add modal endpoint and magpietts

app.py

@@ -20,9 +20,9 @@ from backend.config import (
 from backend.epub import EpubConfig, parse_epub
 from backend.export import export_audiobook
 from backend.input_files import resolve_uploaded_name, resolve_uploaded_path
-from backend.omnivoice_adapter import OmniVoiceAdapter
-from backend.render_pipeline import RenderPipeline
 from backend.session_store import SessionStore
+from backend.synthesis_catalog import MAGPIE_OPTIONS, SYNTHESIS_BACKENDS, SYNTHESIS_MODELS
+from backend.synthesis_service import SynthesisService
 from backend.types import VoiceConfig
 from backend.voice_design import VOICE_DESIGN_OPTIONS
 from backend.voice_presets import VOICE_PRESETS
@@ -36,8 +36,7 @@ app = Server()
 app.title = APP_TITLE
 
 store = SessionStore(root=TEMP_ROOT, ttl_seconds=SESSION_TTL_SECONDS)
-synthesizer = OmniVoiceAdapter()
-pipeline = RenderPipeline(session_root=TEMP_ROOT, synthesizer=synthesizer)
+synthesis_service = SynthesisService(session_root=TEMP_ROOT)
 
 
 def _session_root(session_id: str) -> Path:
@@ -101,7 +100,7 @@ def generate_preview_api(
     text = str(chapter["text"])[:MAX_PREVIEW_CHARACTERS]
     preview_path = _session_root(session_id) / "previews" / f"{chapter_id}.wav"
     voice = _voice_config_for_backend(voice_config, session_id)
-    result = synthesizer.synthesize(
+    result = synthesis_service.generate_preview(
         text=text,
         output_path=preview_path,
         voice_config=VoiceConfig.from_dict(voice),
@@ -112,6 +111,7 @@ def generate_preview_api(
         "url": f"/files/{session_id}/previews/{preview_path.name}",
         "duration_seconds": result["duration_seconds"],
         "backend": result["backend"],
+        "model": result["model"],
     }
 
 
@@ -123,14 +123,14 @@ def start_render_api(
     diffusion_steps: int = 32,
     speed: float = 1.0,
 ) -> Generator[Dict[str, Any], None, None]:
-    job = pipeline.get_job(session_id)
+    job = synthesis_service.get_job(session_id)
     if job.status == "running":
         raise ValueError("A render is already active for this session")
 
     book = _selected_book(session_id, selected_chapter_ids)
     voice = _voice_config_for_backend(voice_config, session_id)
     captured: List[Dict[str, Any]] = []
-    for event in pipeline.render(
+    for event in synthesis_service.render(
         session_id=session_id,
         book=book,
         chapters=book["chapters"],
@@ -170,18 +170,17 @@ def start_render_api(
 
 @app.api(name="pause_render")
 def pause_render_api(session_id: str) -> Dict[str, Any]:
-    return pipeline.pause(session_id)
+    return synthesis_service.pause(session_id)
 
 
 @app.api(name="resume_render")
 def resume_render_api(session_id: str) -> Dict[str, Any]:
-    return pipeline.resume(session_id)
+    return synthesis_service.resume(session_id)
 
 
 @app.api(name="cancel_render")
 def cancel_render_api(session_id: str) -> Dict[str, Any]:
-    pipeline.cancel(session_id)
-    return {"type": "cancelled", "session_id": session_id}
+    return synthesis_service.cancel(session_id)
 
 
 @app.api(name="export_audiobook")
@@ -211,6 +210,9 @@ async def homepage() -> HTMLResponse:
         "<script>"
         f"window.__VOICE_PRESETS__ = {json.dumps(VOICE_PRESETS)};"
         f"window.__VOICE_DESIGN_OPTIONS__ = {json.dumps(VOICE_DESIGN_OPTIONS)};"
+        f"window.__MAGPIE_OPTIONS__ = {json.dumps(MAGPIE_OPTIONS)};"
+        f"window.__SYNTHESIS_MODELS__ = {json.dumps(SYNTHESIS_MODELS)};"
+        f"window.__SYNTHESIS_BACKENDS__ = {json.dumps(SYNTHESIS_BACKENDS)};"
         "</script>"
     )
     return HTMLResponse(html.replace("</body>", f"    {preset_script}\n  </body>"))

backend/magpie_adapter.py

@@ -0,0 +1,166 @@
+import base64
+import math
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+import numpy as np
+import soundfile as sf
+
+from backend.synthesis_catalog import MAGPIE_LANGUAGES, MAGPIE_MODEL, MAGPIE_SPEAKERS
+from backend.types import VoiceConfig
+
+try:
+    import spaces
+except ImportError:
+    class _SpacesShim:
+        @staticmethod
+        def GPU(fn=None, **_kwargs):
+            def decorate(inner):
+                return inner
+
+            if fn is not None:
+                return decorate(fn)
+            return decorate
+
+    spaces = _SpacesShim()
+
+
+MAGPIE_SPEAKER_IDS = {
+    speaker["value"]: index
+    for index, speaker in enumerate(
+        sorted(MAGPIE_SPEAKERS, key=lambda item: ["John", "Sofia", "Aria", "Jason", "Leo"].index(item["value"]))
+    )
+}
+MAGPIE_SUPPORTED_LANGUAGES = {language["value"] for language in MAGPIE_LANGUAGES}
+
+
+class MagpieAdapter:
+    def __init__(
+        self,
+        repo_id: str = "nvidia/magpie_tts_multilingual_357m",
+        checkpoint_filename: str = "magpie_tts_multilingual_357m.nemo",
+        codec_model_path: str = "nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps",
+    ) -> None:
+        self.repo_id = repo_id
+        self.checkpoint_filename = checkpoint_filename
+        self.codec_model_path = codec_model_path
+        self._model = None
+        self._engine = "fallback"
+
+    def _checkpoint_path(self) -> str:
+        from huggingface_hub import hf_hub_download
+
+        return hf_hub_download(
+            repo_id=self.repo_id,
+            filename=self.checkpoint_filename,
+            token=os.environ.get("HF_TOKEN"),
+        )
+
+    def _load_model(self):
+        if self._model is not None:
+            return self._model
+        try:
+            import torch
+            from nemo.collections.tts.modules.magpietts_inference.utils import (
+                ModelLoadConfig,
+                load_magpie_model,
+            )
+        except Exception:
+            self._engine = "fallback"
+            return None
+
+        config = ModelLoadConfig(
+            nemo_file=self._checkpoint_path(),
+            codecmodel_path=self.codec_model_path,
+            legacy_codebooks=False,
+            legacy_text_conditioning=False,
+            hparams_from_wandb=None,
+        )
+        model, _ = load_magpie_model(config)
+        model.eval()
+        if torch.cuda.is_available():
+            model.cuda()
+        self._model = model
+        self._engine = "magpie"
+        return self._model
+
+    @spaces.GPU(duration=300)
+    def synthesize(
+        self,
+        *,
+        text: str,
+        output_path: Path,
+        voice_config: VoiceConfig,
+        diffusion_steps: int,
+        speed: float,
+        language: Optional[str] = None,
+    ) -> Dict[str, object]:
+        del diffusion_steps, speed
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        speaker = voice_config.speaker or "Sofia"
+        if speaker not in MAGPIE_SPEAKER_IDS:
+            raise ValueError(f"Unsupported Magpie speaker: {speaker}")
+        target_language = voice_config.language or language or "en"
+        if target_language not in MAGPIE_SUPPORTED_LANGUAGES:
+            raise ValueError(f"Unsupported Magpie language: {target_language}")
+
+        model = self._load_model()
+        if model is None:
+            return self._synthesize_fallback(
+                text=text,
+                output_path=output_path,
+                speaker=speaker,
+                apply_text_normalization=voice_config.apply_text_normalization,
+            )
+
+        cleaned_text = text.strip()
+        if cleaned_text and cleaned_text[-1] not in ".?!":
+            cleaned_text = f"{cleaned_text}."
+        audio, audio_len = model.do_tts(
+            cleaned_text,
+            language=target_language,
+            apply_TN=voice_config.apply_text_normalization,
+            speaker_index=MAGPIE_SPEAKER_IDS[speaker],
+        )
+        waveform = audio[0, : audio_len[0]].detach().cpu().numpy().astype(np.float32)
+        sample_rate = int(getattr(model, "sample_rate", 22050))
+        sf.write(str(output_path), waveform, sample_rate)
+        duration_seconds = int(round(len(waveform) / sample_rate))
+        return {
+            "duration_seconds": max(1, duration_seconds),
+            "sample_rate": sample_rate,
+            "backend": "local",
+            "model": MAGPIE_MODEL,
+            "engine": self._engine,
+        }
+
+    def _synthesize_fallback(
+        self,
+        *,
+        text: str,
+        output_path: Path,
+        speaker: str,
+        apply_text_normalization: bool,
+    ) -> Dict[str, object]:
+        sample_rate = 22050
+        duration_seconds = max(1.0, min(20.0, len(text.split()) * 0.42))
+        total_samples = int(sample_rate * duration_seconds)
+        speaker_index = MAGPIE_SPEAKER_IDS.get(speaker, 0)
+        base_freq = 170.0 + (speaker_index * 28.0)
+        if apply_text_normalization:
+            base_freq += 8.0
+
+        timeline = np.linspace(0, duration_seconds, total_samples, endpoint=False)
+        waveform = (
+            0.16 * np.sin(2 * math.pi * base_freq * timeline)
+            + 0.04 * np.sin(2 * math.pi * (base_freq * 1.5) * timeline)
+        ).astype(np.float32)
+        sf.write(str(output_path), waveform, sample_rate)
+        return {
+            "duration_seconds": int(round(duration_seconds)),
+            "sample_rate": sample_rate,
+            "backend": "local",
+            "model": MAGPIE_MODEL,
+            "engine": self._engine,
+        }

backend/modal_client.py

@@ -0,0 +1,183 @@
+import base64
+import os
+import time
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+import requests
+
+from backend.synthesis_catalog import MODAL_BACKEND
+from backend.types import VoiceConfig
+
+
+class ModalSynthesisClient:
+    def __init__(
+        self,
+        *,
+        base_url: Optional[str],
+        auth_token: Optional[str] = None,
+        timeout_seconds: float = 60.0,
+        poll_interval_seconds: float = 1.0,
+    ) -> None:
+        self.base_url = base_url.rstrip("/") if base_url else None
+        self.auth_token = auth_token
+        self.timeout_seconds = timeout_seconds
+        self.poll_interval_seconds = poll_interval_seconds
+
+    @classmethod
+    def from_env(cls) -> "ModalSynthesisClient":
+        return cls(
+            base_url=os.getenv("SCRIPTORIUM_MODAL_BASE_URL"),
+            auth_token=os.getenv("SCRIPTORIUM_MODAL_AUTH_TOKEN"),
+            timeout_seconds=float(os.getenv("SCRIPTORIUM_MODAL_TIMEOUT_SECONDS", "60")),
+            poll_interval_seconds=float(os.getenv("SCRIPTORIUM_MODAL_POLL_INTERVAL_SECONDS", "1")),
+        )
+
+    def is_configured(self) -> bool:
+        return bool(self.base_url)
+
+    def generate_preview(
+        self,
+        *,
+        text: str,
+        output_path: Path,
+        voice_config: VoiceConfig,
+        diffusion_steps: int,
+        speed: float,
+    ) -> Dict[str, object]:
+        payload = {
+            "text": text,
+            "voice_config": voice_config.to_dict(),
+            "diffusion_steps": diffusion_steps,
+            "speed": speed,
+        }
+        data = self._post_json("/preview", payload)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_bytes(base64.b64decode(data["audio_base64"]))
+        return {
+            "duration_seconds": int(data.get("duration_seconds", 0)),
+            "sample_rate": int(data.get("sample_rate", 24000)),
+            "backend": MODAL_BACKEND,
+            "model": voice_config.model,
+        }
+
+    def submit_render(
+        self,
+        *,
+        session_id: str,
+        book: Dict[str, object],
+        chapters: List[Dict[str, object]],
+        voice_config: VoiceConfig,
+        diffusion_steps: int,
+        speed: float,
+    ) -> str:
+        payload = {
+            "session_id": session_id,
+            "book": book,
+            "chapters": chapters,
+            "voice_config": voice_config.to_dict(),
+            "diffusion_steps": diffusion_steps,
+            "speed": speed,
+        }
+        data = self._post_json("/renders", payload)
+        job_id = data.get("job_id")
+        if not job_id:
+            raise ValueError("Modal render submission did not return a job id")
+        return str(job_id)
+
+    def render(
+        self,
+        *,
+        session_id: str,
+        job_id: str,
+        render_dir: Path,
+        voice_config: VoiceConfig,
+    ) -> Iterable[Dict[str, object]]:
+        cursor = 0
+        while True:
+            data = self._get_json(f"/renders/{job_id}", params={"cursor": cursor})
+            events = list(data.get("events") or [])
+            cursor += len(events)
+            for event in events:
+                yield self._materialize_event(
+                    session_id=session_id,
+                    render_dir=render_dir,
+                    voice_config=voice_config,
+                    event=event,
+                )
+            status = str(data.get("status", "pending"))
+            if status in {"completed", "failed", "cancelled"}:
+                break
+            time.sleep(self.poll_interval_seconds)
+
+    def cancel_render(self, job_id: str) -> Dict[str, object]:
+        data = self._post_json(f"/renders/{job_id}/cancel", {})
+        return {
+            "type": data.get("type", "cancelled"),
+            "job_id": job_id,
+            "backend": MODAL_BACKEND,
+        }
+
+    def _materialize_event(
+        self,
+        *,
+        session_id: str,
+        render_dir: Path,
+        voice_config: VoiceConfig,
+        event: Dict[str, object],
+    ) -> Dict[str, object]:
+        materialized = dict(event)
+        materialized.setdefault("session_id", session_id)
+        materialized.setdefault("backend", MODAL_BACKEND)
+        materialized.setdefault("model", voice_config.model)
+        artifact_url = materialized.get("artifact_url")
+        filename = materialized.get("filename")
+        if artifact_url and filename:
+            output_path = render_dir / str(filename)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            response = requests.get(
+                self._absolute_url(str(artifact_url)),
+                headers=self._headers(),
+                timeout=self.timeout_seconds,
+            )
+            response.raise_for_status()
+            output_path.write_bytes(response.content)
+            materialized["output_path"] = str(output_path)
+        return materialized
+
+    def _post_json(self, path: str, payload: Dict[str, object]) -> Dict[str, object]:
+        self._ensure_configured()
+        response = requests.post(
+            self._absolute_url(path),
+            json=payload,
+            headers=self._headers(),
+            timeout=self.timeout_seconds,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _get_json(self, path: str, *, params: Dict[str, object]) -> Dict[str, object]:
+        self._ensure_configured()
+        response = requests.get(
+            self._absolute_url(path),
+            params=params,
+            headers=self._headers(),
+            timeout=self.timeout_seconds,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def _absolute_url(self, path: str) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+        return f"{self.base_url}{path}"
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {"Accept": "application/json"}
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+        return headers
+
+    def _ensure_configured(self) -> None:
+        if not self.base_url:
+            raise ValueError("Modal backend is not configured. Set SCRIPTORIUM_MODAL_BASE_URL.")

backend/omnivoice_adapter.py

@@ -35,6 +35,7 @@ class OmniVoiceAdapter:
         self.dtype_name = dtype_name
         self._model = None
         self._backend = "fallback"
+        self._voice_clone_prompt_cache = {}
 
     def _load_model(self):
         if self._model is not None:
@@ -76,18 +77,22 @@ class OmniVoiceAdapter:
                 speed=speed,
             )
 
+        from omnivoice.models.omnivoice import OmniVoiceGenerationConfig
+
         kwargs = {
             "text": text,
-            "num_step": diffusion_steps,
             "speed": speed,
+            "generation_config": OmniVoiceGenerationConfig(
+                num_step=diffusion_steps,
+                position_temperature=0.0,
+                class_temperature=0.0,
+            ),
         }
         if language:
             kwargs["language"] = language
 
         if voice_config.mode == "clone":
-            kwargs["ref_audio"] = voice_config.sample_path
-            if voice_config.reference_text:
-                kwargs["ref_text"] = voice_config.reference_text
+            kwargs["voice_clone_prompt"] = self._voice_clone_prompt(voice_config, model)
         elif voice_config.mode == "design":
             kwargs["instruct"] = voice_config.design_prompt
         elif voice_config.narrator_id:
@@ -103,9 +108,26 @@ class OmniVoiceAdapter:
         return {
             "duration_seconds": max(1, duration_seconds),
             "sample_rate": sample_rate,
-            "backend": self._backend,
+            "backend": "local",
+            "model": "omnivoice",
+            "engine": self._backend,
         }
 
+    def _voice_clone_prompt(self, voice_config: VoiceConfig, model):
+        cache_key = (
+            voice_config.sample_path or "",
+            voice_config.reference_text or "",
+        )
+        prompt = self._voice_clone_prompt_cache.get(cache_key)
+        if prompt is not None:
+            return prompt
+        prompt = model.create_voice_clone_prompt(
+            ref_audio=voice_config.sample_path,
+            ref_text=voice_config.reference_text,
+        )
+        self._voice_clone_prompt_cache[cache_key] = prompt
+        return prompt
+
     def _synthesize_fallback(
         self,
         *,
@@ -136,5 +158,7 @@ class OmniVoiceAdapter:
         return {
             "duration_seconds": int(round(duration_seconds)),
             "sample_rate": sample_rate,
-            "backend": self._backend,
+            "backend": "local",
+            "model": "omnivoice",
+            "engine": self._backend,
         }

backend/render_pipeline.py

@@ -5,7 +5,7 @@ from backend.types import RenderArtifact, RenderJob, VoiceConfig
 
 
 class RenderPipeline:
-    def __init__(self, session_root: Path, synthesizer) -> None:
+    def __init__(self, session_root: Path, synthesizer=None) -> None:
         self.session_root = Path(session_root)
         self.session_root.mkdir(parents=True, exist_ok=True)
         self.synthesizer = synthesizer
@@ -39,17 +39,23 @@ class RenderPipeline:
         voice_config: Dict[str, object],
         diffusion_steps: int,
         speed: float,
+        synthesizer=None,
     ) -> Iterable[Dict[str, object]]:
         selected = [chapter for chapter in chapters if chapter.get("included", True)]
         job = self.get_job(session_id)
         job.status = "running"
         job.outputs.clear()
+        synth = synthesizer or self.synthesizer
+        if synth is None:
+            raise ValueError("No synthesizer provided for render pipeline")
 
         yield {
             "type": "started",
             "session_id": session_id,
             "total_chapters": len(selected),
             "book_title": book.get("title"),
+            "backend": "local",
+            "model": VoiceConfig.from_dict(voice_config).model,
         }
 
         voice = VoiceConfig.from_dict(voice_config)
@@ -58,7 +64,7 @@ class RenderPipeline:
 
         for index, chapter in enumerate(selected):
             if session_id in self._cancelled:
-                yield {"type": "cancelled", "session_id": session_id}
+                yield {"type": "cancelled", "session_id": session_id, "backend": "local", "model": voice.model}
                 self._cancelled.discard(session_id)
                 job.status = "cancelled"
                 return
@@ -72,10 +78,12 @@ class RenderPipeline:
                 "chapter_title": chapter["title"],
                 "chapter_index": index,
                 "overall_progress": index / max(1, len(selected)),
+                "backend": "local",
+                "model": voice.model,
             }
 
             output_path = render_dir / f"{index + 1:03d}-{chapter_id}.wav"
-            result = self.synthesizer.synthesize(
+            result = synth.synthesize(
                 text=str(chapter["text"]),
                 output_path=output_path,
                 voice_config=voice,
@@ -88,6 +96,8 @@ class RenderPipeline:
                 "session_id": session_id,
                 "chapter_id": chapter_id,
                 "percent": 100,
+                "backend": result.get("backend", "local"),
+                "model": result.get("model", voice.model),
             }
 
             artifact = RenderArtifact(
@@ -103,6 +113,8 @@ class RenderPipeline:
                 "duration_seconds": artifact.duration_seconds,
                 "overall_progress": (index + 1) / max(1, len(selected)),
                 "output_path": str(output_path),
+                "backend": result.get("backend", "local"),
+                "model": result.get("model", voice.model),
             }
 
         job.status = "completed"
@@ -110,4 +122,6 @@ class RenderPipeline:
             "type": "completed",
             "session_id": session_id,
             "outputs": [str(artifact.path) for artifact in job.outputs],
+            "backend": "local",
+            "model": voice.model,
         }

backend/synthesis_catalog.py

@@ -0,0 +1,56 @@
+OMNIVOICE_MODEL = "omnivoice"
+MAGPIE_MODEL = "magpie"
+
+LOCAL_BACKEND = "local"
+MODAL_BACKEND = "modal"
+
+SYNTHESIS_MODELS = [
+    {
+        "id": OMNIVOICE_MODEL,
+        "name": "OmniVoice",
+        "desc": "Presets, design prompts, and voice cloning",
+    },
+    {
+        "id": MAGPIE_MODEL,
+        "name": "Magpie TTS",
+        "desc": "Multilingual speaker presets with text normalization",
+    },
+]
+
+SYNTHESIS_BACKENDS = [
+    {
+        "id": LOCAL_BACKEND,
+        "name": "HF/local",
+        "desc": "Run synthesis inside this Space runtime",
+    },
+    {
+        "id": MODAL_BACKEND,
+        "name": "Modal",
+        "desc": "Offload synthesis to a deployed Modal worker",
+    },
+]
+
+MAGPIE_SPEAKERS = [
+    {"value": "Sofia", "label": "Sofia"},
+    {"value": "Aria", "label": "Aria"},
+    {"value": "Jason", "label": "Jason"},
+    {"value": "Leo", "label": "Leo"},
+    {"value": "John", "label": "John"},
+]
+
+MAGPIE_LANGUAGES = [
+    {"value": "en", "label": "English"},
+    {"value": "de", "label": "German"},
+    {"value": "es", "label": "Spanish"},
+    {"value": "fr", "label": "French"},
+    {"value": "it", "label": "Italian"},
+    {"value": "vi", "label": "Vietnamese"},
+    {"value": "zh", "label": "Mandarin Chinese"},
+    {"value": "hi", "label": "Hindi"},
+    {"value": "ja", "label": "Japanese"},
+]
+
+MAGPIE_OPTIONS = {
+    "speakers": MAGPIE_SPEAKERS,
+    "languages": MAGPIE_LANGUAGES,
+}

backend/synthesis_service.py

@@ -0,0 +1,162 @@
+from pathlib import Path
+from typing import Dict, Iterable, Optional
+
+from backend.magpie_adapter import MagpieAdapter
+from backend.modal_client import ModalSynthesisClient
+from backend.omnivoice_adapter import OmniVoiceAdapter
+from backend.render_pipeline import RenderPipeline
+from backend.synthesis_catalog import LOCAL_BACKEND, MODAL_BACKEND, MAGPIE_MODEL, OMNIVOICE_MODEL
+from backend.types import RenderJob, VoiceConfig
+
+
+class SynthesisService:
+    def __init__(
+        self,
+        *,
+        session_root: Path,
+        local_synthesizers: Optional[Dict[str, object]] = None,
+        modal_client: Optional[ModalSynthesisClient] = None,
+    ) -> None:
+        self.session_root = Path(session_root)
+        self.session_root.mkdir(parents=True, exist_ok=True)
+        self.local_synthesizers = local_synthesizers or {
+            OMNIVOICE_MODEL: OmniVoiceAdapter(),
+            MAGPIE_MODEL: MagpieAdapter(),
+        }
+        self.modal_client = modal_client or ModalSynthesisClient.from_env()
+        self.pipeline = RenderPipeline(session_root=self.session_root)
+        self._active_backends: Dict[str, str] = {}
+        self._modal_job_ids: Dict[str, str] = {}
+        self._modal_status: Dict[str, str] = {}
+
+    def get_job(self, session_id: str) -> RenderJob:
+        if self._active_backends.get(session_id) == MODAL_BACKEND:
+            return RenderJob(
+                session_id=session_id,
+                status=self._modal_status.get(session_id, "idle"),
+            )
+        return self.pipeline.get_job(session_id)
+
+    def generate_preview(
+        self,
+        *,
+        text: str,
+        output_path: Path,
+        voice_config: VoiceConfig,
+        diffusion_steps: int,
+        speed: float,
+    ) -> Dict[str, object]:
+        if voice_config.backend == MODAL_BACKEND:
+            return self.modal_client.generate_preview(
+                text=text,
+                output_path=output_path,
+                voice_config=voice_config,
+                diffusion_steps=diffusion_steps,
+                speed=speed,
+            )
+        synthesizer = self._local_synthesizer(voice_config.model)
+        result = synthesizer.synthesize(
+            text=text,
+            output_path=output_path,
+            voice_config=voice_config,
+            diffusion_steps=diffusion_steps,
+            speed=speed,
+        )
+        result.setdefault("backend", LOCAL_BACKEND)
+        result.setdefault("model", voice_config.model)
+        return result
+
+    def render(
+        self,
+        *,
+        session_id: str,
+        book: Dict[str, object],
+        chapters: list[Dict[str, object]],
+        voice_config: Dict[str, object] | VoiceConfig,
+        diffusion_steps: int,
+        speed: float,
+    ) -> Iterable[Dict[str, object]]:
+        voice = voice_config if isinstance(voice_config, VoiceConfig) else VoiceConfig.from_dict(voice_config)
+        self._active_backends[session_id] = voice.backend
+        if voice.backend == MODAL_BACKEND:
+            yield from self._render_modal(
+                session_id=session_id,
+                book=book,
+                chapters=chapters,
+                voice_config=voice,
+                diffusion_steps=diffusion_steps,
+                speed=speed,
+            )
+            return
+
+        synthesizer = self._local_synthesizer(voice.model)
+        yield from self.pipeline.render(
+            session_id=session_id,
+            book=book,
+            chapters=chapters,
+            voice_config=voice.to_dict(),
+            diffusion_steps=diffusion_steps,
+            speed=speed,
+            synthesizer=synthesizer,
+        )
+
+    def pause(self, session_id: str) -> Dict[str, object]:
+        if self._active_backends.get(session_id) == MODAL_BACKEND:
+            raise ValueError("Pause is only supported for local renders")
+        return self.pipeline.pause(session_id)
+
+    def resume(self, session_id: str) -> Dict[str, object]:
+        if self._active_backends.get(session_id) == MODAL_BACKEND:
+            raise ValueError("Resume is only supported for local renders")
+        return self.pipeline.resume(session_id)
+
+    def cancel(self, session_id: str) -> Dict[str, object]:
+        if self._active_backends.get(session_id) == MODAL_BACKEND:
+            job_id = self._modal_job_ids.get(session_id)
+            if not job_id:
+                return {"type": "cancelled", "session_id": session_id, "backend": MODAL_BACKEND}
+            self._modal_status[session_id] = "cancelled"
+            result = self.modal_client.cancel_render(job_id)
+            return {**result, "session_id": session_id}
+        self.pipeline.cancel(session_id)
+        return {"type": "cancelled", "session_id": session_id, "backend": LOCAL_BACKEND}
+
+    def _render_modal(
+        self,
+        *,
+        session_id: str,
+        book: Dict[str, object],
+        chapters: list[Dict[str, object]],
+        voice_config: VoiceConfig,
+        diffusion_steps: int,
+        speed: float,
+    ) -> Iterable[Dict[str, object]]:
+        render_dir = self.session_root / session_id / "renders"
+        render_dir.mkdir(parents=True, exist_ok=True)
+        self._modal_status[session_id] = "pending"
+        job_id = self.modal_client.submit_render(
+            session_id=session_id,
+            book=book,
+            chapters=chapters,
+            voice_config=voice_config,
+            diffusion_steps=diffusion_steps,
+            speed=speed,
+        )
+        self._modal_job_ids[session_id] = job_id
+        self._modal_status[session_id] = "running"
+        for event in self.modal_client.render(
+            session_id=session_id,
+            job_id=job_id,
+            render_dir=render_dir,
+            voice_config=voice_config,
+        ):
+            self._modal_status[session_id] = str(event.get("type", "running"))
+            yield event
+        if self._modal_status.get(session_id) not in {"failed", "cancelled"}:
+            self._modal_status[session_id] = "completed"
+
+    def _local_synthesizer(self, model: str):
+        synthesizer = self.local_synthesizers.get(model)
+        if synthesizer is None:
+            raise ValueError(f"Unsupported synthesis model: {model}")
+        return synthesizer

backend/types.py

@@ -2,6 +2,8 @@ from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from backend.synthesis_catalog import LOCAL_BACKEND, OMNIVOICE_MODEL
+
 
 JsonDict = Dict[str, Any]
 
@@ -33,22 +35,48 @@ class SessionRecord:
 
 @dataclass
 class VoiceConfig:
-    mode: str
+    mode: str = "auto"
+    model: str = OMNIVOICE_MODEL
+    backend: str = LOCAL_BACKEND
     narrator_id: Optional[str] = None
     sample_path: Optional[str] = None
     reference_text: Optional[str] = None
     design_prompt: Optional[str] = None
+    speaker: Optional[str] = None
+    language: Optional[str] = None
+    apply_text_normalization: bool = False
 
     @classmethod
     def from_dict(cls, data: JsonDict) -> "VoiceConfig":
         return cls(
             mode=data.get("mode", "auto"),
+            model=data.get("model", OMNIVOICE_MODEL),
+            backend=data.get("backend", LOCAL_BACKEND),
             narrator_id=data.get("narratorId") or data.get("narrator_id"),
             sample_path=data.get("samplePath") or data.get("sample_path"),
             reference_text=data.get("referenceText") or data.get("reference_text"),
             design_prompt=data.get("designPrompt") or data.get("design_prompt"),
+            speaker=data.get("speaker"),
+            language=data.get("language"),
+            apply_text_normalization=bool(
+                data.get("applyTextNormalization", data.get("apply_text_normalization", False))
+            ),
         )
 
+    def to_dict(self) -> JsonDict:
+        return {
+            "mode": self.mode,
+            "model": self.model,
+            "backend": self.backend,
+            "narratorId": self.narrator_id,
+            "samplePath": self.sample_path,
+            "referenceText": self.reference_text,
+            "designPrompt": self.design_prompt,
+            "speaker": self.speaker,
+            "language": self.language,
+            "applyTextNormalization": self.apply_text_normalization,
+        }
+
 
 @dataclass
 class RenderArtifact:
@@ -63,4 +91,3 @@ class RenderJob:
     status: str = "idle"
     current_chapter_id: Optional[str] = None
     outputs: List[RenderArtifact] = field(default_factory=list)
-

frontend/app.js

@@ -2,6 +2,26 @@ import { Client, handle_file } from "https://esm.sh/@gradio/client";
 
 const NARRATORS = globalThis.__VOICE_PRESETS__ || [];
 const VOICE_DESIGN_OPTIONS = globalThis.__VOICE_DESIGN_OPTIONS__ || [];
+const MAGPIE_OPTIONS = globalThis.__MAGPIE_OPTIONS__ || {
+  speakers: [
+    { value: "Sofia", label: "Sofia" },
+    { value: "Aria", label: "Aria" },
+    { value: "Jason", label: "Jason" },
+    { value: "Leo", label: "Leo" },
+    { value: "John", label: "John" },
+  ],
+  languages: [
+    { value: "en", label: "English" },
+  ],
+};
+const SYNTHESIS_MODELS = globalThis.__SYNTHESIS_MODELS__ || [
+  { id: "omnivoice", name: "OmniVoice", desc: "Presets, design prompts, and voice cloning" },
+  { id: "magpie", name: "Magpie TTS", desc: "Multilingual speaker presets with text normalization" },
+];
+const SYNTHESIS_BACKENDS = globalThis.__SYNTHESIS_BACKENDS__ || [
+  { id: "local", name: "HF/local", desc: "Run synthesis inside this Space runtime" },
+  { id: "modal", name: "Modal", desc: "Offload synthesis to a deployed Modal worker" },
+];
 const DEFAULT_NARRATOR = NARRATORS[0] || {
   id: "the-archivist",
   name: "The Archivist",
@@ -19,11 +39,16 @@ const state = {
   book: null,
   chapters: [],
   currentChapterId: null,
+  model: "omnivoice",
+  backendSelection: "local",
   voiceMode: "auto",
   narratorId: DEFAULT_NARRATOR.id,
   cloneConsent: false,
   cloneSampleFile: null,
   cloneReferenceText: "",
+  magpieSpeaker: MAGPIE_OPTIONS.speakers?.[0]?.value || "Sofia",
+  magpieLanguage: MAGPIE_OPTIONS.languages?.[0]?.value || "en",
+  magpieApplyTextNormalization: false,
   designSelections: {
     gender: "",
     age: "",
@@ -37,8 +62,12 @@ const state = {
   errorMessage: "",
   renderStatus: null,
   renderEvents: [],
+  renderEventKeys: new Set(),
   renderResult: null,
   renderSubmission: null,
+  activeRenderBackend: "local",
+  activeRenderModel: "omnivoice",
+  exportPlayerTrackIndex: 0,
   previewUrl: "",
   exportFormat: "m4a",
   embedMarkers: true,
@@ -119,6 +148,22 @@ function handleChange(event) {
   if (target.matches("[data-design-field]")) {
     state.designSelections[target.dataset.designField] = target.value;
     render();
+    return;
+  }
+  if (target.matches("#magpie-speaker")) {
+    state.magpieSpeaker = target.value;
+    syncNarratorMetadata();
+    render();
+    return;
+  }
+  if (target.matches("#magpie-language")) {
+    state.magpieLanguage = target.value;
+    render();
+    return;
+  }
+  if (target.matches("#magpie-tn")) {
+    state.magpieApplyTextNormalization = target.checked;
+    render();
   }
 }
 
@@ -154,15 +199,21 @@ const actionHandlers = {
     syncNarratorMetadata();
     render();
   },
+  setModel(target) {
+    state.model = target.dataset.model;
+    if (state.model !== "omnivoice") {
+      state.voiceMode = "auto";
+    }
+    syncNarratorMetadata();
+    render();
+  },
+  setBackend(target) {
+    state.backendSelection = target.dataset.backend;
+    render();
+  },
   setVoiceMode(target) {
     state.voiceMode = target.dataset.mode;
-    if (state.voiceMode === "auto") {
-      syncNarratorMetadata();
-    } else if (state.voiceMode === "clone") {
-      state.exportMetadata.narrator = "Cloned Narrator (OmniVoice)";
-    } else {
-      state.exportMetadata.narrator = "Designed Narrator (OmniVoice)";
-    }
+    syncNarratorMetadata();
     render();
   },
   focusChapter(target) {
@@ -196,6 +247,10 @@ const actionHandlers = {
     render();
   },
   async exportBook() {
+    if (state.exportFile) {
+      downloadCurrentExport();
+      return;
+    }
     await requestExport();
   },
   goConfigure() {
@@ -219,15 +274,36 @@ const actionHandlers = {
     document.getElementById("clone-audio")?.click();
   },
   playExportPreview(target) {
-    const audio = document.getElementById("preview-audio");
+    const audio = exportAudioElement();
     if (!audio) return;
+    if (!audio.getAttribute("src")) {
+      playExportTrack(state.exportPlayerTrackIndex);
+      return;
+    }
     if (audio.paused) {
       audio.play();
-      target.textContent = "❚❚";
     } else {
       audio.pause();
-      target.textContent = "▶";
     }
+    syncExportControls();
+  },
+  playRenderedChapter(target) {
+    const trackIndex = Number(target.dataset.trackIndex || 0);
+    playExportTrack(trackIndex);
+  },
+  exportJumpToTrack(target) {
+    const direction = Number(target.dataset.direction || 0);
+    const tracks = playableTracks();
+    if (!tracks.length) return;
+    const nextIndex = clampTrackIndex(state.exportPlayerTrackIndex + direction, tracks.length);
+    playExportTrack(nextIndex);
+  },
+  exportSeek(target) {
+    const audio = exportAudioElement();
+    if (!audio) return;
+    const delta = Number(target.dataset.seconds || 0);
+    audio.currentTime = Math.max(0, Math.min(audio.duration || Infinity, audio.currentTime + delta));
+    syncExportControls();
   },
 };
 
@@ -281,7 +357,10 @@ async function submitRender() {
   state.statusMessage = "Submitting audiobook render…";
   state.step = "generate";
   state.renderEvents = [];
+  state.renderEventKeys = new Set();
   state.renderResult = null;
+  state.activeRenderBackend = state.backendSelection;
+  state.activeRenderModel = state.model;
   render();
 
   const submission = state.client.submit("/start_render", {
@@ -317,6 +396,8 @@ async function submitRender() {
 }
 
 function updateRenderState(payload) {
+  if (payload.backend) state.activeRenderBackend = payload.backend;
+  if (payload.model) state.activeRenderModel = payload.model;
   switch (payload.type) {
     case "started":
       state.statusMessage = `Binding ${payload.total_chapters} chapters…`;
@@ -364,6 +445,7 @@ async function requestExport() {
       embed_markers: state.embedMarkers,
     });
     state.exportFile = payload;
+    state.exportPlayerTrackIndex = clampTrackIndex(state.exportPlayerTrackIndex, Math.max(1, includedChapters().length));
     state.previewUrl = payload.url || state.previewUrl;
     state.statusMessage = `${state.exportFormat.toUpperCase()} export ready.`;
   } catch (error) {
@@ -379,8 +461,20 @@ async function callPredict(apiName, payload) {
 }
 
 function buildVoiceConfig() {
+  if (state.model === "magpie") {
+    return {
+      model: "magpie",
+      backend: state.backendSelection,
+      mode: "auto",
+      speaker: state.magpieSpeaker,
+      language: state.magpieLanguage,
+      applyTextNormalization: state.magpieApplyTextNormalization,
+    };
+  }
   if (state.voiceMode === "clone") {
     return {
+      model: "omnivoice",
+      backend: state.backendSelection,
       mode: "clone",
       referenceText: state.cloneReferenceText,
       cloneConsent: state.cloneConsent,
@@ -389,11 +483,15 @@ function buildVoiceConfig() {
   }
   if (state.voiceMode === "design") {
     return {
+      model: "omnivoice",
+      backend: state.backendSelection,
       mode: "design",
       designPrompt: buildDesignPrompt(),
     };
   }
   return {
+    model: "omnivoice",
+    backend: state.backendSelection,
     mode: "auto",
     narratorId: state.narratorId,
   };
@@ -449,10 +547,11 @@ function appendRenderEvent(payload) {
     ...payload,
     received_at: payload.received_at || new Date().toISOString(),
   };
-  const previous = state.renderEvents[state.renderEvents.length - 1];
-  if (previous && renderEventKey(previous) === renderEventKey(stamped)) {
+  const key = renderEventKey(stamped);
+  if (state.renderEventKeys.has(key)) {
     return;
   }
+  state.renderEventKeys.add(key);
   state.renderEvents.push(stamped);
 }
 
@@ -466,6 +565,8 @@ function renderEventKey(event) {
     output_path: event.output_path,
     url: event.url,
     overall_progress: event.overall_progress,
+    backend: event.backend,
+    model: event.model,
   });
 }
 
@@ -497,6 +598,8 @@ function render() {
   if (nextReadingContainer && previousReadingChapterId === nextReadingChapterId) {
     nextReadingContainer.scrollTop = previousReadingScrollTop;
   }
+  bindExportAudio();
+  syncExportControls();
 }
 
 function renderMasthead() {
@@ -507,7 +610,7 @@ function renderMasthead() {
         <div class="plaque">📖</div>
         <div>
           <div class="wordmark">Scriptorium</div>
-          <div class="tagline">Bind your library into spoken word · OmniVoice TTS</div>
+          <div class="tagline">Bind your library into spoken word · OmniVoice + Magpie TTS</div>
         </div>
       </div>
       <div class="steps">
@@ -582,30 +685,57 @@ function renderConfigure() {
         </div>
 
         <div class="voice-panel">
+          <div class="smallcaps" style="margin-bottom:9px;">Speech model</div>
           <div class="seg">
-            ${["auto", "clone", "design"].map((mode) => `
-              <button type="button" data-action="setVoiceMode" data-mode="${mode}" class="${state.voiceMode === mode ? "active" : ""}">
-                ${mode}
+            ${SYNTHESIS_MODELS.map((model) => `
+              <button type="button" data-action="setModel" data-model="${model.id}" class="${state.model === model.id ? "active" : ""}">
+                ${escapeHtml(model.name)}
               </button>
             `).join("")}
           </div>
+          <div class="chapter-meta" style="margin:10px 0 14px;">${escapeHtml(activeModelDescription())}</div>
+          <div class="smallcaps" style="margin-bottom:9px;">Execution backend</div>
+          <div class="seg">
+            ${SYNTHESIS_BACKENDS.map((backend) => `
+              <button type="button" data-action="setBackend" data-backend="${backend.id}" class="${state.backendSelection === backend.id ? "active" : ""}">
+                ${escapeHtml(backend.name)}
+              </button>
+            `).join("")}
+          </div>
+          <div class="chapter-meta" style="margin:10px 0 14px;">${escapeHtml(activeBackendDescription())}</div>
+          ${state.model === "omnivoice" ? `
+            <div class="seg">
+              ${["auto", "clone", "design"].map((mode) => `
+                <button type="button" data-action="setVoiceMode" data-mode="${mode}" class="${state.voiceMode === mode ? "active" : ""}">
+                  ${mode}
+                </button>
+              `).join("")}
+            </div>
+          ` : ""}
           ${renderVoiceMode()}
-          <div class="dial-grid">
-            <div>
-              <div class="dial-head">
-                <span class="smallcaps">Diffusion steps</span>
-                <span class="dial-value">${state.diffusionSteps}</span>
+          ${state.model === "omnivoice" ? `
+            <div class="dial-grid">
+              <div>
+                <div class="dial-head">
+                  <span class="smallcaps">Diffusion steps</span>
+                  <span class="dial-value">${state.diffusionSteps}</span>
+                </div>
+                <input id="diffusion-steps" class="range" type="range" min="8" max="64" value="${state.diffusionSteps}" />
               </div>
-              <input id="diffusion-steps" class="range" type="range" min="8" max="64" value="${state.diffusionSteps}" />
-            </div>
-            <div>
-              <div class="dial-head">
-                <span class="smallcaps">Reading speed</span>
-                <span class="dial-value">${state.speed.toFixed(1)}×</span>
+              <div>
+                <div class="dial-head">
+                  <span class="smallcaps">Reading speed</span>
+                  <span class="dial-value">${state.speed.toFixed(1)}×</span>
+                </div>
+                <input id="reading-speed" class="range" type="range" min="0.5" max="2" step="0.1" value="${state.speed}" />
               </div>
-              <input id="reading-speed" class="range" type="range" min="0.5" max="2" step="0.1" value="${state.speed}" />
             </div>
-          </div>
+          ` : `
+            <div class="design-preview" style="margin-top:14px;">
+              <div class="smallcaps" style="margin-bottom:7px;">Magpie controls</div>
+              <div class="field design-output">Speaker, language, and text normalization are controlled directly for Magpie. Speed and diffusion controls are OmniVoice-only.</div>
+            </div>
+          `}
         </div>
       </div>
     </div>
@@ -631,7 +761,7 @@ function renderGenerate() {
     <div class="hero">
       ${renderCover({ w: 92, h: 134 })}
       <div class="hero-meta">
-        <div class="smallcaps" style="display:flex; align-items:center; gap:9px; color:var(--leather);"><span class="status-dot"></span> Now binding · OmniVoice TTS</div>
+        <div class="smallcaps" style="display:flex; align-items:center; gap:9px; color:var(--leather);"><span class="status-dot"></span> Now binding · ${escapeHtml(currentRenderStackLabel())}</div>
         <div class="screen-title" style="font-size:31px; font-weight:800; margin:6px 0 14px;">
           Narrating <em style="color:var(--leather); font-style:italic;">${escapeHtml(activeChapter?.title || "your book")}</em>…
         </div>
@@ -645,7 +775,7 @@ function renderGenerate() {
         <div class="pct">${percent}<span style="font-size:24px;">%</span></div>
         <div class="smallcaps">complete</div>
         <div style="margin-top:10px; display:flex; gap:10px; justify-content:flex-end; flex-wrap:wrap;">
-          <button class="small-btn" data-action="pauseRender">Pause</button>
+          ${renderSupportsPause() ? `<button class="small-btn" data-action="pauseRender">Pause</button>` : ""}
           <button class="small-btn danger" data-action="cancelRender">Cancel</button>
         </div>
       </div>
@@ -699,7 +829,7 @@ function renderGenerate() {
     <div class="footer">
       <div class="footer-note">Binding <b>${included.length} chapters</b> · <b>${doneCount} done</b> · Export unlocks when complete</div>
       <div class="spacer"></div>
-      <button class="btn-ghost" data-action="pauseRender">Pause binding</button>
+      ${renderSupportsPause() ? `<button class="btn-ghost" data-action="pauseRender">Pause binding</button>` : ""}
       <button class="btn-primary" data-action="goExport" ${state.renderResult ? "" : "disabled"}>Continue to export</button>
     </div>
   `;
@@ -707,15 +837,19 @@ function renderGenerate() {
 
 function renderExport() {
   const tracks = includedChapters();
+  const activeTrackIndex = clampTrackIndex(state.exportPlayerTrackIndex, Math.max(1, tracks.length));
+  state.exportPlayerTrackIndex = activeTrackIndex;
   let elapsed = 0;
   const trackRows = tracks.map((track, index) => {
     const start = elapsed;
     elapsed += Number(track.duration_seconds || track.est_minutes * 60 || 0);
-    return { track, start, playing: index === 2 };
+    return { track, start, playing: index === activeTrackIndex };
   });
   const totalSeconds = elapsed || Math.round(totalMinutes() * 60);
-  const playbackSeconds = Math.min(totalSeconds, (trackRows[2]?.start || 0) + 300);
+  const playbackSeconds = Math.min(totalSeconds, trackRows[activeTrackIndex]?.start || 0);
   const percent = totalSeconds ? (playbackSeconds / totalSeconds) * 100 : 0;
+  const currentTrack = trackRows[activeTrackIndex]?.track;
+  const exportUrl = currentExportAudioUrl();
 
   return `
     <div class="hero">
@@ -733,7 +867,7 @@ function renderExport() {
       </div>
       <div>
         <button class="btn-primary" data-action="exportBook">${state.exportFile ? "Download again" : "Download audiobook"}</button>
-        ${state.exportFile ? `<div style="margin-top:10px;"><a href="${state.exportFile.url}" target="_blank" rel="noopener">Open exported file</a></div>` : `<div style="margin-top:10px; color:var(--faint); font-size:12.5px;">with embedded chapter markers</div>`}
+        ${state.exportFile ? `<div style="margin-top:10px;"><a href="${state.exportFile.url}" target="_blank" rel="noopener" download="${escapeAttr(exportFilename())}">Open exported file</a></div>` : `<div style="margin-top:10px; color:var(--faint); font-size:12.5px;">with embedded chapter markers</div>`}
       </div>
     </div>
 
@@ -743,13 +877,13 @@ function renderExport() {
           <h2 class="panel-title">Chapters &amp; markers</h2>
           <span class="right">${tracks.length} tracks</span>
         </div>
-        <div class="queue">
+          <div class="queue">
           <div class="list-head">Chapter <span class="count">${formatRuntime(totalSeconds / 60)} total</span></div>
           <div class="track-list">
-            ${trackRows.map(({ track, start, playing }) => `
+            ${trackRows.map(({ track, start, playing }, index) => `
               <div class="track-row ${playing ? "playing" : ""}">
                 <span class="roman">${escapeHtml(track.n)}</span>
-                <button class="circle-btn">${playing ? "❚❚" : "▶"}</button>
+                <button class="circle-btn" data-action="playRenderedChapter" data-track-index="${index}">${playing ? "❚❚" : "▶"}</button>
                 <div class="track-main">
                   <div class="track-name">${escapeHtml(track.title)}</div>
                   <div class="track-meta">starts at ${formatStamp(start)}</div>
@@ -768,25 +902,25 @@ function renderExport() {
           <div style="display:flex; gap:18px; align-items:center; margin-bottom:18px;">
             ${renderCover({ w: 70, h: 102 })}
             <div>
-              <div class="smallcaps">Now playing · chapter ${trackRows[2]?.track.n || "i"}</div>
-              <div class="player-title" style="font-size:24px; font-weight:700;">${escapeHtml(trackRows[2]?.track.title || state.book?.title || "Preview")}</div>
+              <div class="smallcaps">Now playing · chapter ${currentTrack?.n || "i"}</div>
+              <div class="player-title" style="font-size:24px; font-weight:700;">${escapeHtml(currentTrack?.title || state.book?.title || "Preview")}</div>
               <div class="chapter-meta">narrated by ${escapeHtml(activeNarratorName())} · 1.0×</div>
             </div>
           </div>
-          <div class="scrubber">
-            <div class="scrub-fill" style="width:${percent}%"></div>
+          <div class="scrubber" data-export-scrubber>
+            <div class="scrub-fill" data-export-scrub-fill style="width:${percent}%"></div>
             ${trackRows.map(({ start }, index) => index ? `<span class="scrub-tick" style="left:${(start / totalSeconds) * 100}%"></span>` : "").join("")}
-            <span class="scrub-head" style="left:${percent}%"></span>
+            <span class="scrub-head" data-export-scrub-head style="left:${percent}%"></span>
           </div>
-          <div class="track-meta" style="display:flex; justify-content:space-between;"> <span>${formatStamp(playbackSeconds)} elapsed</span> <span>−${formatRuntime((totalSeconds - playbackSeconds) / 60)}</span></div>
+          <div class="track-meta" style="display:flex; justify-content:space-between;"> <span data-export-elapsed>${formatStamp(playbackSeconds)} elapsed</span> <span data-export-remaining>−${formatRuntime((totalSeconds - playbackSeconds) / 60)}</span></div>
           <div class="transport">
-            <button class="transport-btn">⏮</button>
-            <button class="transport-btn">↺15</button>
-            <button class="transport-btn main" data-action="playExportPreview">▶</button>
-            <button class="transport-btn">30↻</button>
-            <button class="transport-btn">⏭</button>
+            <button class="transport-btn" data-action="exportJumpToTrack" data-direction="-1">⏮</button>
+            <button class="transport-btn" data-action="exportSeek" data-seconds="-15">↺15</button>
+            <button class="transport-btn main" data-action="playExportPreview" data-export-play>▶</button>
+            <button class="transport-btn" data-action="exportSeek" data-seconds="30">30↻</button>
+            <button class="transport-btn" data-action="exportJumpToTrack" data-direction="1">⏭</button>
           </div>
-          ${state.previewUrl ? `<audio id="preview-audio" src="${state.previewUrl}" preload="metadata"></audio>` : ""}
+          ${exportUrl ? `<audio id="preview-audio" src="${escapeAttr(exportUrl)}" preload="metadata"></audio>` : ""}
         </div>
         <div class="options">
           <div class="smallcaps" style="margin-bottom:9px;">Export format</div>
@@ -836,7 +970,7 @@ function renderCover(options = {}) {
       <span class="cover-corner bottom"></span>
       <div class="cover-title" style="font-size:${18 * scale}px;">${escapeHtml(state.book?.title || "Scriptorium")}</div>
       <div class="cover-rule" style="width:${38 * scale}px;"></div>
-      <div class="cover-author" style="font-size:${13 * scale}px;">${escapeHtml(state.book?.author || "OmniVoice")}</div>
+      <div class="cover-author" style="font-size:${13 * scale}px;">${escapeHtml(state.book?.author || activeModelName())}</div>
     </div>
   `;
 }
@@ -901,6 +1035,36 @@ function renderChapterBody(text) {
 }
 
 function renderVoiceMode() {
+  if (state.model === "magpie") {
+    return `
+      <div class="design-grid">
+        <label style="display:block;">
+          <div class="smallcaps" style="margin-bottom:7px;">Speaker</div>
+          <select id="magpie-speaker" class="field">
+            ${MAGPIE_OPTIONS.speakers.map((speaker) => `
+              <option value="${escapeAttr(speaker.value)}" ${state.magpieSpeaker === speaker.value ? "selected" : ""}>
+                ${escapeHtml(speaker.label)}
+              </option>
+            `).join("")}
+          </select>
+        </label>
+        <label style="display:block;">
+          <div class="smallcaps" style="margin-bottom:7px;">Language</div>
+          <select id="magpie-language" class="field">
+            ${MAGPIE_OPTIONS.languages.map((language) => `
+              <option value="${escapeAttr(language.value)}" ${state.magpieLanguage === language.value ? "selected" : ""}>
+                ${escapeHtml(language.label)}
+              </option>
+            `).join("")}
+          </select>
+        </label>
+      </div>
+      <label style="display:flex; gap:10px; align-items:flex-start; margin-top:14px;">
+        <input id="magpie-tn" type="checkbox" ${state.magpieApplyTextNormalization ? "checked" : ""} />
+        <span>Apply text normalization for numbers, abbreviations, and special characters when supported by the selected language.</span>
+      </label>
+    `;
+  }
   if (state.voiceMode === "clone") {
     return `
       <div class="drop-zone">
@@ -989,19 +1153,20 @@ function renderLogRow(event) {
 }
 
 function logMessage(event) {
+  const suffix = event.backend === "modal" ? " via Modal" : "";
   switch (event.type) {
     case "started":
-      return `Began binding ${event.total_chapters} chapters`;
+      return `Began binding ${event.total_chapters} chapters${suffix}`;
     case "chapter_started":
-      return `Synthesising ${event.chapter_title}`;
+      return `Synthesising ${event.chapter_title}${suffix}`;
     case "chapter_progress":
-      return `${chapterTitle(event.chapter_id)} is still rendering`;
+      return `${chapterTitle(event.chapter_id)} is still rendering${suffix}`;
     case "chapter_done":
-      return `Bound ${chapterTitle(event.chapter_id)} · ${event.duration_seconds}s`;
+      return `Bound ${chapterTitle(event.chapter_id)} · ${event.duration_seconds}s${suffix}`;
     case "completed":
-      return "Completed audiobook render";
+      return `Completed audiobook render${suffix}`;
     case "cancelled":
-      return "Cancelled render";
+      return `Cancelled render${suffix}`;
     default:
       return JSON.stringify(event);
   }
@@ -1019,9 +1184,166 @@ function renderCompletedChapterRow(chapter) {
   `;
 }
 
+function bindExportAudio() {
+  const audio = exportAudioElement();
+  if (!audio || audio.dataset.bound === "true") return;
+  audio.dataset.bound = "true";
+  audio.addEventListener("play", syncExportControls);
+  audio.addEventListener("pause", syncExportControls);
+  audio.addEventListener("loadedmetadata", syncExportControls);
+  audio.addEventListener("timeupdate", syncExportControls);
+  audio.addEventListener("ended", handleExportAudioEnded);
+}
+
+function handleExportAudioEnded() {
+  const audio = exportAudioElement();
+  if (!audio) return;
+  const tracks = playableTracks();
+  if (!tracks.length) {
+    syncExportControls();
+    return;
+  }
+  if (usingMergedExportAudio()) {
+    const nextIndex = state.exportPlayerTrackIndex + 1;
+    if (nextIndex < tracks.length) {
+      playExportTrack(nextIndex);
+      return;
+    }
+  } else {
+    const nextIndex = state.exportPlayerTrackIndex + 1;
+    if (nextIndex < tracks.length) {
+      playExportTrack(nextIndex);
+      return;
+    }
+  }
+  syncExportControls();
+}
+
+function exportAudioElement() {
+  return document.getElementById("preview-audio");
+}
+
+function playableTracks() {
+  return includedChapters();
+}
+
+function clampTrackIndex(index, length) {
+  if (!length) return 0;
+  return Math.max(0, Math.min(length - 1, index));
+}
+
+function usingMergedExportAudio() {
+  return Boolean(state.exportFile && state.exportFormat !== "zip");
+}
+
+function exportTrackStartSeconds(trackIndex) {
+  const tracks = playableTracks();
+  let elapsed = 0;
+  for (let index = 0; index < tracks.length; index += 1) {
+    if (index === trackIndex) return elapsed;
+    elapsed += Number(tracks[index].duration_seconds || tracks[index].est_minutes * 60 || 0);
+  }
+  return 0;
+}
+
+function currentExportAudioUrl() {
+  if (usingMergedExportAudio()) return state.exportFile?.url || "";
+  const tracks = playableTracks();
+  return tracks[state.exportPlayerTrackIndex]?.render_url || state.previewUrl || "";
+}
+
+function playExportTrack(trackIndex) {
+  const tracks = playableTracks();
+  if (!tracks.length) return;
+  const nextIndex = clampTrackIndex(trackIndex, tracks.length);
+  state.exportPlayerTrackIndex = nextIndex;
+  const audio = exportAudioElement();
+  const nextUrl = usingMergedExportAudio()
+    ? state.exportFile?.url || ""
+    : tracks[nextIndex]?.render_url || state.previewUrl || "";
+  if (!audio || !nextUrl) return;
+  if (audio.getAttribute("src") !== nextUrl) {
+    audio.setAttribute("src", nextUrl);
+    audio.load();
+  }
+  const startSeconds = usingMergedExportAudio() ? exportTrackStartSeconds(nextIndex) : 0;
+  const playWhenReady = () => {
+    audio.currentTime = startSeconds;
+    void audio.play();
+    audio.removeEventListener("loadedmetadata", playWhenReady);
+    syncExportControls();
+  };
+  if (audio.readyState < 1) {
+    audio.addEventListener("loadedmetadata", playWhenReady);
+  } else {
+    audio.currentTime = startSeconds;
+    void audio.play();
+  }
+  syncExportControls();
+}
+
+function syncExportControls() {
+  const audio = exportAudioElement();
+  const playButton = document.querySelector("[data-export-play]");
+  if (playButton) {
+    playButton.textContent = audio && !audio.paused ? "❚❚" : "▶";
+  }
+  const fill = document.querySelector("[data-export-scrub-fill]");
+  const head = document.querySelector("[data-export-scrub-head]");
+  const elapsed = document.querySelector("[data-export-elapsed]");
+  const remaining = document.querySelector("[data-export-remaining]");
+  if (!audio || !fill || !head || !elapsed || !remaining) return;
+
+  const percent = audio.duration ? (audio.currentTime / audio.duration) * 100 : 0;
+  fill.style.width = `${percent}%`;
+  head.style.left = `${percent}%`;
+  elapsed.textContent = `${formatStamp(audio.currentTime)} elapsed`;
+  remaining.textContent = audio.duration
+    ? `−${formatStamp(Math.max(0, audio.duration - audio.currentTime))}`
+    : "−0:00:00";
+
+  if (usingMergedExportAudio()) {
+    const trackIndex = currentTrackIndexForTime(audio.currentTime);
+    if (trackIndex !== state.exportPlayerTrackIndex) {
+      state.exportPlayerTrackIndex = trackIndex;
+    }
+  }
+}
+
+function currentTrackIndexForTime(seconds) {
+  const tracks = playableTracks();
+  let elapsed = 0;
+  for (let index = 0; index < tracks.length; index += 1) {
+    elapsed += Number(tracks[index].duration_seconds || tracks[index].est_minutes * 60 || 0);
+    if (seconds < elapsed) return index;
+  }
+  return clampTrackIndex(tracks.length - 1, Math.max(1, tracks.length));
+}
+
+function exportFilename() {
+  const file = state.exportFile?.file || "";
+  if (file) {
+    const pieces = String(file).split("/");
+    return pieces[pieces.length - 1];
+  }
+  const base = slugify(state.book?.title || "scriptorium-audiobook");
+  return `${base}.${state.exportFormat}`;
+}
+
+function downloadCurrentExport() {
+  if (!state.exportFile?.url) return;
+  const link = document.createElement("a");
+  link.href = state.exportFile.url;
+  link.download = exportFilename();
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+}
+
 function canStartRender() {
   if (!state.book) return false;
   if (!selectedChapterIds().length) return false;
+  if (state.model !== "omnivoice") return true;
   if (state.voiceMode === "clone" && (!state.cloneSampleFile || !state.cloneConsent)) return false;
   if (state.voiceMode === "design" && !buildDesignPrompt()) return false;
   return true;
@@ -1040,6 +1362,9 @@ function buildDesignPrompt() {
 }
 
 function activeNarratorName() {
+  if (state.model === "magpie") {
+    return `${state.magpieSpeaker} (${activeLanguageLabel()})`;
+  }
   const narrator = NARRATORS.find((item) => item.id === state.narratorId);
   return narrator?.name || "Custom narrator";
 }
@@ -1050,9 +1375,58 @@ function chapterTitle(chapterId) {
 }
 
 function syncNarratorMetadata() {
+  if (state.model === "magpie") {
+    state.exportMetadata.narrator = `${activeNarratorName()} (Magpie TTS)`;
+    return;
+  }
+  if (state.voiceMode === "clone") {
+    state.exportMetadata.narrator = "Cloned Narrator (OmniVoice)";
+    return;
+  }
+  if (state.voiceMode === "design") {
+    state.exportMetadata.narrator = "Designed Narrator (OmniVoice)";
+    return;
+  }
   state.exportMetadata.narrator = `${activeNarratorName()} (OmniVoice)`;
 }
 
+function activeModel() {
+  return SYNTHESIS_MODELS.find((item) => item.id === state.model) || SYNTHESIS_MODELS[0];
+}
+
+function activeModelName() {
+  return activeModel()?.name || "Speech model";
+}
+
+function activeModelDescription() {
+  return activeModel()?.desc || "";
+}
+
+function activeBackend() {
+  return SYNTHESIS_BACKENDS.find((item) => item.id === state.backendSelection) || SYNTHESIS_BACKENDS[0];
+}
+
+function activeBackendDescription() {
+  return activeBackend()?.desc || "";
+}
+
+function activeLanguageLabel() {
+  const language = MAGPIE_OPTIONS.languages.find((item) => item.value === state.magpieLanguage);
+  return language?.label || state.magpieLanguage;
+}
+
+function currentRenderStackLabel() {
+  const modelName =
+    (SYNTHESIS_MODELS.find((item) => item.id === state.activeRenderModel)?.name || activeModelName());
+  const backendName =
+    (SYNTHESIS_BACKENDS.find((item) => item.id === state.activeRenderBackend)?.name || activeBackend()?.name || "HF/local");
+  return `${modelName} · ${backendName}`;
+}
+
+function renderSupportsPause() {
+  return state.activeRenderBackend !== "modal";
+}
+
 function excerpt(text, length, start = 0) {
   if (!text) return "";
   return text.slice(start, start + length).trim();
@@ -1070,6 +1444,13 @@ function humanBytes(size) {
   return `${value.toFixed(index ? 1 : 0)} ${units[index]}`;
 }
 
+function slugify(value) {
+  return String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "scriptorium-audiobook";
+}
+
 function escapeHtml(value) {
   return String(value)
     .replaceAll("&", "&amp;")

modal_app.py

@@ -0,0 +1,267 @@
+import base64
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List
+from uuid import uuid4
+
+import fastapi
+import modal
+from fastapi import Header, HTTPException
+from fastapi.responses import Response
+
+from backend.magpie_adapter import MagpieAdapter
+from backend.omnivoice_adapter import OmniVoiceAdapter
+from backend.synthesis_catalog import MODAL_BACKEND
+from backend.types import VoiceConfig
+
+
+app = modal.App("scriptorium-tts")
+image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "fastapi[standard]",
+        "numpy>=1.26.0",
+        "soundfile>=0.13.0",
+        "torch>=2.8.0",
+        "torchaudio>=2.8.0",
+        "omnivoice>=0.1.5",
+        "requests>=2.32.0",
+        "huggingface_hub>=0.33.0",
+        "nemo-toolkit[tts]",
+        "kaldialign",
+    )
+)
+jobs = modal.Dict.from_name("scriptorium-modal-jobs", create_if_missing=True)
+artifacts = modal.Dict.from_name("scriptorium-modal-artifacts", create_if_missing=True)
+web_app = fastapi.FastAPI()
+
+
+def _check_auth(header: str | None) -> None:
+    expected = os.getenv("SCRIPTORIUM_MODAL_SHARED_SECRET", "").strip()
+    if not expected:
+        return
+    token = (header or "").removeprefix("Bearer ").strip()
+    if token != expected:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+
+
+def _adapter_for(model: str):
+    if model == "magpie":
+        return MagpieAdapter()
+    return OmniVoiceAdapter()
+
+
+def _voice_config(payload: Dict[str, Any], temp_dir: Path) -> VoiceConfig:
+    data = dict(payload)
+    sample_b64 = data.pop("sample_b64", None)
+    voice = VoiceConfig.from_dict(data)
+    if sample_b64:
+        sample_path = temp_dir / "clone-sample.wav"
+        sample_path.write_bytes(base64.b64decode(sample_b64))
+        voice.sample_path = str(sample_path)
+    return voice
+
+
+@app.function(image=image, gpu="any", timeout=900)
+def render_preview(payload: Dict[str, Any]) -> Dict[str, Any]:
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dir = Path(tmp)
+        output_path = temp_dir / "preview.wav"
+        voice = _voice_config(payload["voice_config"], temp_dir)
+        result = _adapter_for(voice.model).synthesize(
+            text=str(payload["text"]),
+            output_path=output_path,
+            voice_config=voice,
+            diffusion_steps=int(payload.get("diffusion_steps", 32)),
+            speed=float(payload.get("speed", 1.0)),
+        )
+        return {
+            "audio_base64": base64.b64encode(output_path.read_bytes()).decode("ascii"),
+            "duration_seconds": result.get("duration_seconds", 0),
+            "sample_rate": result.get("sample_rate", 24000),
+            "backend": MODAL_BACKEND,
+            "model": voice.model,
+        }
+
+
+def _job_state(job_id: str) -> Dict[str, Any]:
+    return dict(
+        jobs.get(
+            job_id,
+            {
+                "status": "pending",
+                "events": [],
+                "cancel_requested": False,
+            },
+        )
+    )
+
+
+def _save_job_state(job_id: str, state: Dict[str, Any]) -> None:
+    jobs[job_id] = state
+
+
+def _append_event(job_id: str, event: Dict[str, Any]) -> None:
+    state = _job_state(job_id)
+    state.setdefault("events", []).append(event)
+    state["status"] = event.get("type", state.get("status", "running"))
+    _save_job_state(job_id, state)
+
+
+@app.function(image=image, gpu="any", timeout=60 * 60)
+def render_book(job_id: str, payload: Dict[str, Any]) -> None:
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dir = Path(tmp)
+        voice = _voice_config(payload["voice_config"], temp_dir)
+        chapters = [chapter for chapter in payload["chapters"] if chapter.get("included", True)]
+        state = _job_state(job_id)
+        state["status"] = "running"
+        _save_job_state(job_id, state)
+        _append_event(
+            job_id,
+            {
+                "type": "started",
+                "session_id": payload["session_id"],
+                "total_chapters": len(chapters),
+                "book_title": payload["book"].get("title"),
+                "backend": MODAL_BACKEND,
+                "model": voice.model,
+            },
+        )
+
+        adapter = _adapter_for(voice.model)
+        outputs: List[str] = []
+        for index, chapter in enumerate(chapters):
+            state = _job_state(job_id)
+            if state.get("cancel_requested"):
+                _append_event(
+                    job_id,
+                    {
+                        "type": "cancelled",
+                        "session_id": payload["session_id"],
+                        "backend": MODAL_BACKEND,
+                        "model": voice.model,
+                    },
+                )
+                return
+
+            chapter_id = str(chapter["id"])
+            _append_event(
+                job_id,
+                {
+                    "type": "chapter_started",
+                    "session_id": payload["session_id"],
+                    "chapter_id": chapter_id,
+                    "chapter_title": chapter["title"],
+                    "chapter_index": index,
+                    "overall_progress": index / max(1, len(chapters)),
+                    "backend": MODAL_BACKEND,
+                    "model": voice.model,
+                },
+            )
+            output_path = temp_dir / f"{index + 1:03d}-{chapter_id}.wav"
+            result = adapter.synthesize(
+                text=str(chapter["text"]),
+                output_path=output_path,
+                voice_config=voice,
+                diffusion_steps=int(payload.get("diffusion_steps", 32)),
+                speed=float(payload.get("speed", 1.0)),
+            )
+            filename = output_path.name
+            artifacts[f"{job_id}:{filename}"] = output_path.read_bytes()
+            outputs.append(filename)
+            _append_event(
+                job_id,
+                {
+                    "type": "chapter_done",
+                    "session_id": payload["session_id"],
+                    "chapter_id": chapter_id,
+                    "duration_seconds": int(result.get("duration_seconds", 0)),
+                    "overall_progress": (index + 1) / max(1, len(chapters)),
+                    "filename": filename,
+                    "artifact_url": f"/artifacts/{job_id}/{filename}",
+                    "backend": MODAL_BACKEND,
+                    "model": voice.model,
+                },
+            )
+
+        _append_event(
+            job_id,
+            {
+                "type": "completed",
+                "session_id": payload["session_id"],
+                "outputs": outputs,
+                "backend": MODAL_BACKEND,
+                "model": voice.model,
+            },
+        )
+
+
+@web_app.post("/preview")
+def preview_endpoint(
+    payload: Dict[str, Any],
+    authorization: str | None = Header(default=None),
+) -> Dict[str, Any]:
+    _check_auth(authorization)
+    return render_preview.remote(payload)
+
+
+@web_app.post("/renders")
+def submit_render_endpoint(
+    payload: Dict[str, Any],
+    authorization: str | None = Header(default=None),
+) -> Dict[str, str]:
+    _check_auth(authorization)
+    job_id = str(uuid4())
+    _save_job_state(job_id, {"status": "pending", "events": [], "cancel_requested": False})
+    render_book.spawn(job_id, payload)
+    return {"job_id": job_id}
+
+
+@web_app.get("/renders/{job_id}")
+def render_status_endpoint(
+    job_id: str,
+    cursor: int = 0,
+    authorization: str | None = Header(default=None),
+) -> Dict[str, Any]:
+    _check_auth(authorization)
+    state = _job_state(job_id)
+    events = list(state.get("events", []))
+    return {
+        "job_id": job_id,
+        "status": state.get("status", "pending"),
+        "events": events[cursor:],
+    }
+
+
+@web_app.post("/renders/{job_id}/cancel")
+def cancel_render_endpoint(
+    job_id: str,
+    authorization: str | None = Header(default=None),
+) -> Dict[str, str]:
+    _check_auth(authorization)
+    state = _job_state(job_id)
+    state["cancel_requested"] = True
+    state["status"] = "cancelled"
+    _save_job_state(job_id, state)
+    return {"type": "cancelled", "job_id": job_id}
+
+
+@web_app.get("/artifacts/{job_id}/{filename}")
+def artifact_endpoint(
+    job_id: str,
+    filename: str,
+    authorization: str | None = Header(default=None),
+):
+    _check_auth(authorization)
+    content = artifacts.get(f"{job_id}:{filename}")
+    if content is None:
+        raise HTTPException(status_code=404, detail="Artifact not found")
+    return Response(content=content, media_type="audio/wav")
+
+
+@app.function(image=image)
+@modal.asgi_app()
+def fastapi_app():
+    return web_app

requirements.txt

@@ -8,3 +8,5 @@ numpy>=1.26.0
 torch>=2.8.0
 torchaudio>=2.8.0
 omnivoice>=0.1.5
+requests>=2.32.0
+huggingface_hub>=0.33.0

tests/test_frontend_export_controls.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+
+def test_export_screen_wires_track_and_transport_actions() -> None:
+    source = Path("frontend/app.js").read_text(encoding="utf-8")
+
+    assert 'data-action="playRenderedChapter"' in source
+    assert 'data-action="exportJumpToTrack"' in source
+    assert 'data-action="exportSeek"' in source
+    assert "playRenderedChapter(target)" in source
+    assert "exportJumpToTrack(target)" in source
+    assert "exportSeek(target)" in source
+
+
+def test_export_screen_uses_downloadable_export_links() -> None:
+    source = Path("frontend/app.js").read_text(encoding="utf-8")
+
+    assert "downloadCurrentExport()" in source
+    assert 'download="${escapeAttr(exportFilename())}"' in source

tests/test_omnivoice_adapter.py

@@ -0,0 +1,68 @@
+from pathlib import Path
+
+import numpy as np
+
+from backend.omnivoice_adapter import OmniVoiceAdapter
+from backend.types import VoiceConfig
+
+
+class FakeModel:
+    def __init__(self) -> None:
+        self.generate_calls = []
+        self.clone_prompt_calls = []
+
+    def create_voice_clone_prompt(self, *, ref_audio, ref_text=None):
+        self.clone_prompt_calls.append({"ref_audio": ref_audio, "ref_text": ref_text})
+        return {"prompt": "cached"}
+
+    def generate(self, **kwargs):
+        self.generate_calls.append(kwargs)
+        return [np.zeros(24000, dtype=np.float32)]
+
+
+def test_omnivoice_adapter_uses_stable_generation_config_for_designed_voice(tmp_path: Path) -> None:
+    adapter = OmniVoiceAdapter()
+    fake_model = FakeModel()
+    adapter._model = fake_model
+    adapter._backend = "omnivoice"
+
+    adapter.synthesize(
+        text="Chapter one text.",
+        output_path=tmp_path / "chapter.wav",
+        voice_config=VoiceConfig(mode="design", design_prompt="male, elderly, low pitch, british accent"),
+        diffusion_steps=32,
+        speed=1.0,
+    )
+
+    generation_config = fake_model.generate_calls[0]["generation_config"]
+    assert generation_config.position_temperature == 0.0
+    assert generation_config.class_temperature == 0.0
+
+
+def test_omnivoice_adapter_reuses_cached_clone_prompt_across_chapters(tmp_path: Path) -> None:
+    adapter = OmniVoiceAdapter()
+    fake_model = FakeModel()
+    adapter._model = fake_model
+    adapter._backend = "omnivoice"
+    voice = VoiceConfig(mode="clone", sample_path="/tmp/sample.wav", reference_text="Reference speech")
+
+    adapter.synthesize(
+        text="Chapter one text.",
+        output_path=tmp_path / "chapter-1.wav",
+        voice_config=voice,
+        diffusion_steps=32,
+        speed=1.0,
+    )
+    adapter.synthesize(
+        text="Chapter two text.",
+        output_path=tmp_path / "chapter-2.wav",
+        voice_config=voice,
+        diffusion_steps=32,
+        speed=1.0,
+    )
+
+    assert len(fake_model.clone_prompt_calls) == 1
+    assert fake_model.generate_calls[0]["voice_clone_prompt"] == {"prompt": "cached"}
+    assert fake_model.generate_calls[1]["voice_clone_prompt"] == {"prompt": "cached"}
+    assert "ref_audio" not in fake_model.generate_calls[0]
+    assert "ref_audio" not in fake_model.generate_calls[1]

tests/test_render_api.py

@@ -22,7 +22,7 @@ def test_start_render_api_adds_public_audio_url_to_completed_chapters(monkeypatc
     sys.modules.pop("app", None)
     module = importlib.import_module("app")
 
-    class FakePipeline:
+    class FakeSynthesisService:
         def get_job(self, session_id):
             return SimpleNamespace(status="idle")
 
@@ -34,14 +34,18 @@ def test_start_render_api_adds_public_audio_url_to_completed_chapters(monkeypatc
                 "duration_seconds": 12,
                 "overall_progress": 0.5,
                 "output_path": "/tmp/scriptorium/session-a/renders/001-c1.wav",
+                "backend": "modal",
+                "model": "magpie",
             }
             yield {
                 "type": "completed",
                 "session_id": kwargs["session_id"],
                 "outputs": ["/tmp/scriptorium/session-a/renders/001-c1.wav"],
+                "backend": "modal",
+                "model": "magpie",
             }
 
-    monkeypatch.setattr(module, "pipeline", FakePipeline())
+    monkeypatch.setattr(module, "synthesis_service", FakeSynthesisService())
     monkeypatch.setattr(module, "_selected_book", lambda session_id, selected_ids: {"chapters": [{"id": "c1", "included": True}]})
     monkeypatch.setattr(module, "_voice_config_for_backend", lambda voice_config, session_id: voice_config)
     monkeypatch.setattr(module.store, "save_json", lambda *args, **kwargs: None)
@@ -59,3 +63,42 @@ def test_start_render_api_adds_public_audio_url_to_completed_chapters(monkeypatc
     chapter_done = events[0]
     assert chapter_done["type"] == "chapter_done"
     assert chapter_done["url"] == "/files/session-a/renders/001-c1.wav"
+    assert chapter_done["backend"] == "modal"
+    assert chapter_done["model"] == "magpie"
+
+
+def test_generate_preview_api_exposes_model_and_backend(monkeypatch) -> None:
+    sys.modules.pop("app", None)
+    module = importlib.import_module("app")
+
+    class FakeSynthesisService:
+        def generate_preview(self, **kwargs):
+            output_path = kwargs["output_path"]
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_bytes(b"RIFFpreview")
+            return {
+                "duration_seconds": 6,
+                "sample_rate": 24000,
+                "backend": "modal",
+                "model": "magpie",
+            }
+
+    monkeypatch.setattr(module, "synthesis_service", FakeSynthesisService())
+    monkeypatch.setattr(
+        module,
+        "_book_payload",
+        lambda _session_id: {"chapters": [{"id": "c1", "text": "hello world", "title": "One"}]},
+    )
+    monkeypatch.setattr(module, "_voice_config_for_backend", lambda voice_config, session_id: voice_config)
+
+    payload = module.generate_preview_api(
+        session_id="session-a",
+        chapter_id="c1",
+        voice_config={"model": "magpie", "backend": "modal", "speaker": "Sofia", "language": "en"},
+        diffusion_steps=32,
+        speed=1.0,
+    )
+
+    assert payload["url"] == "/files/session-a/previews/c1.wav"
+    assert payload["backend"] == "modal"
+    assert payload["model"] == "magpie"

tests/test_render_pipeline.py

@@ -10,7 +10,12 @@ class FakeSynthesizer:
     def synthesize(self, *, text: str, output_path: Path, **kwargs) -> dict:
         self.calls.append({"text": text, "output_path": output_path, **kwargs})
         output_path.write_bytes(b"RIFFfakewave")
-        return {"duration_seconds": max(1, len(text.split()) // 2), "sample_rate": 24000}
+        return {
+            "duration_seconds": max(1, len(text.split()) // 2),
+            "sample_rate": 24000,
+            "backend": "local",
+            "model": kwargs["voice_config"].model,
+        }
 
 
 def _chapters() -> list:
@@ -41,6 +46,8 @@ def test_render_pipeline_streams_ordered_progress_events(tmp_path: Path) -> None
     assert "chapter_done" in event_types
     assert event_types[-1] == "completed"
     assert len(synthesizer.calls) == 2
+    assert all(event["backend"] == "local" for event in events)
+    assert all(event["model"] == "omnivoice" for event in events)
 
 
 def test_render_pipeline_can_be_cancelled(tmp_path: Path) -> None:

tests/test_synthesis_service.py

@@ -0,0 +1,152 @@
+from pathlib import Path
+
+import pytest
+
+from backend.synthesis_service import SynthesisService
+from backend.types import VoiceConfig
+
+
+class FakeSynthesizer:
+    def __init__(self, model: str) -> None:
+        self.model = model
+        self.calls = []
+
+    def synthesize(self, *, text: str, output_path: Path, voice_config: VoiceConfig, **kwargs) -> dict:
+        self.calls.append(
+            {
+                "text": text,
+                "output_path": output_path,
+                "voice_config": voice_config,
+                **kwargs,
+            }
+        )
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_bytes(b"RIFFfakewave")
+        return {
+            "duration_seconds": 4,
+            "sample_rate": 24000,
+            "backend": "local",
+            "model": self.model,
+        }
+
+
+class FakeModalClient:
+    def __init__(self) -> None:
+        self.preview_calls = []
+        self.submit_calls = []
+        self.render_calls = []
+        self.cancelled = []
+
+    def generate_preview(self, **kwargs) -> dict:
+        self.preview_calls.append(kwargs)
+        output_path = kwargs["output_path"]
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_bytes(b"RIFFmodalpreview")
+        return {
+            "duration_seconds": 5,
+            "sample_rate": 24000,
+            "backend": "modal",
+            "model": kwargs["voice_config"].model,
+        }
+
+    def submit_render(self, **kwargs) -> str:
+        self.submit_calls.append(kwargs)
+        return "job-123"
+
+    def render(self, **kwargs):
+        self.render_calls.append(kwargs)
+        output_path = kwargs["render_dir"] / "001-c1.wav"
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_bytes(b"RIFFmodalrender")
+        yield {
+            "type": "started",
+            "session_id": kwargs["session_id"],
+            "total_chapters": 1,
+            "book_title": "Book",
+            "backend": "modal",
+            "model": kwargs["voice_config"].model,
+        }
+        yield {
+            "type": "chapter_done",
+            "session_id": kwargs["session_id"],
+            "chapter_id": "c1",
+            "duration_seconds": 7,
+            "overall_progress": 1.0,
+            "output_path": str(output_path),
+            "backend": "modal",
+            "model": kwargs["voice_config"].model,
+        }
+        yield {
+            "type": "completed",
+            "session_id": kwargs["session_id"],
+            "outputs": [str(output_path)],
+            "backend": "modal",
+            "model": kwargs["voice_config"].model,
+        }
+
+    def cancel(self, session_id: str) -> dict:
+        self.cancelled.append(session_id)
+        return {"type": "cancelled", "session_id": session_id, "backend": "modal"}
+
+
+def test_preview_routes_to_model_specific_local_adapter(tmp_path: Path) -> None:
+    omnivoice = FakeSynthesizer("omnivoice")
+    magpie = FakeSynthesizer("magpie")
+    service = SynthesisService(
+        session_root=tmp_path,
+        local_synthesizers={"omnivoice": omnivoice, "magpie": magpie},
+        modal_client=FakeModalClient(),
+    )
+
+    result = service.generate_preview(
+        text="Hello from Magpie.",
+        output_path=tmp_path / "previews" / "preview.wav",
+        voice_config=VoiceConfig(model="magpie", backend="local", speaker="Sofia", language="en"),
+        diffusion_steps=32,
+        speed=1.0,
+    )
+
+    assert result["backend"] == "local"
+    assert result["model"] == "magpie"
+    assert len(magpie.calls) == 1
+    assert magpie.calls[0]["voice_config"].speaker == "Sofia"
+    assert not omnivoice.calls
+
+
+def test_render_routes_modal_jobs_and_preserves_event_shape(tmp_path: Path) -> None:
+    service = SynthesisService(
+        session_root=tmp_path,
+        local_synthesizers={"omnivoice": FakeSynthesizer("omnivoice"), "magpie": FakeSynthesizer("magpie")},
+        modal_client=FakeModalClient(),
+    )
+
+    events = list(
+        service.render(
+            session_id="session-a",
+            book={"title": "Book"},
+            chapters=[{"id": "c1", "title": "One", "text": "hello world", "included": True}],
+            voice_config={"model": "magpie", "backend": "modal", "speaker": "Sofia", "language": "en"},
+            diffusion_steps=32,
+            speed=1.0,
+        )
+    )
+
+    assert [event["type"] for event in events] == ["started", "chapter_done", "completed"]
+    assert all(event["backend"] == "modal" for event in events)
+    assert all(event["model"] == "magpie" for event in events)
+    assert Path(events[1]["output_path"]).exists()
+
+
+def test_pause_and_resume_are_rejected_for_modal_jobs(tmp_path: Path) -> None:
+    service = SynthesisService(
+        session_root=tmp_path,
+        local_synthesizers={"omnivoice": FakeSynthesizer("omnivoice"), "magpie": FakeSynthesizer("magpie")},
+        modal_client=FakeModalClient(),
+    )
+    service._active_backends["session-a"] = "modal"
+
+    with pytest.raises(ValueError, match="Pause is only supported for local renders"):
+        service.pause("session-a")
+
+    with pytest.raises(ValueError, match="Resume is only supported for local renders"):
+        service.resume("session-a")

tests/test_types.py

@@ -0,0 +1,21 @@
+from backend.types import VoiceConfig
+
+
+def test_voice_config_from_dict_parses_model_backend_and_magpie_fields() -> None:
+    voice = VoiceConfig.from_dict(
+        {
+            "model": "magpie",
+            "backend": "modal",
+            "mode": "auto",
+            "speaker": "Sofia",
+            "language": "en",
+            "applyTextNormalization": True,
+        }
+    )
+
+    assert voice.model == "magpie"
+    assert voice.backend == "modal"
+    assert voice.mode == "auto"
+    assert voice.speaker == "Sofia"
+    assert voice.language == "en"
+    assert voice.apply_text_normalization is True

tests/test_voice_presets.py

@@ -60,6 +60,8 @@ def test_homepage_injects_voice_presets_for_frontend() -> None:
 
     assert "window.__VOICE_PRESETS__" in html
     assert "window.__VOICE_DESIGN_OPTIONS__" in html
+    assert "window.__MAGPIE_OPTIONS__" in html
+    assert "window.__SYNTHESIS_BACKENDS__" in html
 
 
 def test_voice_design_options_use_only_supported_omnivoice_design_tokens() -> None: