Rebuild frontend as FastAPI + hand-built UI, replacing Gradio

Gradio's default styling no longer matched the bar for HF Space UIs, so
the frontend is now a FastAPI app serving a custom static UI (index.html/
app.js/styles.css) instead of gr.Blocks. Feature-for-feature parity with
the old app: AI script generation, example scripts, paste/upload script,
per-turn speaker/voice editing, voice preview, and CFG/model controls.

Generation progress now streams from Modal via real Server-Sent Events
instead of a client-side guessed timer, using the same stage/status/log
payloads modal_runner.py already emitted. Switches the Space to a Docker
SDK (Dockerfile added, requirements swapped from gradio to fastapi/
uvicorn/scipy) since sdk:gradio no longer applies.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitignore

@@ -58,3 +58,6 @@ run_phase3.py
 # Large sample media hosted externally via GitHub user-attachments CDN
 public/sample-generations/*.mp4
 public/sample-generations/*.wav
+
+# Local working notes (cold-start brief), never committed
+PIPELINE_NOTES.md

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 user
+WORKDIR /home/user/app
+
+COPY --chown=1000:1000 requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=1000:1000 . .
+
+USER 1000
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -3,9 +3,8 @@ title: Conference Generator VibeVoice
 emoji: ⭐
 colorFrom: indigo
 colorTo: red
-sdk: gradio
-sdk_version: "5.44.1"
-app_file: app.py
+sdk: docker
+app_port: 7860
 pinned: false
 ---
 
@@ -100,21 +99,23 @@ VibeVoice leads on preference, realism, and richness among long-form multi-speak
 
 ## Architecture
 
-This project separates the lightweight Gradio frontend (hosted on HF Spaces) from the GPU-heavy model backend (hosted on [Modal](https://modal.com)).
+This project separates the lightweight FastAPI frontend (hosted on HF Spaces as a Docker Space) from the GPU-heavy model backend (hosted on [Modal](https://modal.com)).
 
 ```
-┌──────────────────────┐      ┌─────────────────────────┐
-│  HF Space (Gradio)   │      │   Modal (GPU backend)   │
-│  ─────────────────   │      │   ───────────────────   │
-│  • Prompt UI         │ ───► │  • VibeVoice-1.5B / 7B  │
-│  • Script editor     │      │  • Voice prompt loader  │
-│  • Qwen2.5-Coder 32B │      │  • Long-form synthesis  │
-│    (script writing)  │ ◄─── │  • Returns WAV bytes    │
-└──────────────────────┘      └─────────────────────────┘
+┌──────────────────────────┐      ┌─────────────────────────┐
+│  HF Space (FastAPI +     │      │   Modal (GPU backend)   │
+│  static HTML/CSS/JS)     │      │   ───────────────────   │
+│  ─────────────────────   │      │  • VibeVoice-1.5B / 7B  │
+│  • Prompt UI             │ ───► │  • Voice prompt loader  │
+│  • Script editor         │      │  • Long-form synthesis  │
+│  • Qwen2.5-Coder 32B     │      │  • Streams progress +   │
+│    (script writing)      │ ◄─── │    WAV bytes            │
+│  • SSE progress streaming│      │                          │
+└──────────────────────────┘      └─────────────────────────┘
 ```
 
-- **Frontend** (`app.py`): Gradio UI, script generation via HF Inference API (Qwen2.5-Coder-32B), script parsing, playback.
-- **Backend** (`backend_modal/`, not included in this repo): deployed separately on Modal as a class-based GPU service exposing `generate_podcast`.
+- **Frontend** (`app.py` + `static/`): FastAPI app serving a hand-built static UI (`index.html`/`app.js`/`styles.css`), script generation via HF Inference API (Qwen2.5-Coder-32B), script parsing, and a `/api/generate` SSE endpoint that streams live progress from Modal.
+- **Backend** (`backend_modal/modal_runner.py`): deployed separately on Modal as a class-based GPU service exposing `generate_podcast`. The VibeVoice model code and voice reference WAVs under `backend_modal/` are gitignored; see Running locally.
 
 ---
 
@@ -159,8 +160,10 @@ Required env:
 
 ```
 .
-├── app.py                # Gradio frontend + script generation
-├── requirements.txt      # gradio, modal, huggingface_hub
+├── app.py                # FastAPI frontend + script generation
+├── Dockerfile             # HF Docker Space image
+├── static/                # Hand-built UI (index.html, app.js, styles.css)
+├── requirements.txt      # fastapi, uvicorn, modal, huggingface_hub, numpy, scipy
 ├── public/
 │   ├── images/              # Banner, architecture diagram, screenshots
 │   ├── voices/              # Voice reference clips (Cherry, Chicago, ...)
@@ -177,6 +180,6 @@ Required env:
 - **[VibeVoice](https://github.com/microsoft/VibeVoice)** — Microsoft Research's long-form multi-speaker TTS model
 - **[Qwen2.5-Coder-32B](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct)** — script generation
 - **[Modal](https://modal.com)** — GPU compute for inference
-- **[Gradio](https://gradio.app)** + **[Hugging Face Spaces](https://huggingface.co/spaces)** — frontend hosting
+- **[FastAPI](https://fastapi.tiangolo.com)** + **[Hugging Face Spaces](https://huggingface.co/spaces)** (Docker SDK) — frontend hosting
 
 ---

app.py

@@ -1,11 +1,28 @@
+from __future__ import annotations
+
+import asyncio
+import io
+import json
 import os
 import re
-import gradio as gr
-import modal
+import threading
+import time
 import traceback
+import uuid
+from pathlib import Path
+from typing import Annotated
+
+import modal
+import numpy as np
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse, Response, StreamingResponse
+from fastapi.staticfiles import StaticFiles
 from huggingface_hub import InferenceClient
+from pydantic import BaseModel
+from scipy.io import wavfile
 
 # --- Configuration ---
+ROOT = Path(__file__).resolve().parent
 MODAL_STUB_NAME = "vibevoice-generator"
 MODAL_CLASS_NAME = "VibeVoiceModel"
 
@@ -15,29 +32,24 @@ VOICE_GENDERS = {
     "Mantis": "F", "Sponge": "M", "Starchild": "F",
 }
 AVAILABLE_VOICES = list(VOICE_GENDERS.keys())
-VOICE_DISPLAY = [f"{name} ({g})" for name, g in VOICE_GENDERS.items()]
-DEFAULT_SPEAKERS_DISPLAY = ["Cherry (F)", "Chicago (M)", "Janus (M)", "Mantis (F)"]
-
-
-def voice_display_to_name(display: str) -> str:
-    """Strip gender tag: 'Cherry (F)' -> 'Cherry'"""
-    if display and " (" in display:
-        return display.rsplit(" (", 1)[0]
-    return display
+DEFAULT_SPEAKERS = ["Cherry", "Chicago", "Janus", "Mantis"]
 
 SCRIPT_GEN_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
 SCRIPT_MAX_WORDS = 1000           # AI generation cap
-MAX_SCRIPT_WORDS = 1500           # Hard limit for audio generation (~10 min)
+MAX_SCRIPT_WORDS = 100000         # Effectively uncapped (2026-08-14, Josh) — backend chunking has no
+                                   # real ceiling; the old 20,000 cap was a leftover UI guess that
+                                   # blocked genuine long-form renders below the backend's actual limit
 MAX_TURNS = 50                    # Max conversation turns
+AUDIO_TTL_SECONDS = 900
 
 
 # --- Load example scripts ---
 def load_example_scripts():
-    examples_dir = "text_examples"
+    examples_dir = ROOT / "text_examples"
     example_scripts = []
     example_scripts_natural = []
 
-    if not os.path.exists(examples_dir):
+    if not examples_dir.exists():
         return example_scripts, example_scripts_natural
 
     original_files = [
@@ -52,27 +64,28 @@ def load_example_scripts():
     ]
 
     for txt_file in original_files:
-        file_path = os.path.join(examples_dir, txt_file)
-        natural_file = txt_file.replace(".txt", "_natural.txt")
-        natural_path = os.path.join(examples_dir, natural_file)
+        file_path = examples_dir / txt_file
+        natural_path = examples_dir / txt_file.replace(".txt", "_natural.txt")
 
-        if os.path.exists(file_path):
-            with open(file_path, "r", encoding="utf-8") as f:
-                example_scripts.append(f.read())
+        if file_path.exists():
+            example_scripts.append(file_path.read_text(encoding="utf-8"))
         else:
             example_scripts.append("")
 
-        if os.path.exists(natural_path):
-            with open(natural_path, "r", encoding="utf-8") as f:
-                example_scripts_natural.append(f.read())
+        if natural_path.exists():
+            example_scripts_natural.append(natural_path.read_text(encoding="utf-8"))
         else:
-            example_scripts_natural.append(
-                example_scripts[-1] if example_scripts else ""
-            )
+            example_scripts_natural.append(example_scripts[-1] if example_scripts else "")
 
     return example_scripts, example_scripts_natural
 
 
+EXAMPLE_NAMES = [
+    "AI TED Talk", "Political Speech",
+    "Finance IPO", "Telehealth",
+    "Military Briefing", "Oil & Energy",
+    "Game Dev Meeting", "Product Review",
+]
 SCRIPT_SPEAKER_COUNTS = [1, 1, 2, 2, 3, 3, 4, 4]
 EXAMPLE_SCRIPTS, EXAMPLE_SCRIPTS_NATURAL = load_example_scripts()
 
@@ -180,16 +193,6 @@ def turns_to_script(turns: list[dict]) -> str:
     return "\n\n".join(lines)
 
 
-def estimate_duration(turns: list[dict]) -> str:
-    total_words = sum(len(t.get("text", "").split()) for t in turns)
-    if total_words == 0:
-        return ""
-    minutes = total_words / 150
-    if minutes < 1:
-        return f"~{int(minutes * 60)}s"
-    return f"~{minutes:.1f}m"
-
-
 # --- AI Script Generation ---
 
 hf_token = os.environ.get("HF_TOKEN")
@@ -309,15 +312,15 @@ def _extract_genders(raw: str) -> tuple[str, dict[int, str]]:
     return cleaned, genders
 
 
-def assign_voices_by_gender(genders: dict[int, str], num_speakers: int) -> list[str]:
-    """Return a list of 4 voice-display strings, picking matching-gender voices without duplicates.
+def assign_voices_by_gender(genders: dict[int, str], num_speakers: int) -> list[str | None]:
+    """Return a list of 4 plain voice names, picking matching-gender voices without duplicates.
 
-    Falls back to DEFAULT_SPEAKERS_DISPLAY if no gender info for a slot.
+    Falls back to DEFAULT_SPEAKERS if no gender info for a slot.
     """
     female_pool = [v for v in AVAILABLE_VOICES if VOICE_GENDERS.get(v) == "F"]
     male_pool = [v for v in AVAILABLE_VOICES if VOICE_GENDERS.get(v) == "M"]
     used: set[str] = set()
-    chosen: list[str] = []
+    chosen: list[str | None] = []
 
     for i in range(4):
         slot = i + 1
@@ -326,16 +329,15 @@ def assign_voices_by_gender(genders: dict[int, str], num_speakers: int) -> list[
             pool = female_pool if g == "F" else (male_pool if g == "M" else AVAILABLE_VOICES)
             pick = next((v for v in pool if v not in used), None)
             if pick is None:
-                # exhausted preferred pool — fall back to any unused voice
                 pick = next((v for v in AVAILABLE_VOICES if v not in used), AVAILABLE_VOICES[0])
             used.add(pick)
-            chosen.append(f"{pick} ({VOICE_GENDERS.get(pick, '?')})")
+            chosen.append(pick)
         else:
-            chosen.append(DEFAULT_SPEAKERS_DISPLAY[i] if i < len(DEFAULT_SPEAKERS_DISPLAY) else None)
+            chosen.append(DEFAULT_SPEAKERS[i] if i < len(DEFAULT_SPEAKERS) else None)
     return chosen
 
 
-def generate_script_from_prompt(prompt: str) -> tuple[list[dict], int, str, list[str]]:
+def generate_script_from_prompt(prompt: str) -> tuple[list[dict], int, str, list[str | None]]:
     """Returns (turns, num_speakers, title, voice_selections)."""
     system = SCRIPT_SYSTEM_PROMPT.format(max_words=SCRIPT_MAX_WORDS)
     response = llm_client.chat_completion(
@@ -408,6 +410,24 @@ def generate_parody_story(prompt: str) -> list[str]:
         return ["Generating your audio... hang tight!"]
 
 
+# --- Precomputed example index (parsed once at startup) ---
+def _build_examples_index() -> list[dict]:
+    index = []
+    for i, name in enumerate(EXAMPLE_NAMES):
+        script = EXAMPLE_SCRIPTS_NATURAL[i] if i < len(EXAMPLE_SCRIPTS_NATURAL) else ""
+        turns = parse_script_to_turns(script)
+        num = SCRIPT_SPEAKER_COUNTS[i] if i < len(SCRIPT_SPEAKER_COUNTS) else 1
+        voices = (AVAILABLE_VOICES[:num] + [None, None, None, None])[:4]
+        index.append({
+            "id": i, "title": name, "turns": turns,
+            "num_speakers": num, "voices": voices,
+        })
+    return index
+
+
+EXAMPLES_INDEX = _build_examples_index()
+
+
 # --- Modal Connection ---
 try:
     RemoteVibeVoiceModel = modal.Cls.from_name(MODAL_STUB_NAME, MODAL_CLASS_NAME)
@@ -420,834 +440,237 @@ except modal.exception.NotFoundError:
     remote_generate_function = None
 
 
-# --- Theme & CSS ---
-theme = gr.themes.Ocean(
-    primary_hue="indigo",
-    secondary_hue="fuchsia",
-    neutral_hue="slate",
-).set(button_large_radius="*radius_sm")
-
-SPEAKER_COLORS = ["#6366f1", "#ec4899", "#22c55e", "#f59e0b"]
-
-CUSTOM_CSS = """
-/* ---- Conversation scroll container ---- */
-.conversation-scroll {
-    max-height: 480px;
-    overflow-y: auto;
-    border: 1px solid var(--border-color-primary);
-    border-radius: 10px;
-    padding: 10px;
-    background: var(--background-fill-secondary);
-}
-.conversation-scroll::-webkit-scrollbar { width: 6px; }
-.conversation-scroll::-webkit-scrollbar-thumb {
-    background: var(--border-color-primary);
-    border-radius: 3px;
-}
+def _encode_wav(sample_rate: int, audio: np.ndarray) -> bytes:
+    audio = np.asarray(audio)
+    if audio.dtype.kind == "f":
+        audio = np.clip(audio, -1.0, 1.0)
+        audio = (audio * 32767).astype(np.int16)
+    elif audio.dtype != np.int16:
+        audio = audio.astype(np.int16)
+    buf = io.BytesIO()
+    wavfile.write(buf, sample_rate, audio)
+    return buf.getvalue()
 
-/* ---- Speaker color bars ---- */
-""" + "\n".join(f"""
-.speaker-{i+1} {{
-    border-left: 4px solid {c} !important;
-    padding-left: 10px !important;
-    margin-bottom: 6px !important;
-    border-radius: 8px !important;
-    background: {c}08 !important;
-}}""" for i, c in enumerate(SPEAKER_COLORS)) + """
-
-/* ---- Voice settings row ---- */
-.voice-row {
-    border: 1px solid var(--border-color-primary);
-    border-radius: 10px;
-    padding: 12px 16px;
-    background: var(--background-fill-secondary);
-}
 
-/* ---- Example pill buttons ---- */
-.example-btn button {
-    border-radius: 20px !important;
-    font-size: 0.85em !important;
-}
+AUDIO_STORE: dict[str, tuple[float, bytes]] = {}
 
-/* ---- CTA buttons ---- */
-.cta-btn button {
-    border-radius: 10px !important;
-    font-size: 1.1em !important;
-    padding: 14px 24px !important;
-    letter-spacing: 0.02em;
-}
 
-/* ---- Status text (inline, no chrome) ---- */
-.status-text {
-    font-style: italic;
-    opacity: 0.8;
-    padding: 8px 0;
-    min-height: 0 !important;
-}
+def _prune_audio_store() -> None:
+    now = time.time()
+    stale = [k for k, (ts, _) in AUDIO_STORE.items() if now - ts > AUDIO_TTL_SECONDS]
+    for k in stale:
+        AUDIO_STORE.pop(k, None)
 
-/* ---- Empty state ---- */
-.empty-state {
-    text-align: center;
-    padding: 48px 20px !important;
-    opacity: 0.6;
-}
 
-/* ---- Generation status banner ---- */
-.gen-status {
-    border-radius: 12px;
-    padding: 18px 24px;
-    margin-top: 10px;
-    text-align: center;
-    font-size: 1.05em;
-    min-height: 0;
-}
-.gen-status-active {
-    border: 2px solid #6366f1;
-    background: linear-gradient(
-        90deg,
-        rgba(99, 102, 241, 0.05) 0%,
-        rgba(99, 102, 241, 0.18) 30%,
-        rgba(236, 72, 153, 0.14) 50%,
-        rgba(99, 102, 241, 0.18) 70%,
-        rgba(99, 102, 241, 0.05) 100%
-    );
-    background-size: 300% 100%;
-    animation: gradient-sweep 2.5s ease-in-out infinite, border-glow 2s ease-in-out infinite;
-    box-shadow: 0 0 15px rgba(99, 102, 241, 0.15), 0 0 30px rgba(99, 102, 241, 0.05);
-}
-@keyframes gradient-sweep {
-    0% { background-position: 100% 0; }
-    50% { background-position: 0% 0; }
-    100% { background-position: 100% 0; }
-}
-@keyframes border-glow {
-    0%, 100% {
-        border-color: #6366f1;
-        box-shadow: 0 0 15px rgba(99, 102, 241, 0.15), 0 0 30px rgba(99, 102, 241, 0.05);
-    }
-    33% {
-        border-color: #ec4899;
-        box-shadow: 0 0 15px rgba(236, 72, 153, 0.2), 0 0 30px rgba(236, 72, 153, 0.08);
+# ========================================================
+# FASTAPI APP
+# ========================================================
+
+app = FastAPI(title="VibeVoice Conference Generator")
+app.mount("/static", StaticFiles(directory=ROOT / "static"), name="static")
+app.mount("/public", StaticFiles(directory=ROOT / "public"), name="public")
+
+
+@app.get("/", include_in_schema=False)
+async def index() -> FileResponse:
+    return FileResponse(ROOT / "static" / "index.html")
+
+
+@app.get("/api/status")
+async def api_status() -> dict:
+    return {"backend": "ready" if remote_generate_function is not None else "offline"}
+
+
+@app.get("/api/models")
+async def api_models() -> list[str]:
+    return AVAILABLE_MODELS
+
+
+@app.get("/api/voices")
+async def api_voices() -> list[dict]:
+    return [
+        {"name": name, "gender": VOICE_GENDERS[name], "preview_url": f"/public/voices/{name}.mp3"}
+        for name in AVAILABLE_VOICES
+    ]
+
+
+@app.get("/api/examples")
+async def api_examples() -> list[dict]:
+    return EXAMPLES_INDEX
+
+
+@app.post("/api/parse-script")
+async def api_parse_script(
+    text: Annotated[str, Form()] = "",
+    file: Annotated[UploadFile | None, File()] = None,
+) -> dict:
+    script = ""
+    if file is not None and file.filename:
+        raw = await file.read()
+        script = raw.decode("utf-8", errors="replace")
+        await file.close()
+    if not script.strip():
+        script = text or ""
+    if not script.strip():
+        raise HTTPException(status_code=400, detail="Paste a script or upload a .txt file first.")
+
+    turns = parse_script_to_turns(script)
+    if not turns:
+        raise HTTPException(status_code=400, detail="Couldn't find any dialogue in that script.")
+
+    total_words = sum(len(t["text"].split()) for t in turns)
+    num = max(1, min(4, max(t["speaker"] for t in turns)))
+    voices = (AVAILABLE_VOICES[:num] + [None, None, None, None])[:4]
+
+    return {
+        "turns": turns,
+        "num_speakers": num,
+        "title": "Uploaded Script",
+        "voices": voices,
+        "word_count": total_words,
+        "over_limit": total_words > MAX_SCRIPT_WORDS,
     }
-    66% {
-        border-color: #22c55e;
-        box-shadow: 0 0 15px rgba(34, 197, 94, 0.2), 0 0 30px rgba(34, 197, 94, 0.08);
+
+
+class ScriptPromptRequest(BaseModel):
+    prompt: str
+
+
+@app.post("/api/generate-script")
+async def api_generate_script(payload: ScriptPromptRequest) -> dict:
+    prompt = (payload.prompt or "").strip()
+    if not prompt:
+        raise HTTPException(status_code=400, detail="Please enter a prompt.")
+
+    try:
+        script_result, parody_lines = await asyncio.gather(
+            asyncio.to_thread(generate_script_from_prompt, prompt),
+            asyncio.to_thread(generate_parody_story, prompt),
+        )
+    except Exception as e:
+        print(f"Script generation error: {e}")
+        traceback.print_exc()
+        msg = str(e)
+        if "api_key" in msg or "log in" in msg or "token" in msg.lower():
+            raise HTTPException(status_code=502, detail="HF_TOKEN not configured. Add it in Space Settings.")
+        raise HTTPException(status_code=502, detail=f"Error: {msg[:200]}")
+
+    turns, detected, title, voice_picks = script_result
+    if not turns:
+        raise HTTPException(status_code=422, detail="Empty result — try a more descriptive prompt.")
+
+    voices = list(voice_picks)[:4]
+    while len(voices) < 4:
+        voices.append(None)
+
+    return {
+        "turns": turns,
+        "num_speakers": detected,
+        "title": title,
+        "voices": voices,
+        "parody_lines": parody_lines,
     }
-}
-"""
-
-
-# --- Status helpers ---
-AUDIO_LABEL_DEFAULT = "Generated Audio"
-PRIMARY_STAGE_MESSAGES = {
-    "connecting": ("Submitted", "Provisioning GPU resources... cold starts can take up to a minute."),
-    "queued": ("Queued", "Worker is spinning up. Cold starts may take 30-60 seconds."),
-    "loading_model": ("Loading Model", "Streaming VibeVoice weights to the GPU."),
-    "loading_voices": ("Loading Voices", None),
-    "preparing_inputs": ("Preparing", "Formatting the conversation for the model."),
-    "generating_audio": ("Generating", "Synthesizing speech — this is the longest step."),
-    "processing_audio": ("Finalizing", "Converting tensors into a playable waveform."),
-    "complete": ("Complete", "Press play below or download your audio."),
-    "error": ("Error", "Check the log for details."),
-}
-AUDIO_STAGE_LABELS = {
-    "connecting": "Audio (requesting GPU...)",
-    "queued": "Audio (GPU warming up...)",
-    "loading_model": "Audio (loading model...)",
-    "loading_voices": "Audio (loading voices...)",
-    "preparing_inputs": "Audio (preparing...)",
-    "generating_audio": "Audio (generating...)",
-    "processing_audio": "Audio (finalizing...)",
-    "error": "Audio (error)",
-}
 
 
-def build_status_html(stage: str, status_line: str) -> str:
-    """Build an HTML status banner for the generation progress."""
-    title, default_desc = PRIMARY_STAGE_MESSAGES.get(stage, ("Working", "Processing..."))
-    desc = status_line or default_desc or ""
-
-    if stage == "complete":
-        icon = '<span style="color:#22c55e; font-size:1.4em; vertical-align:middle;">&#10003;</span>'
-        cls = "gen-status"
-    elif stage == "error":
-        icon = '<span style="color:#ef4444; font-size:1.4em; vertical-align:middle;">&#10007;</span>'
-        cls = "gen-status"
-    else:
-        # Pulsing animated dot
-        icon = (
-            '<span style="display:inline-block; width:12px; height:12px; '
-            'border-radius:50%; background:#6366f1; vertical-align:middle; '
-            'animation: dot-pulse 1.2s ease-in-out infinite;"></span>'
+class GenerateRequest(BaseModel):
+    model: str
+    num_speakers: int
+    turns: list[dict]
+    speakers: list[str | None]
+    cfg_scale: float
+
+
+@app.post("/api/generate")
+async def api_generate(payload: GenerateRequest) -> StreamingResponse:
+    if remote_generate_function is None:
+        raise HTTPException(status_code=503, detail="Modal backend is offline.")
+
+    script = turns_to_script(payload.turns)
+    if not script.strip():
+        raise HTTPException(status_code=400, detail="Add dialogue before generating.")
+
+    word_count = len(script.split())
+    if word_count > MAX_SCRIPT_WORDS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Script too long: {word_count} words (max {MAX_SCRIPT_WORDS}). Shorten some turns.",
         )
-        cls = "gen-status gen-status-active"
-
-    return (
-        f'<style>@keyframes dot-pulse {{ 0%,100% {{ opacity:1; transform:scale(1); }} 50% {{ opacity:0.4; transform:scale(0.7); }} }}</style>'
-        f'<div class="{cls}">'
-        f'{icon} <strong style="font-size:1.1em;">{title}</strong>'
-        f'<br><span style="opacity:0.7; font-size:0.9em;">{desc}</span>'
-        f'</div>'
+
+    speakers = (list(payload.speakers) + [None, None, None, None])[:4]
+
+    async def event_stream():
+        _prune_audio_store()
+        loop = asyncio.get_event_loop()
+        q: asyncio.Queue = asyncio.Queue()
+        sentinel = object()
+
+        def worker():
+            try:
+                for update in remote_generate_function.remote_gen(
+                    num_speakers=payload.num_speakers,
+                    script=script,
+                    speaker_1=speakers[0],
+                    speaker_2=speakers[1],
+                    speaker_3=speakers[2],
+                    speaker_4=speakers[3],
+                    cfg_scale=payload.cfg_scale,
+                    model_name=payload.model,
+                ):
+                    loop.call_soon_threadsafe(q.put_nowait, update)
+            except Exception as e:
+                loop.call_soon_threadsafe(q.put_nowait, {
+                    "stage": "error",
+                    "status": "Inference failed.",
+                    "log": f"{e}\n\n{traceback.format_exc()}",
+                })
+            finally:
+                loop.call_soon_threadsafe(q.put_nowait, sentinel)
+
+        threading.Thread(target=worker, daemon=True).start()
+
+        while True:
+            item = await q.get()
+            if item is sentinel:
+                break
+            if not item:
+                yield ": keep-alive\n\n"
+                continue
+
+            event = dict(item)
+            audio_payload = event.pop("audio", None)
+            if audio_payload is not None:
+                sample_rate, audio_array = audio_payload
+                wav_bytes = _encode_wav(sample_rate, audio_array)
+                audio_id = uuid.uuid4().hex
+                AUDIO_STORE[audio_id] = (time.time(), wav_bytes)
+                event["audio_id"] = audio_id
+                event["audio_duration"] = len(audio_array) / float(sample_rate)
+            yield f"data: {json.dumps(event)}\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
+@app.get("/api/audio/{audio_id}")
+async def api_audio(audio_id: str) -> Response:
+    entry = AUDIO_STORE.get(audio_id)
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Audio not found or expired.")
+    _, wav_bytes = entry
+    return Response(
+        content=wav_bytes,
+        media_type="audio/wav",
+        headers={"Content-Disposition": 'attachment; filename="conference.wav"'},
     )
 
 
-# ========================================================
-# BUILD INTERFACE
-# ========================================================
+@app.get("/health")
+async def health() -> dict:
+    return {"status": "healthy" if remote_generate_function is not None else "backend offline"}
+
 
-def create_demo_interface():
-    with gr.Blocks(
-        title="VibeVoice - Conference Generator",
-        theme=theme,
-        css=CUSTOM_CSS,
-    ) as interface:
-
-        # --- State ---
-        turns_state = gr.State([])
-        script_title_state = gr.State("")
-        parody_lines_state = gr.State([])  # funny loading story for audio generation
-        # Current voice selection per speaker slot (list of 4 display strings like "Cherry (F)")
-        voice_selections_state = gr.State(list(DEFAULT_SPEAKERS_DISPLAY))
-
-        # ---- BANNER ----
-        gr.HTML("""
-        <div style="width:100%; margin-bottom:12px;">
-            <img src="https://huggingface.co/spaces/ACloudCenter/Conference-Generator-VibeVoice/resolve/main/public/images/banner.png"
-                 style="width:100%; height:auto; border-radius:14px; box-shadow:0 8px 32px rgba(0,0,0,0.25);"
-                 alt="VibeVoice Banner">
-        </div>
-        """)
-
-        with gr.Tabs():
-            # ==================== GENERATE TAB ====================
-            with gr.Tab("Generate"):
-
-                # ---- STEP 1: DESCRIBE ----
-                gr.HTML("""
-                <p style="margin:0 0 4px 0; opacity:0.65; font-size:0.9em;">
-                    Describe any scenario and AI writes the script. Then edit, assign voices, and generate audio.
-                </p>
-                """)
-                script_prompt = gr.Textbox(
-                    label="Describe your conversation",
-                    placeholder="A wizard and an orc debating battle strategy before a siege...",
-                    lines=2,
-                    max_lines=3,
-                )
-                generate_script_btn = gr.Button(
-                    "Write Script with AI", variant="primary",
-                    size="lg", elem_classes="cta-btn",
-                )
-                script_gen_status = gr.HTML(value="", elem_classes="status-text")
-
-                # ---- EXAMPLES ----
-                example_names = [
-                    "AI TED Talk", "Political Speech",
-                    "Finance IPO", "Telehealth",
-                    "Military Briefing", "Oil & Energy",
-                    "Game Dev Meeting", "Product Review",
-                ]
-                with gr.Row():
-                    example_buttons = []
-                    for name in example_names:
-                        btn = gr.Button(name, size="sm", variant="secondary",
-                                        elem_classes="example-btn", min_width=80)
-                        example_buttons.append(btn)
-
-                # ---- STEP 2: SCRIPT EDITOR ----
-                with gr.Row():
-                    script_title_display = gr.HTML(value="<h3 style='margin:0'>Script</h3>")
-                    duration_display = gr.HTML(value="")
-
-                with gr.Column(elem_classes="conversation-scroll"):
-                    @gr.render(inputs=[turns_state, voice_selections_state])
-                    def render_turns(turns, voice_sels):
-                        if not turns:
-                            gr.Markdown(
-                                "Your conversation will appear here.\n\n"
-                                "Type a prompt above and click **Write Script with AI**, "
-                                "or pick an example to get started.",
-                                elem_classes="empty-state",
-                            )
-                            return
-
-                        # Build speaker choice labels from the CURRENT voice selections,
-                        # so changing a Voice dropdown below propagates to the tags above.
-                        speaker_choices = []
-                        for i in range(4):
-                            sel = voice_sels[i] if voice_sels and i < len(voice_sels) else None
-                            if sel:
-                                # sel looks like "Cherry (F)" — display directly
-                                speaker_choices.append(f"Speaker {i+1} - {sel}")
-                            else:
-                                speaker_choices.append(f"Speaker {i+1}")
-
-                        for idx, turn in enumerate(turns):
-                            spk_num = turn["speaker"]
-                            color_class = f"speaker-{spk_num}" if 1 <= spk_num <= 4 else "speaker-1"
-                            spk_value = speaker_choices[spk_num - 1] if 1 <= spk_num <= 4 else speaker_choices[0]
-
-                            with gr.Row(key=f"turn-{idx}", elem_classes=color_class):
-                                spk_dd = gr.Dropdown(
-                                    choices=speaker_choices,
-                                    value=spk_value,
-                                    label="",
-                                    scale=1, min_width=115,
-                                    container=False,
-                                    key=f"spk-{idx}",
-                                )
-                                txt = gr.Textbox(
-                                    value=turn["text"],
-                                    label="",
-                                    lines=2, max_lines=8,
-                                    scale=6,
-                                    container=False,
-                                    key=f"txt-{idx}",
-                                )
-                                del_btn = gr.Button(
-                                    "X", size="sm", variant="stop",
-                                    scale=0, min_width=36, key=f"del-{idx}",
-                                )
-
-                            def on_text_change(new_text, current_turns, i=idx):
-                                if i < len(current_turns):
-                                    current_turns[i]["text"] = new_text
-                                return current_turns
-
-                            txt.change(fn=on_text_change, inputs=[txt, turns_state],
-                                       outputs=[turns_state], queue=False)
-
-                            def on_speaker_change(new_spk, current_turns, i=idx):
-                                if i < len(current_turns):
-                                    # Parse "Speaker 2 - Chicago (M)" -> 2
-                                    m = re.match(r"Speaker (\d+)", new_spk)
-                                    if m:
-                                        current_turns[i]["speaker"] = int(m.group(1))
-                                return current_turns
-
-                            spk_dd.change(fn=on_speaker_change, inputs=[spk_dd, turns_state],
-                                          outputs=[turns_state], queue=False)
-
-                            def on_delete(current_turns, i=idx):
-                                if i < len(current_turns):
-                                    current_turns.pop(i)
-                                return current_turns
-
-                            del_btn.click(fn=on_delete, inputs=[turns_state],
-                                          outputs=[turns_state])
-
-                add_turn_btn = gr.Button("+ Add Turn", size="sm", variant="secondary")
-
-                # ---- STEP 3: VOICE & MODEL ----
-                num_speakers = gr.Slider(
-                    minimum=1, maximum=4, value=2, step=1, visible=False,
-                )
-
-                with gr.Group(elem_classes="voice-row"):
-                    with gr.Row():
-                        model_dropdown = gr.Dropdown(
-                            choices=AVAILABLE_MODELS,
-                            value=AVAILABLE_MODELS[0],
-                            label="Model",
-                            scale=1,
-                        )
-                        speaker_selections = []
-                        for i in range(4):
-                            s = gr.Dropdown(
-                                choices=VOICE_DISPLAY,
-                                value=DEFAULT_SPEAKERS_DISPLAY[i] if i < len(DEFAULT_SPEAKERS_DISPLAY) else None,
-                                label=f"Voice {i+1}",
-                                visible=(i < 2),
-                                scale=1,
-                            )
-                            speaker_selections.append(s)
-                    with gr.Row():
-                        cfg_scale = gr.Slider(
-                            minimum=1.0, maximum=2.0, value=2.0, step=0.05,
-                            label="CFG Scale",
-                        )
-
-                # ---- Voice preview ----
-                with gr.Accordion("🔊 Preview voices before generating", open=False):
-                    with gr.Row():
-                        preview_voice = gr.Dropdown(
-                            choices=VOICE_DISPLAY,
-                            value=VOICE_DISPLAY[0] if VOICE_DISPLAY else None,
-                            label="Pick a voice",
-                            scale=2,
-                        )
-                        preview_audio = gr.Audio(
-                            label="Sample",
-                            value=os.path.join("public", "voices", f"{AVAILABLE_VOICES[0]}.mp3") if AVAILABLE_VOICES else None,
-                            autoplay=False,
-                            show_download_button=False,
-                            scale=3,
-                        )
-
-                    def _load_preview(display: str):
-                        name = voice_display_to_name(display) if display else None
-                        if not name:
-                            return gr.update(value=None)
-                        path = os.path.join("public", "voices", f"{name}.mp3")
-                        if not os.path.exists(path):
-                            return gr.update(value=None)
-                        return gr.update(value=path)
-
-                    preview_voice.change(
-                        fn=_load_preview,
-                        inputs=[preview_voice],
-                        outputs=[preview_audio],
-                        queue=False,
-                    )
-
-                # ---- STEP 4: GENERATE ----
-                generate_btn = gr.Button(
-                    "Generate Conference Audio", size="lg", variant="primary",
-                    elem_classes="cta-btn",
-                )
-                primary_status = gr.HTML(value="", elem_classes="gen-status")
-
-                # ---- OUTPUT ----
-                complete_audio_output = gr.Audio(
-                    label=AUDIO_LABEL_DEFAULT,
-                    type="numpy",
-                    autoplay=False,
-                    show_download_button=True,
-                )
-                with gr.Accordion("Generation Log", open=False):
-                    log_output = gr.Textbox(
-                        label="Log", lines=8, max_lines=15, interactive=False,
-                    )
-
-                # ==================== EVENT HANDLERS ====================
-
-                def update_speaker_visibility(n):
-                    return [gr.update(visible=(i < n)) for i in range(4)]
-
-                num_speakers.change(
-                    fn=update_speaker_visibility,
-                    inputs=[num_speakers],
-                    outputs=speaker_selections,
-                )
-
-                # Two-way sync: when a Voice dropdown changes, update voice_selections_state
-                # so the script turn tags re-render with the new voice label.
-                def _sync_voice_state(*voices):
-                    return list(voices)
-
-                for sel in speaker_selections:
-                    sel.change(
-                        fn=_sync_voice_state,
-                        inputs=speaker_selections,
-                        outputs=[voice_selections_state],
-                        queue=False,
-                    )
-
-                def add_turn(turns):
-                    if len(turns) >= MAX_TURNS:
-                        gr.Warning(f"Maximum {MAX_TURNS} turns reached.")
-                        return turns, estimate_duration(turns)
-                    if not turns:
-                        next_speaker = 1
-                    else:
-                        max_spk = max(t["speaker"] for t in turns)
-                        last = turns[-1]["speaker"]
-                        next_speaker = (last % max_spk) + 1
-                    turns.append({"speaker": next_speaker, "text": ""})
-                    return turns, estimate_duration(turns)
-
-                add_turn_btn.click(
-                    fn=add_turn,
-                    inputs=[turns_state],
-                    outputs=[turns_state, duration_display],
-                )
-
-                turns_state.change(
-                    fn=lambda turns: estimate_duration(turns),
-                    inputs=[turns_state],
-                    outputs=[duration_display],
-                    queue=False,
-                )
-
-                # --- AI Script Generation ---
-                import time as _time
-                import threading as _threading
-
-                SCRIPT_GEN_MESSAGES = [
-                    "Writing script...",
-                    "Still generating...",
-                    "Making magic happen...",
-                    "Bossing around robot writers...",
-                    "Entering the matrix...",
-                    "Crafting dialogue...",
-                    "Teaching AI to be dramatic...",
-                    "Consulting the creative robots...",
-                    "Spilling digital ink...",
-                    "Herding AI cats into a script...",
-                    "Negotiating with the muse...",
-                    "Downloading inspiration...",
-                    "Warming up the plot engine...",
-                    "Shaking the idea tree...",
-                    "Feeding the word machine...",
-                    "Polishing virtual microphones...",
-                    "Rehearsing in the AI green room...",
-                    "Bribing the creativity daemon...",
-                    "Untangling narrative spaghetti...",
-                    "Summoning fictional characters...",
-                    "Tuning the dialogue generator...",
-                    "Spinning up the story factory...",
-                    "Convincing electrons to be eloquent...",
-                    "Wrangling syllables into sentences...",
-                    "Asking the AI to use its inside voice...",
-                    "Loading dramatic tension...",
-                    "Calibrating the sass levels...",
-                    "Assembling words in the right order...",
-                    "Generating witty banter...",
-                    "Overthinking your prompt (in a good way)...",
-                    "Running it by the robot editor...",
-                    "Adding a pinch of personality...",
-                    "Almost done, probably...",
-                    "Spell-checking the AI's homework...",
-                    "Giving characters their motivation...",
-                    "Practicing dramatic pauses...",
-                    "Reticulating splines (just kidding)...",
-                    "The AI is in the zone...",
-                    "Finalizing the masterpiece...",
-                    "One more revision, we promise...",
-                ]
-
-                # outputs: turns, duration, status, title, audio, script_btn, gen_btn, parody, num_speakers, *4 voices, voice_selections_state
-                def _script_no_change(status_html):
-                    return (gr.update(), gr.update(), status_html,
-                            gr.update(), gr.update(),
-                            gr.update(), gr.update(),
-                            gr.update(),
-                            gr.update(), *[gr.update()] * 4, gr.update())
-
-                def _script_buttons_busy(status_html):
-                    return (gr.update(), gr.update(), status_html,
-                            gr.update(), gr.update(),
-                            gr.update(interactive=False, value="Writing..."),
-                            gr.update(interactive=False),
-                            gr.update(),
-                            gr.update(), *[gr.update()] * 4, gr.update())
-
-                def _script_buttons_ready(status_html=""):
-                    return (gr.update(), gr.update(), status_html,
-                            gr.update(), gr.update(),
-                            gr.update(interactive=True, value="Write Script with AI"),
-                            gr.update(interactive=True),
-                            gr.update(),
-                            gr.update(), *[gr.update()] * 4, gr.update())
-
-                def _make_title_html(title):
-                    if title:
-                        return f"<h3 style='margin:0'>{title}</h3>"
-                    return "<h3 style='margin:0'>Script</h3>"
-
-                def on_generate_script(prompt):
-                    if not prompt or not prompt.strip():
-                        gr.Warning("Please enter a prompt.")
-                        yield _script_no_change("")
-                        return
-
-                    # Disable both buttons
-                    yield _script_buttons_busy(f"<em>{SCRIPT_GEN_MESSAGES[0]}</em>")
-
-                    # Run script + parody generation in threads
-                    result = {}
-                    error = {}
-                    parody_result = {"lines": []}
-
-                    def _run():
-                        try:
-                            result["data"] = generate_script_from_prompt(prompt.strip())
-                        except Exception as e:
-                            error["err"] = e
-
-                    def _run_parody():
-                        parody_result["lines"] = generate_parody_story(prompt.strip())
-
-                    thread = _threading.Thread(target=_run, daemon=True)
-                    parody_thread = _threading.Thread(target=_run_parody, daemon=True)
-                    thread.start()
-                    parody_thread.start()
-
-                    msg_idx = 1
-                    while thread.is_alive():
-                        _time.sleep(3)
-                        msg = SCRIPT_GEN_MESSAGES[msg_idx % len(SCRIPT_GEN_MESSAGES)]
-                        msg_idx += 1
-                        yield _script_buttons_busy(f"<em>{msg}</em>")
-
-                    thread.join()
-                    parody_thread.join()
-
-                    if "err" in error:
-                        e = error["err"]
-                        print(f"Script generation error: {e}")
-                        traceback.print_exc()
-                        msg = str(e)
-                        if "api_key" in msg or "log in" in msg or "token" in msg.lower():
-                            yield _script_buttons_ready("<em>HF_TOKEN not configured. Add it in Space Settings.</em>")
-                        else:
-                            yield _script_buttons_ready(f"<em>Error: {msg[:200]}</em>")
-                        return
-
-                    turns, detected, title, voice_picks = result["data"]
-                    if not turns:
-                        yield _script_buttons_ready("<em>Empty result — try a more descriptive prompt.</em>")
-                        return
-
-                    # voice_picks is a list of 4 display strings from assign_voices_by_gender
-                    voices = list(voice_picks)
-                    while len(voices) < 4:
-                        voices.append(None)
-
-                    # Strip "Speaker N - " style prefixes so the Voice dropdowns get clean values.
-                    # assign_voices_by_gender already returns display strings like "Cherry (F)".
-                    clean_voices = voices[:4]
-
-                    audio_label = title if title else AUDIO_LABEL_DEFAULT
-                    yield (turns, estimate_duration(turns), "",
-                           _make_title_html(title),
-                           gr.update(label=audio_label),
-                           gr.update(interactive=True, value="Write Script with AI"),
-                           gr.update(interactive=True),
-                           parody_result["lines"],
-                           detected, *clean_voices, clean_voices)
-
-                generate_script_btn.click(
-                    fn=on_generate_script,
-                    inputs=[script_prompt],
-                    outputs=[turns_state, duration_display, script_gen_status,
-                             script_title_display, complete_audio_output,
-                             generate_script_btn, generate_btn,
-                             parody_lines_state,
-                             num_speakers] + speaker_selections + [voice_selections_state],
-                )
-
-                # --- Load examples ---
-                def load_example(idx):
-                    if idx >= len(EXAMPLE_SCRIPTS):
-                        return [], 2, "", "<h3 style='margin:0'>Script</h3>", gr.update(), *[None] * 4, list(DEFAULT_SPEAKERS_DISPLAY)
-
-                    title = example_names[idx]
-                    script = EXAMPLE_SCRIPTS_NATURAL[idx]
-                    num = SCRIPT_SPEAKER_COUNTS[idx] if idx < len(SCRIPT_SPEAKER_COUNTS) else 1
-                    turns = parse_script_to_turns(script)
-
-                    voices = list(VOICE_DISPLAY[:num])
-                    while len(voices) < 4:
-                        voices.append(None)
-
-                    return (turns, num, estimate_duration(turns),
-                            f"<h3 style='margin:0'>{title}</h3>",
-                            gr.update(label=title),
-                            *voices[:4], voices[:4])
-
-                for idx, btn in enumerate(example_buttons):
-                    btn.click(
-                        fn=lambda i=idx: load_example(i),
-                        inputs=[],
-                        outputs=[turns_state, num_speakers, duration_display,
-                                 script_title_display, complete_audio_output]
-                                + speaker_selections + [voice_selections_state],
-                        queue=False,
-                    )
-
-                # --- Generate audio ---
-                def _gen_yield(status_html, btn_label, btn_interactive, audio_update, log_text):
-                    return (
-                        status_html,
-                        gr.update(value=btn_label, interactive=btn_interactive),
-                        gr.update(interactive=btn_interactive),
-                        audio_update,
-                        log_text,
-                    )
-
-                def generate_podcast_wrapper(
-                    model_choice, num_speakers_val, turns, parody_lines, *speakers_and_params
-                ):
-                    BTN_BUSY = "Generating..."
-                    BTN_READY = "Generate Conference Audio"
-
-                    # Set up parody line cycling
-                    parody_idx = [0]  # mutable counter
-                    def _next_parody():
-                        if not parody_lines:
-                            return None
-                        line = parody_lines[parody_idx[0] % len(parody_lines)]
-                        parody_idx[0] += 1
-                        return line
-
-                    if remote_generate_function is None:
-                        yield _gen_yield(
-                            build_status_html("error", "Modal backend is offline."),
-                            BTN_READY, True,
-                            gr.update(), "ERROR: Modal function not deployed.",
-                        )
-                        return
-
-                    script = turns_to_script(turns)
-                    if not script.strip():
-                        yield _gen_yield(
-                            build_status_html("error", "No script to generate."),
-                            BTN_READY, True,
-                            gr.update(), "Add dialogue before generating.",
-                        )
-                        return
-
-                    word_count = len(script.split())
-                    if word_count > MAX_SCRIPT_WORDS:
-                        yield _gen_yield(
-                            build_status_html("error",
-                                f"Script too long: {word_count} words (max {MAX_SCRIPT_WORDS}). "
-                                "Shorten some turns."),
-                            BTN_READY, True,
-                            gr.update(), f"Script has {word_count} words, max is {MAX_SCRIPT_WORDS}.",
-                        )
-                        return
-
-                    # Disable buttons, show connecting status
-                    first_line = _next_parody() or "Provisioning GPU resources..."
-                    yield _gen_yield(
-                        build_status_html("connecting", first_line),
-                        BTN_BUSY, False,
-                        gr.update(label=AUDIO_STAGE_LABELS.get("connecting", AUDIO_LABEL_DEFAULT)),
-                        "Requesting GPU on Modal.com...",
-                    )
-
-                    try:
-                        speakers = [voice_display_to_name(s) for s in speakers_and_params[:4]]
-                        cfg_scale_val = speakers_and_params[4]
-                        current_log = ""
-                        last_stage = "connecting"
-
-                        for update in remote_generate_function.remote_gen(
-                            num_speakers=int(num_speakers_val),
-                            script=script,
-                            speaker_1=speakers[0],
-                            speaker_2=speakers[1],
-                            speaker_3=speakers[2],
-                            speaker_4=speakers[3],
-                            cfg_scale=cfg_scale_val,
-                            model_name=model_choice,
-                        ):
-                            if not update:
-                                continue
-
-                            if isinstance(update, dict):
-                                audio_payload = update.get("audio")
-                                stage_key = update.get("stage", last_stage) or last_stage
-                                status_line = update.get("status") or "Processing..."
-                                current_log = update.get("log", current_log)
-
-                                audio_label = AUDIO_STAGE_LABELS.get(stage_key,
-                                    f"Audio ({stage_key.replace('_',' ')})")
-                                is_done = stage_key in ("complete", "error")
-                                if stage_key == "complete":
-                                    audio_label = AUDIO_LABEL_DEFAULT
-
-                                audio_update = gr.update(label=audio_label)
-                                if audio_payload is not None:
-                                    audio_update = gr.update(value=audio_payload, label=AUDIO_LABEL_DEFAULT)
-
-                                # Use parody line for active stages, real status for done
-                                if is_done:
-                                    display_line = status_line
-                                else:
-                                    display_line = _next_parody() or status_line
-
-                                yield _gen_yield(
-                                    build_status_html(stage_key, display_line),
-                                    BTN_READY if is_done else BTN_BUSY,
-                                    is_done,
-                                    audio_update,
-                                    current_log,
-                                )
-                                last_stage = stage_key
-                            else:
-                                audio_payload, log_text = (
-                                    update if isinstance(update, (tuple, list)) else (None, str(update))
-                                )
-                                if log_text:
-                                    current_log = log_text
-                                if audio_payload is not None:
-                                    yield _gen_yield(
-                                        build_status_html("complete", "Ready."),
-                                        BTN_READY, True,
-                                        gr.update(value=audio_payload, label=AUDIO_LABEL_DEFAULT),
-                                        current_log,
-                                    )
-                                else:
-                                    display_line = _next_parody() or (
-                                        current_log.splitlines()[-1] if current_log else "Processing...")
-                                    yield _gen_yield(
-                                        build_status_html("generating_audio", display_line),
-                                        BTN_BUSY, False,
-                                        gr.update(), current_log,
-                                    )
-                    except Exception as e:
-                        tb = traceback.format_exc()
-                        print(f"Error calling Modal: {e}")
-                        yield _gen_yield(
-                            build_status_html("error", "Inference failed."),
-                            BTN_READY, True,
-                            gr.update(), f"Error: {e}\n\n{tb}",
-                        )
-
-                generate_btn.click(
-                    fn=generate_podcast_wrapper,
-                    inputs=[model_dropdown, num_speakers, turns_state, parody_lines_state] + speaker_selections + [cfg_scale],
-                    outputs=[primary_status, generate_btn, generate_script_btn, complete_audio_output, log_output],
-                )
-
-            # ==================== ARCHITECTURE TAB ====================
-            with gr.Tab("Architecture"):
-                gr.Markdown("## VibeVoice: A Frontier Open-Source Text-to-Speech Model")
-                gr.Markdown(
-                    """VibeVoice generates expressive, long-form, multi-speaker conversational audio from text.
-                It uses continuous speech tokenizers at an ultra-low 7.5 Hz frame rate and a next-token diffusion
-                framework to synthesize up to 90 minutes of speech with up to 4 distinct speakers."""
-                )
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("""
-### Key Features
-- **Multi-Speaker**: Up to 4 distinct voices
-- **Long-Form**: Up to 90 minutes of audio
-- **Natural Flow**: Turn-taking, interruptions, filler words
-- **Efficient**: 7.5 Hz tokenizers for low compute cost
-
-### Architecture
-1. **Continuous Speech Tokenizers** — Acoustic + Semantic at 7.5 Hz
-2. **Next-Token Diffusion** — LLM context + diffusion generation
-3. **Diffusion Head** — High-fidelity acoustic output
-
-### Models
-- **1.5B** — Fast inference, great for iteration
-- **7B** — Higher fidelity, longer generation time
-                        """)
-                    with gr.Column():
-                        gr.Image(value="public/images/diagram.jpg",
-                                 label="Architecture", show_download_button=False)
-                        gr.Image(value="public/images/chart.png",
-                                 label="Performance", show_download_button=False)
-
-    return interface
-
-
-# --- Main ---
 if __name__ == "__main__":
+    import uvicorn
+
     if remote_generate_function is None:
-        with gr.Blocks(theme=theme) as interface:
-            gr.Markdown("# Configuration Error")
-            gr.Markdown(
-                "Cannot connect to Modal backend. "
-                "Run `modal deploy backend_modal/modal_runner.py` and refresh."
-            )
-        interface.launch()
-    else:
-        interface = create_demo_interface()
-        interface.queue().launch(show_error=True)
+        print("WARNING: Modal function not deployed — run `modal deploy backend_modal/modal_runner.py`.")
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))

backend_modal/modal_runner.py

@@ -1,10 +1,9 @@
+from __future__ import annotations  # keep np.ndarray hints lazy at deploy time
+
+import gc
 import os
 import time
 import threading
-import numpy as np
-import librosa
-import soundfile as sf
-import torch
 from datetime import datetime
 import hashlib
 import json
@@ -38,6 +37,7 @@ image = (
         "ln -s /root/voices /root/vibevoice/voices",
         "ln -s /root/schedule /root/vibevoice/schedule"
     )
+    .env({"PYTORCH_CUDA_ALLOC_CONF": "expandable_segments:True"})  # fights fragmentation across waves
     .add_local_dir("backend_modal/modular", remote_path="/root/modular")
     .add_local_dir("backend_modal/processor", remote_path="/root/processor")
     .add_local_dir("backend_modal/voices", remote_path="/root/voices")
@@ -50,12 +50,21 @@ app = modal.App(
     image=image,
 )
 
+# Heavy imports run only inside the container (deploy-time on a laptop
+# doesn't have torch/numpy/librosa — and doesn't need them)
+with image.imports():
+    import numpy as np
+    import librosa
+    import soundfile as sf
+    import torch
+
 # Create a volume for caching generated audio
 cache_volume = modal.Volume.from_name("vibevoice-cache", create_if_missing=True)
 
 @app.cls(
-    gpu="A100-40GB", 
+    gpu="A100-40GB",
     scaledown_window=300,
+    timeout=3600,  # long-form renders (90-min scripts ~25 min wall) need headroom
     volumes={"/cache": cache_volume}
 )
 class VibeVoiceModel:
@@ -89,7 +98,7 @@ class VibeVoiceModel:
         self.processors = {}
         self.current_model_name = None
         
-        # Load all models directly to GPU (A10G has enough memory)
+        # Load all models directly to GPU (A100-40GB holds both; ~17 GB baseline)
         for name, path in self.model_paths.items():
             print(f" - Loading {name} from {path}")
             proc = VibeVoiceProcessor.from_pretrained(path)
@@ -105,9 +114,14 @@ class VibeVoiceModel:
         
         # Set default model
         self.current_model_name = "VibeVoice-1.5B"
-        
+
         self.setup_voice_presets()
-        print("Model loading complete.")
+        self.ready_at = time.time()  # for cold-start detection in timing reports
+        # VRAM baseline right after model load: requests arriving to a GPU far
+        # above this are hitting a poisoned container (e.g. a cancelled run's
+        # zombie generation thread) and must recycle, not proceed (2026-08-14)
+        self.baseline_alloc = torch.cuda.memory_allocated()
+        print(f"Model loading complete. VRAM baseline: {self.baseline_alloc/1e9:.1f} GB")
 
     def _place_model(self, target_name: str):
         """Both models stay on GPU. Just update the active selection."""
@@ -149,7 +163,8 @@ class VibeVoiceModel:
             "model": model_name,
             "speakers": sorted(speakers),  # Sort for consistency
             "cfg_scale": cfg_scale,
-            "inference_steps": self.inference_steps
+            "inference_steps": self.inference_steps,
+            "pipeline": "chunked-parallel-v1",  # renditions differ from monolithic
         }
         cache_str = json.dumps(cache_data, sort_keys=True)
         return hashlib.sha256(cache_str.encode()).hexdigest()
@@ -228,6 +243,125 @@ class VibeVoiceModel:
             print(f"Error reading audio {audio_path}: {e}")
             return np.array([])
 
+    # ---- chunked-parallel generation (2026-08-14) ----------------------------
+    # Rendering the whole script as ONE sequential generate call is the slow
+    # path (~1.4x slower than realtime). Grouping whole turns into chunks and
+    # rendering them as a BATCH in a single call is ~3x faster at batch-4 with
+    # no measured quality loss (audio-level parity: WER 0.000/0.071/0.000/0.000
+    # solo-vs-batched; seams inaudible with a 0.25 s crossfade). Validation
+    # record: LongFlow experiments/p1_flow_head/NOTES.md, Gate Nights 4-5.
+    CHUNK_TARGET_WORDS = 200          # ~80-90 s of audio per chunk
+    CHUNK_MIN_SCRIPT_WORDS = 350      # below this, monolithic is fine
+    CROSSFADE_S = 0.25                # GN5 ear-validated
+    # Ambitious caps: with OOM backoff (waves split in half and retry), an
+    # overshoot costs one halving, never the job. Validated floors were 8/4.
+    MAX_BATCH = {"VibeVoice-1.5B": 12, "VibeVoice-7B": 6}  # A100-40GB
+
+    @classmethod
+    def _split_turns_into_chunks(cls, turn_lines: list) -> list:
+        """Group whole 'Speaker N:' turn lines into ~CHUNK_TARGET_WORDS chunks.
+
+        Never splits inside a turn (turn boundaries are what keep pacing
+        natural and identity anchored), so each chunk is itself a valid
+        mini-script for the same speaker set.
+        """
+        chunks, cur, cur_words = [], [], 0
+        for line in turn_lines:
+            cur.append(line)
+            cur_words += len(line.split())
+            if cur_words >= cls.CHUNK_TARGET_WORDS:
+                chunks.append("\n".join(cur))
+                cur, cur_words = [], 0
+        if cur:
+            # avoid a tiny trailing chunk: merge into the previous one
+            if chunks and cur_words < cls.CHUNK_TARGET_WORDS // 3:
+                chunks[-1] = chunks[-1] + "\n" + "\n".join(cur)
+            else:
+                chunks.append("\n".join(cur))
+        return chunks
+
+    @classmethod
+    def _crossfade_concat(cls, pieces: list, sample_rate: int) -> np.ndarray:
+        """Concatenate audio pieces with a short linear crossfade at each seam."""
+        pieces = [p for p in pieces if p is not None and len(p) > 0]
+        if not pieces:
+            return np.array([])
+        xf = int(cls.CROSSFADE_S * sample_rate)
+        out = pieces[0]
+        for p in pieces[1:]:
+            n = min(xf, len(out), len(p))
+            if n <= 0:
+                out = np.concatenate([out, p])
+                continue
+            fade = np.linspace(1.0, 0.0, n)
+            seam = out[-n:] * fade + p[:n] * (1.0 - fade)
+            out = np.concatenate([out[:-n], seam, p[n:]])
+        return out
+
+    # ---- detect-and-reroll quality gate (2026-08-14) ---------------------
+    # Transient-babble glitch rate is <1 per 46 min, so the gate must be
+    # CONSERVATIVE: only re-roll on egregious failures, and fail OPEN (any
+    # gate error = pass) so it can never block a render. Metrics per chunk:
+    #   rate     — words/sec of audio; healthy renders measure ~2.2-2.5
+    #   silence  — fraction of 50 ms frames near-silent (drone/stall symptom)
+    #   flatness — mean spectral flatness (static/babble is noise-like, ~1.0;
+    #              speech is ~0.01-0.2)
+    # One reroll attempt per failing chunk on a fresh torch seed; keep the
+    # reroll only if it gates better than the original.
+    GATE_WPS_MIN = 1.2            # slower = audio stretched/droning
+    GATE_WPS_MAX = 4.2            # faster = audio truncated/skipped words
+    GATE_SILENCE_MAX = 0.5        # >50% near-silent frames
+    GATE_FLATNESS_MAX = 0.5       # white noise ≈ 1.0, speech ≪ 0.5
+
+    @classmethod
+    def _chunk_quality(cls, chunk_text: str, audio, sample_rate: int):
+        """Score one rendered chunk. Returns (ok, badness, reason).
+
+        badness is a monotone severity score so a reroll can be compared
+        against the original even when both fail. Fails open on any error.
+        """
+        import re as _re
+        try:
+            if audio is None or len(audio) == 0:
+                return False, float("inf"), "no audio"
+            words = len(_re.sub(r"(?mi)^\s*Speaker\s+\d+\s*:", "", chunk_text).split())
+            dur = len(audio) / sample_rate
+            if words == 0 or dur <= 0:
+                return True, 0.0, "unscorable"
+            wps = words / dur
+
+            frame = int(0.05 * sample_rate)
+            n = (len(audio) // frame) * frame
+            frames = np.asarray(audio[:n], dtype=np.float64).reshape(-1, frame)
+            rms = np.sqrt((frames ** 2).mean(axis=1))
+            overall = rms.mean() or 1e-9
+            silence_frac = float((rms < 0.05 * overall).mean())
+
+            # Spectral flatness on up to 40 evenly-spaced frames (cheap):
+            # geometric/arithmetic mean ratio of the power spectrum.
+            idx = np.linspace(0, len(frames) - 1, min(40, len(frames))).astype(int)
+            spec = np.abs(np.fft.rfft(frames[idx], axis=1)) ** 2 + 1e-12
+            flatness = float(np.exp(np.log(spec).mean(axis=1)).mean()
+                             / spec.mean(axis=1).mean())
+
+            badness = 0.0
+            reasons = []
+            if wps < cls.GATE_WPS_MIN or wps > cls.GATE_WPS_MAX:
+                badness += abs(wps - np.clip(wps, cls.GATE_WPS_MIN, cls.GATE_WPS_MAX))
+                reasons.append(f"rate {wps:.2f} wps")
+            if silence_frac > cls.GATE_SILENCE_MAX:
+                badness += silence_frac - cls.GATE_SILENCE_MAX
+                reasons.append(f"silence {silence_frac:.2f}")
+            if flatness > cls.GATE_FLATNESS_MAX:
+                badness += flatness - cls.GATE_FLATNESS_MAX
+                reasons.append(f"flatness {flatness:.2f}")
+            if reasons:
+                return False, badness, ", ".join(reasons)
+            return True, 0.0, f"ok (wps {wps:.2f}, sil {silence_frac:.2f}, flat {flatness:.3f})"
+        except Exception as gate_err:  # fail open — never block a render
+            print(f"Quality gate error (passing chunk through): {gate_err}")
+            return True, 0.0, "gate error"
+
     @staticmethod
     def _infer_num_speakers_from_script(script: str) -> int:
         """
@@ -338,6 +472,21 @@ class VibeVoiceModel:
             )
             self._place_model(model_name)
 
+            # GPU health check: a poisoned container (zombie thread from a
+            # cancelled run) shows allocated VRAM far above the post-load
+            # baseline. Proceeding would OOM every wave — recycle instead.
+            gc.collect()
+            torch.cuda.empty_cache()
+            alloc = torch.cuda.memory_allocated()
+            baseline = getattr(self, "baseline_alloc", alloc)
+            if alloc > baseline + 6e9:
+                yield self._emit_progress(
+                    stage="error", pct=0,
+                    status="GPU busy from a previous cancelled job — container is restarting. Please retry in about a minute.",
+                    log_text=log_text + "\nGPU poisoned (leftover allocation detected); recycling container.",
+                )
+                os._exit(1)
+
             model = self.models[model_name]
             processor = self.processors[model_name]
             model.set_ddpm_inference_steps(num_steps=self.inference_steps)
@@ -347,7 +496,7 @@ class VibeVoiceModel:
             if not script.strip():
                 raise ValueError("Error: Please provide a script.")
 
-            script = script.replace("'", "'")
+            script = script.replace("’", "'").replace("‘", "'")
 
             if not 1 <= num_speakers <= 4:
                 raise ValueError("Error: Number of speakers must be between 1 and 4.")
@@ -406,68 +555,249 @@ class VibeVoiceModel:
                 log_text=log_text,
             )
 
-            inputs = processor(
-                text=[formatted_script],
-                voice_samples=[voice_samples],
-                padding=True,
-                return_tensors="pt",
-                return_attention_mask=True,
-            ).to(self.device)
+            # ---- chunked-parallel fast path (falls back to monolithic) ------
+            script_words = len(formatted_script.split())
+            chunks = (self._split_turns_into_chunks(formatted_script_lines)
+                      if script_words >= self.CHUNK_MIN_SCRIPT_WORDS else [formatted_script])
+            batch_cap = self.MAX_BATCH.get(model_name, 4)
+            use_parallel = len(chunks) > 1
 
-            log_lines.append("Inputs prepared; starting diffusion generation…")
+            if use_parallel:
+                log_lines.append(
+                    f"Parallel mode: {len(chunks)} chunks, batches of up to {batch_cap}"
+                )
+            else:
+                log_lines.append("Short script: single-pass generation")
             log_text = "\n".join(log_lines)
             yield self._emit_progress(
                 stage="generating_audio",
                 pct=70,
-                status="Running VibeVoice diffusion (this may take 1-2 minutes)…",
+                status="Running VibeVoice diffusion…",
                 log_text=log_text,
             )
 
-            start_time = time.time()
-            result_container = {}
-            exception_container = {}
-
-            def _run_generation():
+            def _generate_batch(text_list):
+                """One batched generate call; returns list of np audio (or None)."""
+                batch_inputs = processor(
+                    text=text_list,
+                    voice_samples=[voice_samples] * len(text_list),
+                    padding=True,
+                    return_tensors="pt",
+                    return_attention_mask=True,
+                ).to(self.device)
+                result, exc = {}, {}
+
+                def _run():
+                    try:
+                        with torch.inference_mode():
+                            result['outputs'] = model.generate(
+                                **batch_inputs,
+                                max_new_tokens=None,
+                                cfg_scale=cfg_scale,
+                                tokenizer=processor.tokenizer,
+                                generation_config={'do_sample': False},
+                                verbose=False,
+                            )
+                    except Exception as gen_err:
+                        # store the MESSAGE, never the exception object: its
+                        # traceback pins every GPU tensor of the failed attempt
+                        # and makes OOM-backoff retries futile (2026-08-14 bug)
+                        exc['error'] = f"{type(gen_err).__name__}: {gen_err}"
+
+                t = threading.Thread(target=_run, daemon=True)
+                t.start()
                 try:
-                    with torch.inference_mode():
-                        result_container['outputs'] = model.generate(
-                            **inputs,
-                            max_new_tokens=None,
-                            cfg_scale=cfg_scale,
-                            tokenizer=processor.tokenizer,
-                            generation_config={'do_sample': False},
-                            verbose=False,
-                        )
-                except Exception as gen_err:
-                    exception_container['error'] = gen_err
-
-            generation_thread = threading.Thread(target=_run_generation, daemon=True)
-            generation_thread.start()
-
-            # Emit keep-alive progress while the heavy generation is running
-            while generation_thread.is_alive():
-                elapsed = time.time() - start_time
-                status_msg = f"Running VibeVoice diffusion… {int(elapsed)}s elapsed"
-                pct_hint = min(88, 70 + int(elapsed // 5))
-                yield self._emit_progress(
-                    stage="generating_audio",
-                    pct=pct_hint,
-                    status=status_msg,
-                    log_text=log_text,
-                )
-                time.sleep(5)
-
-            generation_thread.join()
-            if 'error' in exception_container:
-                raise exception_container['error']
+                    while t.is_alive():
+                        yield None  # keep-alive tick for the caller
+                        time.sleep(5)
+                except GeneratorExit:
+                    # Client cancelled mid-generation. Python cannot kill the
+                    # worker thread, and a surviving thread becomes a zombie
+                    # that eats the GPU for every later request on this warm
+                    # container (observed 2026-08-14). Recycle the container.
+                    print("Run cancelled mid-generation; recycling container "
+                          "so no zombie thread survives.")
+                    os._exit(1)
+                t.join()
+                if 'error' in exc:
+                    result.clear()
+                    del batch_inputs
+                    gc.collect()
+                    torch.cuda.empty_cache()
+                    raise RuntimeError(exc['error'])
+                outputs = result.get('outputs')
+                if outputs is None or not hasattr(outputs, 'speech_outputs'):
+                    raise RuntimeError("Generation produced no outputs.")
+                pieces = []
+                for so in outputs.speech_outputs[:len(text_list)]:
+                    if so is None:
+                        pieces.append(None)
+                    else:
+                        a = so.cpu().float().numpy()
+                        pieces.append(a.squeeze() if a.ndim > 1 else a)
+                # release this wave's GPU memory before the next wave starts
+                del outputs
+                result.clear()
+                del batch_inputs
+                gc.collect()
+                torch.cuda.empty_cache()
+                yield pieces
+
+            def _wave_with_backoff(wave):
+                """Run a wave; on CUDA OOM, split in half and retry recursively.
+
+                Yields None keep-alive ticks, then exactly one final list of
+                audio pieces (in wave order)."""
+                try:
+                    for tick in _generate_batch(wave):
+                        yield tick
+                    return
+                except RuntimeError as e:
+                    msg = str(e).lower()
+                    if len(wave) == 1 or ("out of memory" not in msg and "cuda" not in msg):
+                        raise
+                    print(f"OOM at batch {len(wave)}; backing off to halves.")
+                    gc.collect()  # must run BEFORE empty_cache to actually free tensors
+                    torch.cuda.empty_cache()
+                mid = (len(wave) + 1) // 2
+                combined = []
+                for sub in (wave[:mid], wave[mid:]):
+                    if not sub:
+                        continue
+                    for tick in _wave_with_backoff(sub):
+                        if tick is None:
+                            yield None
+                        else:
+                            combined.extend(tick)
+                yield combined
 
-            outputs = result_container.get('outputs')
-            if outputs is None:
-                raise RuntimeError("Generation thread finished without producing outputs.")
+            start_time = time.time()
+            audio = None
+            ran_parallel = False
+            try:
+                waves = [chunks[i:i + batch_cap] for i in range(0, len(chunks), batch_cap)]
+                all_pieces = []
+                rerolled_total = 0
+                for wi, wave in enumerate(waves):
+                    wave_pieces = []
+                    for tick in _wave_with_backoff(wave):
+                        if tick is None:
+                            elapsed = time.time() - start_time
+                            pct_hint = min(88, 70 + int(elapsed // 5))
+                            yield self._emit_progress(
+                                stage="generating_audio",
+                                pct=pct_hint,
+                                status=(f"Rendering wave {wi + 1}/{len(waves)} "
+                                        f"({len(wave)} chunks in parallel)… "
+                                        f"{int(elapsed)}s elapsed"),
+                                log_text=log_text,
+                            )
+                        else:
+                            wave_pieces = tick
+
+                    # ---- quality gate: score every chunk, reroll failures --
+                    if len(wave_pieces) == len(wave):
+                        gates = [self._chunk_quality(wave[ci], wave_pieces[ci], 24000)
+                                 for ci in range(len(wave))]
+                        failed = [ci for ci, (ok, _, _) in enumerate(gates) if not ok]
+                        for ci, (ok, _, reason) in enumerate(gates):
+                            chunk_no = wi * batch_cap + ci + 1
+                            # container-log every chunk's metrics (calibration data)
+                            print(f"gate: chunk {chunk_no}: {reason}")
+                            if not ok:
+                                log_lines.append(
+                                    f"Quality gate: chunk {chunk_no} FAILED ({reason}) — rerolling")
+                        if failed:
+                            log_text = "\n".join(log_lines)
+                            torch.manual_seed((int(start_time * 1000) + wi * 7919) % (2 ** 31))
+                            reroll_pieces = []
+                            for tick in _wave_with_backoff([wave[ci] for ci in failed]):
+                                if tick is None:
+                                    elapsed = time.time() - start_time
+                                    yield self._emit_progress(
+                                        stage="generating_audio",
+                                        pct=min(88, 70 + int(elapsed // 5)),
+                                        status=(f"Re-rolling {len(failed)} flagged "
+                                                f"chunk(s) on a new seed… "
+                                                f"{int(elapsed)}s elapsed"),
+                                        log_text=log_text,
+                                    )
+                                else:
+                                    reroll_pieces = tick
+                            for j, ci in enumerate(failed):
+                                if j >= len(reroll_pieces):
+                                    break
+                                ok2, bad2, reason2 = self._chunk_quality(
+                                    wave[ci], reroll_pieces[j], 24000)
+                                chunk_no = wi * batch_cap + ci + 1
+                                if ok2 or bad2 < gates[ci][1]:
+                                    wave_pieces[ci] = reroll_pieces[j]
+                                    rerolled_total += 1
+                                    log_lines.append(
+                                        f"Quality gate: chunk {chunk_no} reroll "
+                                        f"{'passed' if ok2 else f'improved ({reason2})'} — kept")
+                                else:
+                                    log_lines.append(
+                                        f"Quality gate: chunk {chunk_no} reroll no better "
+                                        f"({reason2}) — keeping original")
+                            log_text = "\n".join(log_lines)
+                    all_pieces.extend(wave_pieces)
+                if any(p is None for p in all_pieces):
+                    raise RuntimeError("A chunk produced no audio.")
+                if rerolled_total == 0:
+                    log_lines.append(f"Quality gate: all {len(all_pieces)} chunks passed")
+                log_text = "\n".join(log_lines)
+                audio = (self._crossfade_concat(all_pieces, 24000)
+                         if use_parallel else all_pieces[0])
+                ran_parallel = use_parallel
+            except Exception as fast_err:
+                # Fall back to SEQUENTIAL PER-CHUNK, never monolithic: a long
+                # monolithic render triggers the model's rate/drift defects
+                # (finding N8) — turn-split chunks must be preserved even at
+                # batch size 1. Only truly short scripts run monolithic.
+                if not use_parallel:
+                    raise
+                print(f"Parallel path failed ({fast_err}); sequential per-chunk fallback.")
+                log_lines.append("Parallel path failed; sequential per-chunk fallback.")
+                log_text = "\n".join(log_lines)
+                gc.collect()
+                torch.cuda.empty_cache()
+                seq_pieces = []
+                for ci, chunk in enumerate(chunks):
+                    for tick in _generate_batch([chunk]):
+                        if tick is None:
+                            elapsed = time.time() - start_time
+                            yield self._emit_progress(
+                                stage="generating_audio",
+                                pct=min(88, 70 + int(elapsed // 5)),
+                                status=(f"Sequential fallback: chunk {ci + 1}/"
+                                        f"{len(chunks)}… {int(elapsed)}s elapsed"),
+                                log_text=log_text,
+                            )
+                        else:
+                            seq_pieces.extend(tick)
+                if any(p is None for p in seq_pieces) or not seq_pieces:
+                    raise RuntimeError("Error: No audio was generated by the model.")
+                audio = self._crossfade_concat(seq_pieces, 24000)
 
             generation_time = time.time() - start_time
-
-            log_lines.append(f"Generation completed in {generation_time:.2f} seconds")
+            audio_s = len(audio) / 24000 if audio is not None else 0
+            container_age = time.time() - getattr(self, "ready_at", time.time())
+            cold = container_age < 120  # this request likely paid the container boot
+            speed = (audio_s / generation_time) if generation_time > 0 else 0
+            log_lines.append("—— timing ——")
+            log_lines.append(
+                f"Container: {'COLD START (boot + model load happened before this job)' if cold else 'warm'}"
+            )
+            log_lines.append(
+                f"Pure generation: {generation_time:.1f}s for {audio_s:.1f}s of audio "
+                f"→ {speed:.2f}x realtime"
+            )
+            if ran_parallel:
+                n_waves = (len(chunks) + batch_cap - 1) // batch_cap
+                log_lines.append(f"Mode: parallel — {len(chunks)} chunks in {n_waves} wave(s)")
+            else:
+                log_lines.append("Mode: sequential chunks (fallback)" if use_parallel else "Mode: single-pass")
             log_lines.append("Processing audio output…")
             log_text = "\n".join(log_lines)
             yield self._emit_progress(
@@ -477,15 +807,9 @@ class VibeVoiceModel:
                 log_text=log_text,
             )
 
-            if hasattr(outputs, 'speech_outputs') and outputs.speech_outputs[0] is not None:
-                audio_tensor = outputs.speech_outputs[0]
-                audio = audio_tensor.cpu().float().numpy()
-            else:
+            if audio is None or len(audio) == 0:
                 raise RuntimeError("Error: No audio was generated by the model.")
 
-            if audio.ndim > 1:
-                audio = audio.squeeze()
-
             sample_rate = 24000
             total_duration = len(audio) / sample_rate
             log_lines.append(f"Audio duration: {total_duration:.2f} seconds")

requirements.txt

@@ -1,3 +1,7 @@
-gradio
+fastapi>=0.115,<1.0
+uvicorn[standard]>=0.30
+python-multipart>=0.0.9
 modal
 huggingface_hub
+numpy
+scipy

static/app.js

@@ -0,0 +1,481 @@
+const MAX_TURNS = 50;
+
+const SCRIPT_GEN_MESSAGES = [
+  "Writing script...", "Still generating...", "Making magic happen...",
+  "Bossing around robot writers...", "Entering the matrix...", "Crafting dialogue...",
+  "Teaching AI to be dramatic...", "Consulting the creative robots...", "Spilling digital ink...",
+  "Herding AI cats into a script...", "Negotiating with the muse...", "Downloading inspiration...",
+  "Warming up the plot engine...", "Shaking the idea tree...", "Feeding the word machine...",
+  "Polishing virtual microphones...", "Rehearsing in the AI green room...",
+  "Bribing the creativity daemon...", "Untangling narrative spaghetti...",
+  "Summoning fictional characters...", "Tuning the dialogue generator...",
+  "Spinning up the story factory...", "Convincing electrons to be eloquent...",
+  "Wrangling syllables into sentences...", "Loading dramatic tension...",
+  "Calibrating the sass levels...", "Generating witty banter...",
+  "Overthinking your prompt (in a good way)...", "Adding a pinch of personality...",
+  "Almost done, probably...", "Finalizing the masterpiece...",
+];
+
+const PRIMARY_STAGE_MESSAGES = {
+  connecting: ["Submitted", "Provisioning GPU resources... cold starts can take up to a minute."],
+  queued: ["Queued", "Worker is spinning up. Cold starts may take 30-60 seconds."],
+  loading_model: ["Loading Model", "Streaming VibeVoice weights to the GPU."],
+  loading_voices: ["Loading Voices", null],
+  preparing_inputs: ["Preparing", "Formatting the conversation for the model."],
+  generating_audio: ["Generating", "Synthesizing speech — this is the longest step."],
+  processing_audio: ["Finalizing", "Converting tensors into a playable waveform."],
+  complete: ["Complete", "Press play below or download your audio."],
+  error: ["Error", "Check the log for details."],
+};
+
+const state = {
+  turns: [],
+  numSpeakers: 2,
+  voices: [],
+  voiceSelections: [null, null, null, null],
+  models: [],
+  examples: [],
+  parodyLines: [],
+  parodyIndex: 0,
+  currentAudioId: null,
+};
+
+const el = {
+  runtimeStatus: document.querySelector("#runtimeStatus"),
+  runtimeLabel: document.querySelector("#runtimeLabel"),
+  scriptPrompt: document.querySelector("#scriptPrompt"),
+  generateScriptBtn: document.querySelector("#generateScriptBtn"),
+  scriptGenStatus: document.querySelector("#scriptGenStatus"),
+  examplePills: document.querySelector("#examplePills"),
+  pastedScript: document.querySelector("#pastedScript"),
+  scriptFileUpload: document.querySelector("#scriptFileUpload"),
+  loadScriptBtn: document.querySelector("#loadScriptBtn"),
+  scriptTitle: document.querySelector("#scriptTitle"),
+  scriptDuration: document.querySelector("#scriptDuration"),
+  turnsScroll: document.querySelector("#turnsScroll"),
+  addTurnBtn: document.querySelector("#addTurnBtn"),
+  modelSelect: document.querySelector("#modelSelect"),
+  cfgScale: document.querySelector("#cfgScale"),
+  cfgScaleValue: document.querySelector("#cfgScaleValue"),
+  previewVoiceSelect: document.querySelector("#previewVoiceSelect"),
+  previewAudio: document.querySelector("#previewAudio"),
+  generateBtn: document.querySelector("#generateBtn"),
+  primaryStatus: document.querySelector("#primaryStatus"),
+  primaryStatusTitle: document.querySelector("#primaryStatusTitle"),
+  primaryStatusDesc: document.querySelector("#primaryStatusDesc"),
+  outputEmpty: document.querySelector("#outputEmpty"),
+  outputResult: document.querySelector("#outputResult"),
+  resultWaveform: document.querySelector("#resultWaveform"),
+  resultAudio: document.querySelector("#resultAudio"),
+  generationTime: document.querySelector("#generationTime"),
+  audioDuration: document.querySelector("#audioDuration"),
+  resultModel: document.querySelector("#resultModel"),
+  downloadBtn: document.querySelector("#downloadBtn"),
+  logBox: document.querySelector("#logBox"),
+};
+
+function genderOf(name) {
+  const v = state.voices.find((x) => x.name === name);
+  return v ? v.gender : "?";
+}
+
+function estimateDuration(turns) {
+  const totalWords = turns.reduce((sum, t) => sum + (t.text || "").trim().split(/\s+/).filter(Boolean).length, 0);
+  if (totalWords === 0) return "";
+  const minutes = totalWords / 150;
+  return minutes < 1 ? `~${Math.round(minutes * 60)}s` : `~${minutes.toFixed(1)}m`;
+}
+
+function formatDuration(seconds) {
+  if (!Number.isFinite(seconds)) return "--";
+  return seconds < 60 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
+}
+
+/* ---------------- Views ---------------- */
+document.querySelectorAll(".view-tab").forEach((tab) => {
+  tab.addEventListener("click", () => {
+    document.querySelectorAll(".view-tab").forEach((t) => t.classList.toggle("active", t === tab));
+    document.querySelectorAll("#generate-view, #architecture-view").forEach((section) => {
+      section.classList.toggle("visible", section.id === `${tab.dataset.view}-view`);
+    });
+  });
+});
+
+/* ---------------- Status polling ---------------- */
+async function updateStatus() {
+  try {
+    const res = await fetch("/api/status", { cache: "no-store" });
+    const payload = await res.json();
+    const ready = payload.backend === "ready";
+    el.runtimeStatus.classList.toggle("ready", ready);
+    el.runtimeLabel.textContent = ready ? "Model ready" : "Backend offline";
+  } catch {
+    el.runtimeStatus.classList.remove("ready");
+    el.runtimeLabel.textContent = "Connecting";
+  }
+}
+
+/* ---------------- Voice / model selects ---------------- */
+function renderVoiceControls() {
+  el.modelSelect.innerHTML = state.models.map((m) => `<option value="${m}">${m}</option>`).join("");
+
+  document.querySelectorAll(".voice-select").forEach((select) => {
+    const idx = Number(select.dataset.index);
+    select.innerHTML = state.voices
+      .map((v) => `<option value="${v.name}">${v.name} (${v.gender})</option>`)
+      .join("");
+    if (state.voiceSelections[idx]) select.value = state.voiceSelections[idx];
+    select.closest(".voice-slot").hidden = idx >= state.numSpeakers;
+  });
+
+  el.previewVoiceSelect.innerHTML = state.voices.map((v) => `<option value="${v.name}">${v.name} (${v.gender})</option>`).join("");
+  if (state.voices.length) {
+    el.previewVoiceSelect.value = state.voices[0].name;
+    el.previewAudio.src = state.voices[0].preview_url;
+  }
+}
+
+document.querySelectorAll(".voice-select").forEach((select) => {
+  select.addEventListener("change", () => {
+    state.voiceSelections[Number(select.dataset.index)] = select.value;
+    renderTurns();
+  });
+});
+
+el.previewVoiceSelect.addEventListener("change", () => {
+  const v = state.voices.find((x) => x.name === el.previewVoiceSelect.value);
+  if (v) el.previewAudio.src = v.preview_url;
+});
+
+el.cfgScale.addEventListener("input", () => {
+  el.cfgScaleValue.textContent = Number(el.cfgScale.value).toFixed(2);
+});
+
+/* ---------------- Turn editor ---------------- */
+function speakerChoiceLabel(i) {
+  const sel = state.voiceSelections[i];
+  return sel ? `Speaker ${i + 1} - ${sel} (${genderOf(sel)})` : `Speaker ${i + 1}`;
+}
+
+function renderTurns() {
+  el.turnsScroll.innerHTML = "";
+  if (!state.turns.length) {
+    const empty = document.createElement("div");
+    empty.className = "empty-turns";
+    empty.id = "emptyTurns";
+    empty.innerHTML = "Your conversation will appear here.<br />Type a prompt above and click <strong>Write Script with AI</strong>, or pick an example to get started.";
+    el.turnsScroll.append(empty);
+    updateDuration();
+    return;
+  }
+
+  state.turns.forEach((turn, idx) => {
+    const spk = Math.min(4, Math.max(1, turn.speaker || 1));
+    const row = document.createElement("div");
+    row.className = `turn-row speaker-${spk}`;
+
+    const spkSelect = document.createElement("select");
+    for (let i = 1; i <= 4; i += 1) {
+      const opt = document.createElement("option");
+      opt.value = String(i);
+      opt.textContent = speakerChoiceLabel(i - 1);
+      if (i === spk) opt.selected = true;
+      spkSelect.append(opt);
+    }
+    spkSelect.addEventListener("change", () => {
+      state.turns[idx].speaker = Number(spkSelect.value);
+      renderTurns();
+    });
+
+    const textArea = document.createElement("textarea");
+    textArea.rows = 2;
+    textArea.value = turn.text || "";
+    textArea.addEventListener("input", () => {
+      state.turns[idx].text = textArea.value;
+      updateDuration();
+    });
+
+    const delBtn = document.createElement("button");
+    delBtn.type = "button";
+    delBtn.className = "btn btn-danger";
+    delBtn.textContent = "✕";
+    delBtn.addEventListener("click", () => {
+      state.turns.splice(idx, 1);
+      renderTurns();
+    });
+
+    row.append(spkSelect, textArea, delBtn);
+    el.turnsScroll.append(row);
+  });
+  updateDuration();
+}
+
+function updateDuration() {
+  el.scriptDuration.textContent = estimateDuration(state.turns);
+}
+
+el.addTurnBtn.addEventListener("click", () => {
+  if (state.turns.length >= MAX_TURNS) {
+    alert(`Maximum ${MAX_TURNS} turns reached.`);
+    return;
+  }
+  let nextSpeaker = 1;
+  if (state.turns.length) {
+    const maxSpk = Math.max(...state.turns.map((t) => t.speaker));
+    const last = state.turns[state.turns.length - 1].speaker;
+    nextSpeaker = (last % maxSpk) + 1;
+  }
+  state.turns.push({ speaker: nextSpeaker, text: "" });
+  renderTurns();
+});
+
+function loadScriptResult(result, titleFallback) {
+  state.turns = result.turns;
+  state.numSpeakers = result.num_speakers;
+  const voices = (result.voices || []).slice(0, 4);
+  while (voices.length < 4) voices.push(null);
+  state.voiceSelections = voices;
+  el.scriptTitle.textContent = result.title || titleFallback || "Script";
+  renderVoiceControls();
+  renderTurns();
+  el.outputEmpty.hidden = false;
+  el.outputResult.classList.remove("visible");
+}
+
+/* ---------------- Examples ---------------- */
+function renderExamplePills() {
+  el.examplePills.innerHTML = "";
+  state.examples.forEach((example) => {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "btn btn-sm btn-pill";
+    btn.textContent = example.title;
+    btn.addEventListener("click", () => loadScriptResult(example, example.title));
+    el.examplePills.append(btn);
+  });
+}
+
+/* ---------------- Paste / upload ---------------- */
+el.loadScriptBtn.addEventListener("click", async () => {
+  const text = el.pastedScript.value.trim();
+  const file = el.scriptFileUpload.files[0];
+  if (!text && !file) {
+    alert("Paste a script or upload a .txt file first.");
+    return;
+  }
+  const formData = new FormData();
+  formData.set("text", text);
+  if (file) formData.set("file", file);
+
+  try {
+    const res = await fetch("/api/parse-script", { method: "POST", body: formData });
+    const payload = await res.json();
+    if (!res.ok) throw new Error(payload.detail || "Could not parse script.");
+    if (payload.over_limit) {
+      alert(`Script is ${payload.word_count} words; loading anyway — trim before generating.`);
+    }
+    loadScriptResult(payload, "Uploaded Script");
+  } catch (error) {
+    alert(error.message);
+  }
+});
+
+/* ---------------- AI script generation ---------------- */
+el.generateScriptBtn.addEventListener("click", async () => {
+  const prompt = el.scriptPrompt.value.trim();
+  if (!prompt) {
+    alert("Please enter a prompt.");
+    return;
+  }
+
+  el.generateScriptBtn.disabled = true;
+  el.generateScriptBtn.textContent = "Writing...";
+  el.loadScriptBtn.disabled = true;
+  let msgIdx = 0;
+  el.scriptGenStatus.textContent = SCRIPT_GEN_MESSAGES[0];
+  const ticker = window.setInterval(() => {
+    msgIdx += 1;
+    el.scriptGenStatus.textContent = SCRIPT_GEN_MESSAGES[msgIdx % SCRIPT_GEN_MESSAGES.length];
+  }, 3000);
+
+  try {
+    const res = await fetch("/api/generate-script", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt }),
+    });
+    const payload = await res.json();
+    if (!res.ok) throw new Error(payload.detail || "Script generation failed.");
+    state.parodyLines = payload.parody_lines || [];
+    state.parodyIndex = 0;
+    loadScriptResult(payload, "Script");
+    el.scriptGenStatus.textContent = "";
+  } catch (error) {
+    el.scriptGenStatus.textContent = error.message;
+  } finally {
+    window.clearInterval(ticker);
+    el.generateScriptBtn.disabled = false;
+    el.generateScriptBtn.textContent = "Write Script with AI";
+    el.loadScriptBtn.disabled = false;
+  }
+});
+
+/* ---------------- Waveform ---------------- */
+async function drawWaveform(url, canvas, color = "#6366f1") {
+  const response = await fetch(url);
+  if (!response.ok) return;
+  const data = await response.arrayBuffer();
+  const context = new AudioContext();
+  try {
+    const buffer = await context.decodeAudioData(data.slice(0));
+    const samples = buffer.getChannelData(0);
+    const width = canvas.width;
+    const height = canvas.height;
+    const blocks = Math.min(160, Math.max(40, Math.floor(width / 6)));
+    const blockSize = Math.max(1, Math.floor(samples.length / blocks));
+    const peaks = [];
+    for (let block = 0; block < blocks; block += 1) {
+      let peak = 0;
+      const start = block * blockSize;
+      const end = Math.min(samples.length, start + blockSize);
+      for (let i = start; i < end; i += 1) peak = Math.max(peak, Math.abs(samples[i]));
+      peaks.push(peak);
+    }
+    const maxPeak = Math.max(...peaks, 0.001);
+    const draw = canvas.getContext("2d");
+    draw.clearRect(0, 0, width, height);
+    draw.fillStyle = color;
+    const barWidth = Math.max(2, width / blocks - 2);
+    peaks.forEach((peak, i) => {
+      const normalized = peak / maxPeak;
+      const barHeight = Math.max(3, normalized * height * 0.9);
+      const x = i * (width / blocks) + 1;
+      draw.fillRect(x, (height - barHeight) / 2, barWidth, barHeight);
+    });
+  } finally {
+    await context.close();
+  }
+}
+
+/* ---------------- Generation status banner ---------------- */
+function nextParodyLine() {
+  if (!state.parodyLines.length) return null;
+  const line = state.parodyLines[state.parodyIndex % state.parodyLines.length];
+  state.parodyIndex += 1;
+  return line;
+}
+
+function setPrimaryStatus(stage, fallbackText) {
+  const [title, defaultDesc] = PRIMARY_STAGE_MESSAGES[stage] || ["Working", "Processing..."];
+  el.primaryStatus.classList.add("visible");
+  el.primaryStatus.classList.toggle("active", stage !== "complete" && stage !== "error");
+  el.primaryStatus.classList.toggle("complete", stage === "complete");
+  el.primaryStatus.classList.toggle("error", stage === "error");
+  el.primaryStatusTitle.textContent = title;
+  el.primaryStatusDesc.textContent = fallbackText || defaultDesc || "";
+}
+
+/* ---------------- Generate ---------------- */
+el.generateBtn.addEventListener("click", async () => {
+  const script = state.turns.map((t) => (t.text || "").trim()).filter(Boolean).join(" ");
+  if (!script) {
+    alert("Add dialogue before generating.");
+    return;
+  }
+
+  el.generateBtn.disabled = true;
+  el.generateBtn.textContent = "Generating...";
+  el.generateScriptBtn.disabled = true;
+  el.outputResult.classList.remove("visible");
+  el.outputEmpty.hidden = false;
+  el.logBox.textContent = "";
+  const started = performance.now();
+  setPrimaryStatus("connecting", nextParodyLine() || "Provisioning GPU resources...");
+
+  const payload = {
+    model: el.modelSelect.value,
+    num_speakers: state.numSpeakers,
+    turns: state.turns,
+    speakers: state.voiceSelections,
+    cfg_scale: Number(el.cfgScale.value),
+  };
+
+  try {
+    const response = await fetch("/api/generate", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+      const body = await response.json().catch(() => ({}));
+      throw new Error(body.detail || "The model could not generate audio.");
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let done = false;
+
+    while (!done) {
+      const chunk = await reader.read();
+      done = chunk.done;
+      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: true });
+
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) >= 0) {
+        const rawEvent = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        if (!rawEvent.startsWith("data: ")) continue;
+        const evt = JSON.parse(rawEvent.slice(6));
+        const isDone = evt.stage === "complete" || evt.stage === "error";
+        const displayLine = isDone ? evt.status : nextParodyLine() || evt.status;
+        setPrimaryStatus(evt.stage, displayLine);
+        if (evt.log) el.logBox.textContent = evt.log;
+
+        if (evt.stage === "complete" && evt.audio_id) {
+          const audioRes = await fetch(`/api/audio/${evt.audio_id}`);
+          const blob = await audioRes.blob();
+          const url = URL.createObjectURL(blob);
+          el.resultAudio.src = url;
+          el.downloadBtn.href = url;
+          el.generationTime.textContent = formatDuration((performance.now() - started) / 1000);
+          el.audioDuration.textContent = formatDuration(evt.audio_duration);
+          el.resultModel.textContent = el.modelSelect.value;
+          await drawWaveform(url, el.resultWaveform);
+          el.outputEmpty.hidden = true;
+          el.outputResult.classList.add("visible");
+        }
+      }
+    }
+  } catch (error) {
+    setPrimaryStatus("error", error.message);
+  } finally {
+    el.generateBtn.disabled = false;
+    el.generateBtn.textContent = "Generate Conference Audio";
+    el.generateScriptBtn.disabled = false;
+  }
+});
+
+/* ---------------- Init ---------------- */
+async function init() {
+  const [models, voices, examples] = await Promise.all([
+    fetch("/api/models").then((r) => r.json()),
+    fetch("/api/voices").then((r) => r.json()),
+    fetch("/api/examples").then((r) => r.json()),
+  ]);
+  state.models = models;
+  state.voices = voices;
+  state.examples = examples;
+  state.voiceSelections = voices.slice(0, 4).map((v) => v.name);
+  while (state.voiceSelections.length < 4) state.voiceSelections.push(null);
+
+  renderVoiceControls();
+  renderTurns();
+  renderExamplePills();
+  updateStatus();
+  window.setInterval(updateStatus, 8000);
+}
+
+init().catch((error) => {
+  el.scriptGenStatus.textContent = `Failed to load app data: ${error.message}`;
+});

static/index.html

@@ -0,0 +1,235 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#0d0d14" />
+    <meta
+      name="description"
+      content="Generate realistic multi-speaker conference calls, meetings, and podcasts from a single prompt, powered by VibeVoice."
+    />
+    <title>Conference Generator — VibeVoice</title>
+    <link rel="stylesheet" href="/static/styles.css" />
+    <script src="/static/app.js" defer></script>
+  </head>
+  <body>
+    <header class="topbar">
+      <div class="topbar-inner">
+        <a class="brand" href="/">
+          <span class="brand-mark">🎙️</span>
+          <span>Conference Generator</span>
+        </a>
+        <nav class="view-tabs" aria-label="View">
+          <button class="view-tab active" type="button" data-view="generate">Generate</button>
+          <button class="view-tab" type="button" data-view="architecture">Architecture</button>
+        </nav>
+        <div class="runtime-status" id="runtimeStatus" aria-live="polite">
+          <span class="status-dot"></span>
+          <span id="runtimeLabel">Connecting</span>
+        </div>
+      </div>
+    </header>
+
+    <main>
+      <img
+        class="banner"
+        src="https://huggingface.co/spaces/ACloudCenter/Conference-Generator-VibeVoice/resolve/main/public/images/banner.png"
+        alt="VibeVoice Conference Generator"
+      />
+
+      <section id="generate-view" class="visible">
+        <!-- STEP 1: DESCRIBE -->
+        <section class="step-card">
+          <div class="step-heading">
+            <div class="step-heading-left">
+              <span class="step-index">01</span>
+              <h2>Describe your conversation</h2>
+            </div>
+          </div>
+          <p class="field-hint" style="margin-top: -6px; margin-bottom: 12px;">
+            Describe any scenario and AI writes the script. Then edit, assign voices, and generate audio.
+          </p>
+          <div class="script-prompt-row">
+            <textarea
+              id="scriptPrompt"
+              rows="2"
+              placeholder="A wizard and an orc debating battle strategy before a siege..."
+            ></textarea>
+            <div class="row">
+              <button id="generateScriptBtn" class="btn btn-primary btn-cta" type="button" style="width: auto; flex: 1;">
+                Write Script with AI
+              </button>
+            </div>
+            <span id="scriptGenStatus" class="status-text"></span>
+          </div>
+
+          <div id="examplePills" class="row example-pills"></div>
+
+          <details class="accordion">
+            <summary>📋 Paste or upload a full script</summary>
+            <div class="accordion-body">
+              <p class="field-hint">
+                Bring your own script. Use <code>Speaker 1:</code> … <code>Speaker 4:</code> tags (one turn per
+                line). Untagged text becomes Speaker 1. Named characters (<code>Host:</code>, <code>Mom:</code>)
+                are auto-mapped to speaker slots.
+              </p>
+              <textarea
+                id="pastedScript"
+                rows="6"
+                placeholder="Speaker 1: Welcome to the show...&#10;Speaker 2: Thanks for having me..."
+              ></textarea>
+              <div class="row" style="margin-top: 10px;">
+                <input id="scriptFileUpload" type="file" accept=".txt,.md" style="flex: 1;" />
+                <button id="loadScriptBtn" class="btn btn-primary" type="button">Load Script</button>
+              </div>
+            </div>
+          </details>
+        </section>
+
+        <!-- STEP 2: SCRIPT EDITOR -->
+        <section class="step-card">
+          <div class="step-heading">
+            <div class="step-heading-left">
+              <span class="step-index">02</span>
+              <h2>Script editor</h2>
+            </div>
+          </div>
+          <div class="script-title-row">
+            <h3 id="scriptTitle">Script</h3>
+            <span id="scriptDuration" class="script-duration"></span>
+          </div>
+          <div id="turnsScroll" class="turns-scroll">
+            <div class="empty-turns" id="emptyTurns">
+              Your conversation will appear here.<br />
+              Type a prompt above and click <strong>Write Script with AI</strong>, or pick an example to get started.
+            </div>
+          </div>
+          <button id="addTurnBtn" class="btn btn-sm add-turn-btn" type="button">+ Add Turn</button>
+        </section>
+
+        <!-- STEP 3: VOICE & MODEL -->
+        <section class="step-card">
+          <div class="step-heading">
+            <div class="step-heading-left">
+              <span class="step-index">03</span>
+              <h2>Voice &amp; model</h2>
+            </div>
+          </div>
+          <div class="voice-grid">
+            <div>
+              <label class="field-label" for="modelSelect">Model</label>
+              <select id="modelSelect"></select>
+            </div>
+            <div class="voice-slot" data-slot="0">
+              <label class="field-label">Voice 1</label>
+              <select class="voice-select" data-index="0"></select>
+            </div>
+            <div class="voice-slot" data-slot="1">
+              <label class="field-label">Voice 2</label>
+              <select class="voice-select" data-index="1"></select>
+            </div>
+            <div class="voice-slot" data-slot="2" hidden>
+              <label class="field-label">Voice 3</label>
+              <select class="voice-select" data-index="2"></select>
+            </div>
+            <div class="voice-slot" data-slot="3" hidden>
+              <label class="field-label">Voice 4</label>
+              <select class="voice-select" data-index="3"></select>
+            </div>
+          </div>
+          <label class="field-label" for="cfgScale">CFG Scale</label>
+          <div class="slider-row">
+            <input id="cfgScale" type="range" min="1.0" max="2.0" step="0.05" value="2.0" />
+            <span id="cfgScaleValue" class="slider-value">2.00</span>
+          </div>
+
+          <details class="accordion">
+            <summary>🔊 Preview voices before generating</summary>
+            <div class="accordion-body preview-row">
+              <select id="previewVoiceSelect"></select>
+              <audio id="previewAudio" controls></audio>
+            </div>
+          </details>
+        </section>
+
+        <!-- STEP 4: GENERATE -->
+        <section class="step-card">
+          <div class="step-heading">
+            <div class="step-heading-left">
+              <span class="step-index">04</span>
+              <h2>Generate</h2>
+            </div>
+          </div>
+          <button id="generateBtn" class="btn btn-primary btn-cta" type="button">Generate Conference Audio</button>
+          <div id="primaryStatus" class="gen-status">
+            <div class="gen-status-title"><span class="dot"></span><span id="primaryStatusTitle">Working</span></div>
+            <div class="gen-status-desc" id="primaryStatusDesc"></div>
+          </div>
+
+          <div class="output-panel">
+            <div id="outputEmpty" class="output-empty">Your generated conference audio will appear here.</div>
+            <div id="outputResult" class="output-result">
+              <canvas id="resultWaveform" width="960" height="90"></canvas>
+              <audio id="resultAudio" controls></audio>
+              <div class="result-metrics">
+                <div><span>Generation</span><strong id="generationTime">--</strong></div>
+                <div><span>Audio</span><strong id="audioDuration">--</strong></div>
+                <div><span>Model</span><strong id="resultModel">--</strong></div>
+              </div>
+              <a id="downloadBtn" class="btn btn-sm" download="conference.wav">Download WAV</a>
+            </div>
+          </div>
+
+          <details class="accordion">
+            <summary>Generation log</summary>
+            <div class="accordion-body">
+              <div id="logBox" class="log-box"></div>
+            </div>
+          </details>
+        </section>
+      </section>
+
+      <section id="architecture-view">
+        <section class="step-card">
+          <h2 style="margin-top:0;">VibeVoice: A Frontier Open-Source Text-to-Speech Model</h2>
+          <p style="color: var(--text-dim);">
+            VibeVoice generates expressive, long-form, multi-speaker conversational audio from text. It uses
+            continuous speech tokenizers at an ultra-low 7.5&nbsp;Hz frame rate and a next-token diffusion
+            framework to synthesize up to 90 minutes of speech with up to 4 distinct speakers.
+          </p>
+          <div class="arch-grid">
+            <div>
+              <h3>Key features</h3>
+              <ul>
+                <li><strong>Multi-speaker</strong> — up to 4 distinct voices</li>
+                <li><strong>Long-form</strong> — up to 90 minutes of audio</li>
+                <li><strong>Natural flow</strong> — turn-taking, interruptions, filler words</li>
+                <li><strong>Efficient</strong> — 7.5&nbsp;Hz tokenizers for low compute cost</li>
+              </ul>
+              <h3>Architecture</h3>
+              <ul>
+                <li>Continuous speech tokenizers — acoustic + semantic at 7.5&nbsp;Hz</li>
+                <li>Next-token diffusion — LLM context + diffusion generation</li>
+                <li>Diffusion head — high-fidelity acoustic output</li>
+              </ul>
+              <h3>Models</h3>
+              <ul>
+                <li><strong>1.5B</strong> — fast inference, great for iteration</li>
+                <li><strong>7B</strong> — higher fidelity, longer generation time</li>
+              </ul>
+            </div>
+            <div>
+              <img src="/public/images/diagram.jpg" alt="VibeVoice architecture diagram" />
+              <img src="/public/images/chart.png" alt="VibeVoice benchmark chart" />
+            </div>
+          </div>
+        </section>
+      </section>
+    </main>
+
+    <footer>
+      <span>Conference Generator — powered by VibeVoice</span>
+      <span>Runs speech synthesis on Modal GPU workers; script writing via Qwen2.5-Coder-32B.</span>
+    </footer>
+  </body>
+</html>

static/styles.css

@@ -0,0 +1,473 @@
+:root {
+  --bg: #0d0d14;
+  --bg-elevated: #14141f;
+  --bg-card: #191926;
+  --border: #2a2a3a;
+  --border-soft: #232332;
+  --text: #eceaf5;
+  --text-dim: #9a97ad;
+  --text-faint: #6e6b82;
+  --indigo: #6366f1;
+  --fuchsia: #ec4899;
+  --green: #22c55e;
+  --amber: #f59e0b;
+  --red: #ef4444;
+  --radius: 14px;
+  --radius-sm: 9px;
+  --shadow: 0 8px 32px rgba(0, 0, 0, 0.35);
+  --font: -apple-system, BlinkMacSystemFont, "Segoe UI", Inter, Roboto, sans-serif;
+}
+
+* { box-sizing: border-box; }
+
+html, body {
+  margin: 0;
+  padding: 0;
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--font);
+  -webkit-font-smoothing: antialiased;
+}
+
+body {
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+a { color: inherit; }
+
+.sr-only {
+  position: absolute;
+  width: 1px; height: 1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+}
+
+/* ---- Topbar ---- */
+.topbar {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  background: rgba(13, 13, 20, 0.85);
+  backdrop-filter: blur(10px);
+  border-bottom: 1px solid var(--border-soft);
+}
+.topbar-inner {
+  max-width: 1180px;
+  margin: 0 auto;
+  padding: 14px 24px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+}
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  text-decoration: none;
+  font-weight: 700;
+  font-size: 1.05rem;
+  color: var(--text);
+}
+.brand-mark {
+  width: 28px; height: 28px;
+  border-radius: 8px;
+  background: linear-gradient(135deg, var(--indigo), var(--fuchsia));
+  display: flex; align-items: center; justify-content: center;
+  font-size: 1rem;
+}
+.view-tabs {
+  display: flex;
+  gap: 4px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-soft);
+  border-radius: 999px;
+  padding: 3px;
+}
+.view-tab {
+  border: none;
+  background: transparent;
+  color: var(--text-dim);
+  font: inherit;
+  font-size: 0.85rem;
+  font-weight: 600;
+  padding: 7px 16px;
+  border-radius: 999px;
+  cursor: pointer;
+  transition: background 0.15s, color 0.15s;
+}
+.view-tab.active {
+  background: var(--indigo);
+  color: #fff;
+}
+.runtime-status {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 0.8rem;
+  color: var(--text-dim);
+  border: 1px solid var(--border-soft);
+  border-radius: 999px;
+  padding: 6px 12px;
+}
+.status-dot {
+  width: 8px; height: 8px;
+  border-radius: 50%;
+  background: var(--red);
+  box-shadow: 0 0 0 3px rgba(239, 68, 68, 0.15);
+}
+.runtime-status.ready .status-dot {
+  background: var(--green);
+  box-shadow: 0 0 0 3px rgba(34, 197, 94, 0.15);
+}
+
+/* ---- Layout ---- */
+main {
+  max-width: 1180px;
+  width: 100%;
+  margin: 0 auto;
+  padding: 24px;
+  flex: 1;
+}
+.banner {
+  width: 100%;
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  margin-bottom: 24px;
+  display: block;
+}
+
+.step-card {
+  background: var(--bg-card);
+  border: 1px solid var(--border-soft);
+  border-radius: var(--radius);
+  padding: 22px;
+  margin-bottom: 18px;
+}
+.step-heading {
+  display: flex;
+  align-items: baseline;
+  gap: 10px;
+  margin-bottom: 14px;
+  flex-wrap: wrap;
+  justify-content: space-between;
+}
+.step-heading-left { display: flex; align-items: baseline; gap: 10px; }
+.step-index {
+  font-size: 0.75rem;
+  font-weight: 700;
+  color: var(--indigo);
+  background: rgba(99, 102, 241, 0.12);
+  border-radius: 6px;
+  padding: 2px 7px;
+  letter-spacing: 0.03em;
+}
+.step-heading h2 {
+  margin: 0;
+  font-size: 1.05rem;
+}
+
+textarea, input[type="text"], input[type="number"], select {
+  width: 100%;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  color: var(--text);
+  border-radius: var(--radius-sm);
+  padding: 10px 12px;
+  font: inherit;
+  font-size: 0.92rem;
+  resize: vertical;
+}
+textarea:focus, input:focus, select:focus {
+  outline: none;
+  border-color: var(--indigo);
+}
+
+.field-hint {
+  font-size: 0.8rem;
+  color: var(--text-faint);
+  margin: 6px 0 0;
+}
+
+.btn {
+  font: inherit;
+  font-size: 0.88rem;
+  font-weight: 600;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--border);
+  background: var(--bg-elevated);
+  color: var(--text);
+  padding: 9px 16px;
+  cursor: pointer;
+  transition: filter 0.15s, transform 0.05s;
+}
+.btn:hover { filter: brightness(1.15); }
+.btn:active { transform: scale(0.98); }
+.btn:disabled { opacity: 0.5; cursor: not-allowed; }
+.btn-primary {
+  background: linear-gradient(135deg, var(--indigo), #4f46e5);
+  border-color: transparent;
+  color: #fff;
+}
+.btn-cta {
+  font-size: 1rem;
+  padding: 13px 22px;
+  width: 100%;
+  border-radius: 12px;
+}
+.btn-danger {
+  background: transparent;
+  border-color: var(--border);
+  color: var(--red);
+  padding: 4px 9px;
+  font-size: 0.8rem;
+}
+.btn-sm { padding: 6px 12px; font-size: 0.8rem; }
+.btn-pill { border-radius: 999px; }
+
+.row { display: flex; gap: 10px; flex-wrap: wrap; }
+
+/* ---- Prompt / script gen ---- */
+.script-prompt-row { display: flex; flex-direction: column; gap: 10px; }
+.status-text {
+  font-size: 0.85rem;
+  color: var(--text-dim);
+  font-style: italic;
+  min-height: 1.1em;
+}
+.example-pills { margin-top: 12px; }
+.example-pills .btn { border-radius: 999px; font-size: 0.8rem; }
+
+details.accordion {
+  margin-top: 14px;
+  border: 1px solid var(--border-soft);
+  border-radius: var(--radius-sm);
+  padding: 0;
+}
+details.accordion > summary {
+  cursor: pointer;
+  padding: 11px 14px;
+  font-size: 0.88rem;
+  font-weight: 600;
+  list-style: none;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+details.accordion > summary::-webkit-details-marker { display: none; }
+details.accordion > summary::after {
+  content: "\2304";
+  transition: transform 0.15s;
+  color: var(--text-faint);
+}
+details.accordion[open] > summary::after { transform: rotate(180deg); }
+.accordion-body { padding: 4px 14px 16px; }
+
+/* ---- Script editor ---- */
+.script-title-row {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 10px;
+  margin-bottom: 12px;
+}
+.script-title-row h3 { margin: 0; font-size: 1rem; }
+.script-duration { font-size: 0.8rem; color: var(--text-faint); }
+
+.turns-scroll {
+  max-height: 460px;
+  overflow-y: auto;
+  border: 1px solid var(--border-soft);
+  border-radius: var(--radius-sm);
+  padding: 10px;
+  background: var(--bg-elevated);
+}
+.turns-scroll::-webkit-scrollbar { width: 6px; }
+.turns-scroll::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
+
+.empty-turns {
+  text-align: center;
+  padding: 40px 16px;
+  color: var(--text-faint);
+  font-size: 0.88rem;
+}
+
+.turn-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  padding: 8px;
+  border-radius: 10px;
+  margin-bottom: 6px;
+  border-left: 4px solid var(--border);
+}
+.turn-row select {
+  width: auto;
+  min-width: 130px;
+  max-width: 190px;
+  font-size: 0.78rem;
+  padding: 8px;
+}
+.turn-row textarea {
+  flex: 1;
+  font-size: 0.88rem;
+  min-height: 44px;
+}
+.speaker-1 { border-left-color: #6366f1; background: #6366f108; }
+.speaker-2 { border-left-color: #ec4899; background: #ec489908; }
+.speaker-3 { border-left-color: #22c55e; background: #22c55e08; }
+.speaker-4 { border-left-color: #f59e0b; background: #f59e0b08; }
+
+.add-turn-btn { margin-top: 12px; }
+
+/* ---- Voice / model panel ---- */
+.voice-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+  gap: 12px;
+  margin-bottom: 14px;
+}
+.field-label {
+  font-size: 0.78rem;
+  color: var(--text-dim);
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 600;
+}
+.slider-row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+input[type="range"] {
+  flex: 1;
+  accent-color: var(--indigo);
+}
+.slider-value {
+  font-size: 0.82rem;
+  color: var(--text-dim);
+  min-width: 34px;
+  text-align: right;
+}
+
+.preview-row { display: flex; align-items: center; gap: 14px; flex-wrap: wrap; }
+.preview-row select { max-width: 220px; }
+.preview-row audio { flex: 1; min-width: 220px; height: 36px; }
+
+/* ---- Generate status banner ---- */
+.gen-status {
+  border-radius: 12px;
+  padding: 16px 20px;
+  margin-top: 14px;
+  text-align: center;
+  border: 2px solid var(--border-soft);
+  display: none;
+}
+.gen-status.visible { display: block; }
+.gen-status-title { font-size: 1rem; font-weight: 700; }
+.gen-status-desc { font-size: 0.85rem; color: var(--text-dim); margin-top: 4px; }
+.gen-status .dot {
+  display: inline-block;
+  width: 10px; height: 10px;
+  border-radius: 50%;
+  background: var(--indigo);
+  margin-right: 8px;
+  vertical-align: middle;
+  animation: dot-pulse 1.2s ease-in-out infinite;
+}
+.gen-status.active {
+  border-color: var(--indigo);
+  background: linear-gradient(90deg,
+    rgba(99,102,241,0.05) 0%, rgba(99,102,241,0.16) 30%,
+    rgba(236,72,153,0.13) 50%, rgba(99,102,241,0.16) 70%, rgba(99,102,241,0.05) 100%);
+  background-size: 300% 100%;
+  animation: gradient-sweep 2.5s ease-in-out infinite;
+}
+.gen-status.complete { border-color: var(--green); }
+.gen-status.error { border-color: var(--red); }
+@keyframes dot-pulse { 0%, 100% { opacity: 1; transform: scale(1); } 50% { opacity: 0.4; transform: scale(0.7); } }
+@keyframes gradient-sweep { 0% { background-position: 100% 0; } 50% { background-position: 0 0; } 100% { background-position: 100% 0; } }
+
+/* ---- Output ---- */
+.output-panel { margin-top: 16px; }
+.output-empty {
+  text-align: center;
+  padding: 32px 16px;
+  color: var(--text-faint);
+  font-size: 0.85rem;
+  border: 1px dashed var(--border);
+  border-radius: var(--radius-sm);
+}
+.output-result { display: none; }
+.output-result.visible { display: block; }
+#resultWaveform {
+  width: 100%;
+  height: 90px;
+  border-radius: var(--radius-sm);
+  background: var(--bg-elevated);
+  display: block;
+  margin-bottom: 10px;
+}
+.output-result audio { width: 100%; margin-bottom: 10px; }
+.result-metrics {
+  display: flex;
+  gap: 20px;
+  font-size: 0.8rem;
+  color: var(--text-dim);
+  margin-bottom: 10px;
+}
+.result-metrics strong { color: var(--text); display: block; font-size: 0.95rem; }
+
+.log-box {
+  width: 100%;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  color: var(--text-dim);
+  font-family: ui-monospace, "SF Mono", Menlo, monospace;
+  font-size: 0.75rem;
+  padding: 10px;
+  max-height: 220px;
+  overflow-y: auto;
+  white-space: pre-wrap;
+}
+
+/* ---- Architecture view ---- */
+#architecture-view { display: none; }
+#architecture-view.visible { display: block; }
+.arch-grid {
+  display: grid;
+  grid-template-columns: 1.1fr 1fr;
+  gap: 24px;
+  align-items: start;
+}
+.arch-grid img {
+  width: 100%;
+  border-radius: var(--radius-sm);
+  margin-bottom: 14px;
+  border: 1px solid var(--border-soft);
+}
+.step-card ul { padding-left: 20px; margin: 8px 0; }
+.step-card li { margin-bottom: 4px; font-size: 0.9rem; color: var(--text-dim); }
+@media (max-width: 860px) {
+  .arch-grid { grid-template-columns: 1fr; }
+}
+
+footer {
+  border-top: 1px solid var(--border-soft);
+  padding: 18px 24px;
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+  font-size: 0.78rem;
+  color: var(--text-faint);
+}
+
+@media (max-width: 640px) {
+  .topbar-inner { flex-wrap: wrap; }
+  main { padding: 16px; }
+  .step-card { padding: 16px; }
+}