Add MOSS-TTS-Nano 2nd backend (rs.cpp + codec.cpp, ORT-free) with voice clone

Second TTS engine alongside the MB-iSTFT-VITS: MOSS-TTS-Nano-100M autoregressive
LLM-TTS, fully ggml (no onnxruntime). Pipeline: SentencePiece tokenizer +
manifest-driven prompt + rs.cpp moss-gen (AR, 16 codebooks) + codec.cpp
(moss_audio codec) -> 48kHz. User can upload a reference clip to clone its voice.

- moss_backend.py: self-contained streaming backend (graceful-degrades to VITS-only)
- server.py: /has_moss, /moss_ref (ref upload), /moss_ws (48kHz stream); startup
asset download (gguf + tokenizer + manifest + hans00 codec gguf)
- static/index.html: engine selector + ref-audio upload + dynamic playback SR
- Dockerfile: builds moss-gen + codec-cli (shared ggml, CPU) in-image
- requirements: sentencepiece, librosa, gguf

RTF ~0.7 on 2 vCPU = real-time on the free CPU tier.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Dockerfile

@@ -1,13 +1,30 @@
-# PrimeTTS real-time streaming demo — FastAPI + WebSocket + Web Audio (ONNX, torch-free).
+# PrimeTTS real-time streaming demo — FastAPI + WebSocket + Web Audio (torch-free).
+# Two TTS backends: MB-iSTFT-VITS (ONNX phoneme) + MOSS-TTS-Nano (rs.cpp+codec.cpp, ggml).
 FROM python:3.10-slim
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y --no-install-recommends \
-      ca-certificates libgomp1 && rm -rf /var/lib/apt/lists/*
+      ca-certificates libgomp1 build-essential cmake git && rm -rf /var/lib/apt/lists/*
+
+# ---- MOSS ggml binaries: codec-cli (codec.cpp) + moss-gen (fork tool), sharing one ggml ----
+RUN git clone --recursive --depth 1 https://github.com/mybigday/codec.cpp /tmp/cc && \
+    cd /tmp/cc && cmake -B build -DGGML_CUDA=OFF -DCMAKE_BUILD_TYPE=Release && \
+    cmake --build build --target codec-cli -j"$(nproc)" && \
+    mkdir -p /app/bin && cp build/codec-cli /app/bin/ && \
+    (cp build/libcodec.so /app/bin/ 2>/dev/null || true) && \
+    find build -name 'libggml*.so' -exec cp {} /app/bin/ \;
+# moss-gen: compile the fork's standalone tool against codec.cpp's ggml (no rapidspeech-core)
+RUN git clone --depth 1 -b jetson-nano-gen1 https://github.com/vieenrose/RapidSpeech.cpp /tmp/rs && \
+    g++ -O3 -std=c++17 -I /tmp/cc/ggml/include /tmp/rs/tools/moss_gen.cpp -o /app/bin/moss-gen \
+        -L /app/bin -lggml -lggml-base -lggml-cpu && \
+    rm -rf /tmp/cc /tmp/rs
+
 COPY requirements.txt /app/requirements.txt
 RUN pip install --no-cache-dir -r /app/requirements.txt
 RUN useradd -m -u 1000 user
 ENV HOME=/home/user HF_HOME=/home/user/.cache/huggingface \
-    G2PW_CACHE=/home/user/.cache/g2pw NUMBA_CACHE_DIR=/tmp/numba
+    G2PW_CACHE=/home/user/.cache/g2pw NUMBA_CACHE_DIR=/tmp/numba \
+    LD_LIBRARY_PATH=/app/bin MOSS_GEN=/app/bin/moss-gen MOSS_CODEC_CLI=/app/bin/codec-cli \
+    MOSS_DIR=/home/user/moss MOSS_THREADS=2
 WORKDIR /app
 COPY . /app
 RUN cd /app && python -c "from g2pw_min.api import download_model; download_model('G2PWModel')" && \

MOSS_DEPLOY.md

@@ -0,0 +1,68 @@
+# Deploying the MOSS-TTS-Nano 2nd backend to the Space
+
+The MOSS backend adds a text→codec autoregressive TTS (rs.cpp CPU, 48 kHz, voice
+clone) alongside the phoneme VITS. It **graceful-degrades**: if any asset is
+missing, `MOSS.available = False` and the demo serves VITS only — so this is
+safe to ship incrementally.
+
+## 1. Binary — build in-Space (glibc safety)
+The dev-box binary is glibc 2.39; HF Spaces are older. **Build `moss-gen` in the
+Space's own image** (Docker Space) so glibc matches. `Dockerfile`:
+
+```dockerfile
+FROM python:3.11-slim
+RUN apt-get update && apt-get install -y build-essential cmake git && rm -rf /var/lib/apt/lists/*
+# build moss-gen + ggml (CPU) from the fork
+RUN git clone --depth 1 -b jetson-nano-gen1 https://github.com/vieenrose/RapidSpeech.cpp /tmp/rs && \
+    cd /tmp/rs && cmake -B build -DGGML_CUDA=OFF -DCMAKE_BUILD_TYPE=Release && \
+    cmake --build build --target moss-gen -j && \
+    mkdir -p /app/bin && cp build/moss-gen /app/bin/ && cp build/ggml/src/libggml*.so /app/bin/
+# codec.cpp (ggml codec-cli) — replaces the codec ONNX (ORT-free)
+RUN git clone --recursive --depth 1 https://github.com/mybigday/codec.cpp /tmp/cc && \
+    cd /tmp/cc && cmake -B build -DGGML_CUDA=OFF -DCMAKE_BUILD_TYPE=Release && \
+    cmake --build build --target codec-cli -j && cp build/codec-cli /app/bin/ && cp build/libcodec.so /app/bin/ 2>/dev/null || true
+ENV LD_LIBRARY_PATH=/app/bin
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+ENV MOSS_GEN=/app/bin/moss-gen
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]
+```
+
+(If the fork target `moss-gen` isn't in the default CMake, it is guarded by the
+same `tools/` block as the other moss tools — ensure `-DRS_BUILD_TOOLS=ON` or the
+equivalent, or compile `tools/moss_gen.cpp` standalone against the built libs.)
+
+## 2. Assets — host in an HF model repo, download at startup
+Per repo policy, weights live in a **model repo**, not the Space. Already hosted:
+`Luigi/MOSS-TTS-Nano-100M-GGUF` → `moss_nano_full.gguf`. Also needed (add to that
+repo or a `*-demo-assets` repo):
+- codec gguf: `hans00/MOSS-TTS-Nano-GGUF` `codec-q8_0.gguf` (used by codec.cpp — no ONNX)
+- MOSS **tokenizer**: `tokenizer.model`, `tokenization_moss_tts_nano.py`, `config.json`,
+  `special_tokens_map.json`, `tokenizer_config.json`
+- (embedding tables are **derived from the gguf at startup** — no hosting needed)
+
+`server.py` downloads them at startup into `MOSS_DIR` (mirror the existing
+`hf_hub_download` pattern used for the VITS/LLM weights).
+
+## 3. Support files
+None — `moss_backend.py` is self-contained (SentencePiece tokenizer + manifest-driven
+prompt build + `moss-gen` + `codec-cli`). No `NanoRuntime` / `ort_cpu_runtime` / ONNX.
+
+## 4. requirements.txt — add
+```
+sentencepiece
+soundfile
+librosa
+gguf
+```
+
+## 5. Verify before pushing
+```
+MOSS_DIR=... MOSS_GEN=.../moss-gen python -c "import server"   # MOSS ready?
+```
+Check `[moss] backend ready` in logs, then exercise `/has_moss`, `/moss_ref`
+(upload a clip), `/moss_ws` (stream). RTF ~0.72 on 2 vCPU = real-time.
+```
+```

moss_backend.py

@@ -0,0 +1,136 @@
+"""MOSS-TTS-Nano-100M streaming backend — fully rs.cpp/ggml (ORT-free).
+
+Pipeline (no onnxruntime anywhere):
+  tokenizer : SentencePiece (tokenizer.model)
+  prompt    : build_voice_clone_request_rows (replicated from the manifest config)
+  AR gen    : RapidSpeech.cpp `moss-gen` (ggml) — text+ref -> 16-codebook frames
+  codec     : codec.cpp `codec-cli` (ggml, moss_audio gguf) — ref encode + frame decode
+
+Assets (model repo): moss_nano_full.gguf (AR), codec gguf, tokenizer.model,
+browser_poc_manifest.json. Graceful: `available=False` if a binary/asset is missing.
+"""
+import os, json, subprocess, tempfile, threading
+import numpy as np
+
+SR_OUT = 48000
+
+class MossBackend:
+    def __init__(self, moss_dir, gguf, moss_gen, codec_cli, codec_gguf,
+                 chunk_ms=240, threads=2):
+        self.available = False
+        self._lock = threading.Lock()
+        self.ref_codes = {}                       # session -> [T,16] frame-major ref codes
+        self.chunk_bytes = int(SR_OUT * chunk_ms / 1000) * 2
+        try:
+            import sentencepiece as spm
+            self.moss_dir = os.path.abspath(moss_dir)
+            self.gguf = gguf if os.path.isabs(gguf) else os.path.join(self.moss_dir, gguf)
+            self.moss_gen, self.codec_cli, self.codec_gguf = moss_gen, codec_cli, codec_gguf
+            self.threads = threads
+            self.man = json.load(open(os.path.join(self.moss_dir, "browser_poc_manifest.json")))
+            self.tc = self.man["tts_config"]; self.pt = self.man["prompt_templates"]
+            self.NVQ = int(self.tc["n_vq"]); self.PAD = int(self.tc["audio_pad_token_id"])
+            self.sp = spm.SentencePieceProcessor(model_file=os.path.join(self.moss_dir, "tokenizer.model"))
+            self.H = 768
+            self.TOK, self.AUD = self._embed_tables()
+            for p in (self.moss_gen, self.codec_cli, self.codec_gguf):
+                if not os.path.exists(p): raise FileNotFoundError(p)
+            self.available = True
+            print("[moss] backend ready (rs.cpp+codec.cpp, ORT-free, 48kHz AR-TTS + clone)")
+        except Exception as e:
+            print(f"[moss] backend unavailable ({e}); VITS-only")
+
+    def _embed_tables(self):
+        tb = os.path.join(self.moss_dir, "gg_tok_embd.bin"); ab = os.path.join(self.moss_dir, "gg_audio_embd.bin")
+        if os.path.exists(tb) and os.path.exists(ab):
+            return (np.fromfile(tb, np.float32).reshape(-1, self.H),
+                    np.fromfile(ab, np.float32).reshape(16, 1024, self.H))
+        from gguf import GGUFReader, GGMLQuantizationType
+        from gguf.quants import dequantize
+        r = GGUFReader(self.gguf)
+        def T(n):
+            t = next(x for x in r.tensors if x.name == n); a = np.array(t.data)
+            if t.tensor_type != GGMLQuantizationType.F32: a = dequantize(a, t.tensor_type)
+            return a.reshape(t.shape[::-1])
+        return (T("token_embd.weight").astype(np.float32),
+                np.stack([T(f"audio_embd.{k}.weight") for k in range(16)]).astype(np.float32))
+
+    # ---- prompt build (replicated from OrtCpuRuntime, config-driven, no ONNX) ----
+    def _text_rows(self, ids):
+        w = self.NVQ + 1
+        return [[t] + [self.PAD] * self.NVQ for t in ids]  # row[0]=tok, rest pad
+    def _audio_rows(self, codes, slot):
+        rows = []
+        for cr in codes:
+            row = [self.PAD] * (self.NVQ + 1); row[0] = slot
+            for i in range(min(len(cr), self.NVQ)): row[i + 1] = int(cr[i])
+            rows.append(row)
+        return rows
+    def _prompt17(self, ref_codes, text_ids):
+        prefix = [*self.pt["user_prompt_prefix_token_ids"], int(self.tc["audio_start_token_id"])]
+        suffix = [int(self.tc["audio_end_token_id"]), *self.pt["user_prompt_after_reference_token_ids"],
+                  *text_ids, *self.pt["assistant_prompt_prefix_token_ids"], int(self.tc["audio_start_token_id"])]
+        return (self._text_rows(prefix) + self._audio_rows(ref_codes, int(self.tc["audio_user_slot_token_id"]))
+                + self._text_rows(suffix))
+
+    def _prompt_embed(self, p17):
+        L = len(p17); emb = np.zeros((L, self.H), np.float32)
+        for p in range(L):
+            emb[p] = self.TOK[p17[p][0]]
+            for k in range(self.NVQ):
+                c = p17[p][k + 1]
+                if c != self.PAD and c < 1024: emb[p] += self.AUD[k][c]
+        return emb
+
+    def _codec_encode(self, wav_f32_48k):
+        import soundfile as sf
+        st = np.stack([wav_f32_48k, wav_f32_48k], axis=1).astype(np.float32)  # stereo
+        with tempfile.TemporaryDirectory() as td:
+            w = os.path.join(td, "r.wav"); c = os.path.join(td, "c.npy")
+            sf.write(w, st, SR_OUT)
+            subprocess.run([self.codec_cli, "encode", "--model", self.codec_gguf, "--in", w,
+                            "--out", c, "--nq", str(self.NVQ), "--threads", str(self.threads)],
+                           check=True, stdout=subprocess.DEVNULL)
+            return np.load(c)                    # [16, T]
+
+    def _codec_decode(self, frames_N16):
+        import soundfile as sf
+        codes = np.ascontiguousarray(frames_N16.T.astype(np.int32))   # [16, N] C-order
+        with tempfile.TemporaryDirectory() as td:
+            c = os.path.join(td, "c.npy"); w = os.path.join(td, "o.wav")
+            np.save(c, codes)
+            subprocess.run([self.codec_cli, "decode", "--model", self.codec_gguf, "--codes", c,
+                            "--out", w, "--nq", str(self.NVQ), "--threads", str(self.threads)],
+                           check=True, stdout=subprocess.DEVNULL)
+            a, _ = sf.read(w)
+            return (a.mean(1) if getattr(a, "ndim", 1) > 1 else a).astype(np.float32)
+
+    # ---- voice clone ----
+    def set_reference(self, session, wav_f32_48k):
+        codes = self._codec_encode(wav_f32_48k)          # [16,T]
+        self.ref_codes[session] = codes.T.tolist()       # [T,16] frame-major
+        return len(self.ref_codes[session])
+    def clear_reference(self, session):
+        self.ref_codes.pop(session, None)
+
+    # ---- streaming synth (clause granularity: generate -> codec decode -> chunked emit) ----
+    def stream(self, text, emit, session_id=None, seed=7, sample=True, max_frames=400):
+        if not self.available: return
+        with self._lock:
+            ids = self.sp.encode(text)
+            ref = self.ref_codes.get(session_id) or [[self.PAD] * self.NVQ]
+            p17 = self._prompt17(ref, ids); L = len(p17)
+            emb = self._prompt_embed(p17)
+            with tempfile.TemporaryDirectory() as td:
+                pe = os.path.join(td, "pe.bin"); out = os.path.join(td, "fr.bin")
+                emb.astype(np.float32).tofile(pe)
+                subprocess.run([self.moss_gen, self.gguf, str(max_frames), str(seed),
+                                "sample" if sample else "greedy", pe, str(L), out],
+                               check=True, env=dict(os.environ, MOSS_DIR=self.moss_dir),
+                               stdout=subprocess.DEVNULL)
+                frames = np.fromfile(out, np.int32).reshape(-1, 16)
+            if not len(frames): return
+            audio = self._codec_decode(frames)
+            pcm = (np.clip(audio, -1, 1) * 32767).astype("<i2").tobytes()
+            for i in range(0, len(pcm), self.chunk_bytes):        # sub-chunk for smooth playback
+                if emit(pcm[i:i + self.chunk_bytes]) is False: break

requirements.txt

@@ -13,3 +13,6 @@ inflect
 fastapi
 uvicorn[standard]
 llama-cpp-python
+sentencepiece
+librosa
+gguf

server.py

@@ -11,7 +11,7 @@ falls back to the pure-onnxruntime split runner (bit-exact) otherwise.
 import os, json, struct, asyncio
 from pathlib import Path
 
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, UploadFile, File
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 import numpy as np
@@ -111,6 +111,40 @@ def _pcm16(x):
 
 BACKEND = Backend()
 
+# ---- 2nd backend: MOSS-TTS-Nano-100M (rs.cpp CPU, 48kHz AR-TTS + voice clone) ----
+# Assets (gguf + codec ONNX + tokenizer) live in the model repo, downloaded at startup.
+MOSS_DIR = os.environ.get("MOSS_DIR", str(HERE / "moss"))
+def _fetch_moss_assets():
+    if os.environ.get("MOSS_GEN") is None and not (HERE / "bin" / "moss-gen").exists():
+        return False   # no binary -> skip download, backend will report unavailable
+    try:
+        from huggingface_hub import snapshot_download
+        snapshot_download(os.environ.get("MOSS_REPO", "Luigi/MOSS-TTS-Nano-100M-GGUF"),
+                          local_dir=MOSS_DIR,
+                          allow_patterns=["moss_nano_full.gguf", "tokenizer/*", "browser_poc_manifest.json"])
+        from huggingface_hub import hf_hub_download
+        os.environ.setdefault("MOSS_CODEC_GGUF",
+            hf_hub_download(os.environ.get("MOSS_CODEC_REPO", "hans00/MOSS-TTS-Nano-GGUF"),
+                            os.environ.get("MOSS_CODEC_FILE", "codec-q8_0.gguf")))
+        # tokenizer files live under tokenizer/ in the repo — flatten into MOSS_DIR
+        import shutil
+        for f in ("tokenizer.model", "browser_poc_manifest.json"):
+            src = os.path.join(MOSS_DIR, "tokenizer", f)
+            if os.path.exists(src) and not os.path.exists(os.path.join(MOSS_DIR, f)):
+                shutil.copy(src, os.path.join(MOSS_DIR, f))
+        return True
+    except Exception as e:
+        print(f"[moss] asset download failed ({e})"); return False
+_fetch_moss_assets()
+from moss_backend import MossBackend, SR_OUT as MOSS_SR
+MOSS = MossBackend(
+    moss_dir=MOSS_DIR,
+    gguf=os.environ.get("MOSS_GGUF", "moss_nano_full.gguf"),
+    moss_gen=os.environ.get("MOSS_GEN", str(HERE / "bin" / "moss-gen")),
+    codec_cli=os.environ.get("MOSS_CODEC_CLI", str(HERE / "bin" / "codec-cli")),
+    codec_gguf=os.environ.get("MOSS_CODEC_GGUF", str(MOSS_DIR + "/codec-q8_0.gguf")),
+    threads=int(os.environ.get("MOSS_THREADS", "2")))
+
 # ---- two preloaded gguf models: story (llama2.c-zh 15M) + chat (SmolLM-Chinese-180M) ----
 import time, random, textgen
 import opencc
@@ -221,6 +255,68 @@ async def healthz():
     return {"backend": BACKEND.kind, "sr": SR, "chunk_ms": CHUNK * HOP // (SR // 1000)}
 
 
+@app.get("/has_moss")
+async def has_moss():
+    return {"available": MOSS.available, "sr": MOSS_SR}
+
+@app.post("/moss_ref")
+async def moss_ref(session: str = "", clear: int = 0, file: UploadFile = File(None)):
+    """Upload a reference clip to clone its voice (or clear=1 to reset)."""
+    if not MOSS.available:
+        return {"ok": False, "error": "moss backend unavailable"}
+    if clear or file is None:
+        MOSS.clear_reference(session)
+        return {"ok": True, "cleared": True}
+    import io, soundfile as sf
+    data = await file.read()
+    w, sr = sf.read(io.BytesIO(data))
+    if getattr(w, "ndim", 1) > 1:
+        w = w.mean(1)
+    w = w.astype(np.float32)
+    if sr != MOSS_SR:
+        import librosa
+        w = librosa.resample(w, orig_sr=sr, target_sr=MOSS_SR)
+    n = MOSS.set_reference(session, w)
+    return {"ok": True, "ref_frames": n}
+
+@app.websocket("/moss_ws")
+async def moss_ws(sock: WebSocket):
+    """Stream MOSS-Nano: client sends {text, session}. 48 kHz PCM chunks (~80 ms/frame)."""
+    await sock.accept()
+    loop = asyncio.get_event_loop()
+    try:
+        while True:
+            msg = json.loads(await sock.receive_text())
+            text = (msg.get("text") or "").strip()
+            if not text:
+                continue
+            session = str(msg.get("session", ""))
+            if not MOSS.available:
+                await sock.send_text(json.dumps({"type": "error", "msg": "moss unavailable"}))
+                continue
+            await sock.send_text(json.dumps({"type": "start", "sr": MOSS_SR}))
+            q: asyncio.Queue = asyncio.Queue()
+
+            def emit(pcm):
+                loop.call_soon_threadsafe(q.put_nowait, pcm)
+                return True
+
+            def work():
+                for cl in _split_clauses(text):
+                    MOSS.stream(cl, emit, session_id=session)
+                loop.call_soon_threadsafe(q.put_nowait, None)
+
+            fut = loop.run_in_executor(None, work)
+            while True:
+                pcm = await q.get()
+                if pcm is None:
+                    break
+                await sock.send_bytes(pcm)
+            await fut
+            await sock.send_text(json.dumps({"type": "end"}))
+    except WebSocketDisconnect:
+        pass
+
 @app.websocket("/ws")
 async def ws(sock: WebSocket):
     await sock.accept()

static/index.html

@@ -47,9 +47,19 @@
     <div class="chips" id="chips"></div>
     <div class="row">
       <button id="go">▶ Speak (stream)</button>
-      <label class="opt">voice
+      <label class="opt">engine
+        <select id="engine" style="background:#0b0f16;color:var(--fg);border:1px solid #2a3342;border-radius:8px;padding:5px 8px;font-size:13px;">
+          <option value="vits">PrimeTTS (VITS 16k)</option>
+          <option value="moss">MOSS-Nano (clone 48k)</option>
+        </select>
+      </label>
+      <label class="opt" id="voicewrap">voice
         <select id="voice" style="background:#0b0f16;color:var(--fg);border:1px solid #2a3342;border-radius:8px;padding:5px 8px;font-size:13px;"></select>
       </label>
+      <label class="opt" id="refwrap" style="display:none;">🎙 ref
+        <input type="file" id="ref" accept="audio/*" style="font-size:12px;max-width:150px;">
+        <span id="refstat" style="font-size:12px;color:var(--acc);"></span>
+      </label>
       <label class="opt"><input type="checkbox" id="onenter" checked> stream on Enter</label>
       <span class="stat">first-audio <b id="first">–</b> · chunks <b id="nc">0</b> · <b id="audio">0.0s</b></span>
       <a id="dl" download="primetts.wav" style="display:none;color:var(--acc);font-size:13px;text-decoration:none;border:1px solid #2a3342;border-radius:8px;padding:5px 10px;">⬇ WAV</a>
@@ -98,15 +108,40 @@ fetch('/voices').then(r=>r.json()).then(j=>{
 }).catch(()=>{});
 const getSid = () => parseInt(($('voice')||{}).value || '0', 10);
 
+// ---- engine selector (VITS / MOSS-Nano voice clone) ----
+const SESSION = 'moss-' + Math.random().toString(36).slice(2);
+fetch('/has_moss').then(r=>r.json()).then(j=>{
+  if(!j || !j.available){ const e=$('engine'); if(e){ [...e.options].forEach(o=>{ if(o.value==='moss') o.disabled=true; }); } }
+}).catch(()=>{});
+function syncEngine(){
+  const moss = ($('engine')||{}).value === 'moss';
+  if($('refwrap')) $('refwrap').style.display = moss ? '' : 'none';
+  if($('voicewrap')) $('voicewrap').style.display = moss ? 'none' : '';
+}
+if($('engine')) $('engine').addEventListener('change', syncEngine);
+syncEngine();
+// upload a reference clip -> clone its voice for this session
+if($('ref')) $('ref').addEventListener('change', async e=>{
+  const f = e.target.files[0]; if(!f) return;
+  $('refstat').textContent = 'uploading…';
+  const fd = new FormData(); fd.append('file', f);
+  try{
+    const r = await fetch('/moss_ref?session='+encodeURIComponent(SESSION), {method:'POST', body:fd});
+    const j = await r.json();
+    $('refstat').textContent = j.ok ? `✓ cloned (${j.ref_frames} frames)` : ('✗ ' + (j.error||'failed'));
+  }catch(err){ $('refstat').textContent = '✗ error'; }
+});
+
 let ac, nextStart = 0;
 let curWs = null, srcs = [];   // active socket + scheduled audio sources (for Stop)
-function ensureCtx(){ if(!ac) ac = new (window.AudioContext||window.webkitAudioContext)({sampleRate:SR}); if(ac.state==='suspended') ac.resume(); }
+let curSR = SR;                // playback SR of the active stream (16k VITS / 48k MOSS)
+function ensureCtx(){ if(!ac) ac = new (window.AudioContext||window.webkitAudioContext)(); if(ac.state==='suspended') ac.resume(); }
 
 function playPCM(buf){
   const i16 = new Int16Array(buf);
   const f32 = new Float32Array(i16.length);
   for (let i=0;i<i16.length;i++) f32[i] = i16[i] / 32768;
-  const ab = ac.createBuffer(1, f32.length, SR);
+  const ab = ac.createBuffer(1, f32.length, curSR);   // browser resamples to ctx rate
   ab.copyToChannel(f32, 0);
   const src = ac.createBufferSource(); src.buffer = ab; src.connect(ac.destination);
   const now = ac.currentTime;
@@ -126,7 +161,7 @@ function capFinish(anchor){
   const wr = (o,s)=>{ for(let i=0;i<s.length;i++) dv.setUint8(o+i, s.charCodeAt(i)); };
   wr(0,'RIFF'); dv.setUint32(4, 36+capBytes, true); wr(8,'WAVE'); wr(12,'fmt ');
   dv.setUint32(16,16,true); dv.setUint16(20,1,true); dv.setUint16(22,1,true);
-  dv.setUint32(24,SR,true); dv.setUint32(28,SR*2,true); dv.setUint16(32,2,true); dv.setUint16(34,16,true);
+  dv.setUint32(24,curSR,true); dv.setUint32(28,curSR*2,true); dv.setUint16(32,2,true); dv.setUint16(34,16,true);
   wr(36,'data'); dv.setUint32(40, capBytes, true);
   let off=44; for(const c of capChunks){ wav.set(c, off); off+=c.length; }
   const url = URL.createObjectURL(new Blob([wav], {type:'audio/wav'}));
@@ -152,19 +187,22 @@ function speak(){
   capReset($('dl'));
   const t0 = performance.now(); let first=null, n=0, samples=0;
   const proto = location.protocol==='https:' ? 'wss':'ws';
-  const ws = new WebSocket(`${proto}://${location.host}/ws`); curWs = ws;
+  const moss = ($('engine')||{}).value === 'moss';
+  curSR = moss ? 48000 : SR;                                   // provisional; start msg confirms
+  const ws = new WebSocket(`${proto}://${location.host}/${moss ? 'moss_ws' : 'ws'}`); curWs = ws;
   ws.binaryType = 'arraybuffer';
   const done = () => { setBtn($('go'), false, '▶ Speak (stream)'); if(curWs===ws) curWs=null; };
-  ws.onopen = () => ws.send(JSON.stringify({text, sid: getSid()}));
+  ws.onopen = () => ws.send(JSON.stringify(moss ? {text, session: SESSION} : {text, sid: getSid()}));
   ws.onmessage = ev => {
     if (typeof ev.data === 'string'){ const m=JSON.parse(ev.data);
+      if(m.type==='start' && m.sr){ curSR = m.sr; }
       if(m.type==='end'){ ws.close(); }
       if(m.type==='error'){ $('first').textContent='—'; ws.close(); }
       return; }
     if(first===null){ first=performance.now()-t0; $('first').textContent=first.toFixed(0)+' ms'; }
     playPCM(ev.data); capPush(ev.data);
     n++; samples += ev.data.byteLength/2;
-    $('nc').textContent=n; $('audio').textContent=(samples/SR).toFixed(1)+'s';
+    $('nc').textContent=n; $('audio').textContent=(samples/curSR).toFixed(1)+'s';
     $('bar').style.width = Math.min(100, n*8)+'%';
   };
   ws.onclose = () => { done(); $('bar').style.width='100%'; capFinish($('dl')); };