Upload folder using huggingface_hub

arc.py

@@ -179,6 +179,15 @@ def stage_default_mood(stage: str) -> str:
     return s["default_mood"]
 
 
+def sample_line(stage: str, seed: int = 0) -> str:
+    """A clean, stage-appropriate canned line (fallback when brain text is junk)."""
+    s = _STAGE_BY_KEY.get(stage) or _STAGE_BY_KEY["oblivious"]
+    lines = s.get("sample_lines") or []
+    if not lines:
+        return "Stay with me, friend. The night's long and the dial's warm."
+    return lines[int(seed) % len(lines)]
+
+
 # ---------------------------------------------------------------------------
 # System-prompt assembly
 # ---------------------------------------------------------------------------

proxy.py

@@ -15,6 +15,7 @@ import datetime
 import io
 import json
 import os
+import re
 import struct
 import threading
 import wave
@@ -189,6 +190,70 @@ def call_speak(text: str, voice: str = arc.VOICE) -> Dict[str, Any]:
     return resp.json()
 
 
+# ---------------------------------------------------------------------------
+# DJ-text sanitizer: a small 1B model sometimes leaks the JSON labels into the
+# spoken text ("...mood: warm") or emits placeholders ("<sentence 1>"). We never
+# want the DJ to SAY those, so we scrub the text before TTS and, if what's left
+# is degenerate, fall back to a clean stage-appropriate canned line.
+# ---------------------------------------------------------------------------
+_LABEL_RE = re.compile(
+    r"[\(\[]?\s*\b(?:mood|arc[_ ]?cue)\b\s*[:=]\s*[a-z_]+\s*[\)\]]?", re.IGNORECASE
+)
+_PLACEHOLDER_RE = re.compile(r"<[^>]{0,40}>|\bsentence\s*\d+\b", re.IGNORECASE)
+
+
+def _clean_dj_text(text: Optional[str]) -> Optional[str]:
+    """Strip label leakage / markdown; return cleaned spoken text or None if junk."""
+    t = text or ""
+    t = _LABEL_RE.sub("", t)          # drop "mood: warm" / "arc_cue: none"
+    t = re.sub(r"[*#`]+", "", t)       # drop markdown emphasis/headings
+    t = t.strip()
+    if len(t) >= 2 and t[0] in "\"'" and t[-1] in "\"'":
+        t = t[1:-1].strip()            # unwrap a fully-quoted line
+    t = re.sub(r"\s+", " ", t).strip()  # it's spoken: collapse whitespace
+    # Degenerate?  empty / placeholder / angle-bracket template / too few letters.
+    if not t or _PLACEHOLDER_RE.search(t) or ("<" in t and ">" in t):
+        return None
+    if len(re.sub(r"[^a-zA-Z]", "", t)) < 6:
+        return None
+    return t
+
+
+# ---------------------------------------------------------------------------
+# Pre-cached "stall" lines: instant filler audio played the moment a caller stops
+# talking, while the real reply generates underneath -- so the call never has
+# dead air. Synthesized once (per container) via Modal /speak, then cached.
+# ---------------------------------------------------------------------------
+_STALL_LINES = [
+    "Mm. Good question, friend. Let me sit with that a second.",
+    "That's a thing to ask at this hour. Hold on now, let me find the words.",
+    "Hm. Give me a breath, caller. The night makes me slow.",
+    "Let me think on that one. Stay right there with me.",
+]
+_stall_cache: Optional[List[str]] = None
+_stall_lock = threading.Lock()
+
+
+def get_stalls() -> List[str]:
+    """Return a list of base64 WAV stall clips (cached after first synthesis)."""
+    global _stall_cache
+    if _stall_cache is not None:
+        return _stall_cache
+    with _stall_lock:
+        if _stall_cache is not None:
+            return _stall_cache
+        clips: List[str] = []
+        for line in _STALL_LINES:
+            try:
+                sp = call_speak(line)
+                if sp.get("audio_b64"):
+                    clips.append(sp["audio_b64"])
+            except Exception:
+                pass
+        _stall_cache = clips
+        return clips
+
+
 # ---------------------------------------------------------------------------
 # High-level turns (what server.py routes call)
 # ---------------------------------------------------------------------------
@@ -202,7 +267,7 @@ def broadcast_turn(
     """
     system = arc.build_system_prompt(stage, "broadcast", topic=topic)
     brain = call_brain(system, [{"role": "user", "content": "Go on air."}])
-    text = brain.get("text", "")
+    text = _clean_dj_text(brain.get("text", "")) or arc.sample_line(stage, meter)
     mood = brain.get("mood", arc.stage_default_mood(stage))
     arc_cue = brain.get("arc_cue", "none")
     speak = call_speak(text)
@@ -241,7 +306,7 @@ def call_turn(stage: str, meter: int, audio_b64: str) -> Dict[str, Any]:
         brain = call_brain(
             system, [{"role": "user", "content": caller_text or "(crackle)"}]
         )
-        text = brain.get("text", "")
+        text = _clean_dj_text(brain.get("text", "")) or arc.sample_line(stage, meter)
         mood = brain.get("mood", arc.stage_default_mood(stage))
         arc_cue = brain.get("arc_cue", "none")
 

radio.html

@@ -751,8 +751,14 @@ function initAudio(){
   Sound.crackleGain.connect(Sound.analyser);
   Sound.crackleSrc.start(0);
 
+  // ----- lo-fi percussion bus (kick + brushed hat), gain-gated like the pad ---
+  Sound.drumGain = ctx.createGain();
+  Sound.drumGain.gain.value = 0.0;
+  Sound.drumGain.connect(Sound.analyser);
+
   // ----- hiss bed: noise -> lowpass -> hissGain -> analyser
   const buf = makeNoiseBuffer(ctx);
+  Sound.noiseBuf = buf;            // reused by the brushed-hat percussion
   Sound.hissSrc = ctx.createBufferSource();
   Sound.hissSrc.buffer = buf;
   Sound.hissSrc.loop = true;
@@ -824,6 +830,11 @@ function updateHissForTuning(){
   let pad = (State.powered && locked) ? 0.05 : 0.0;
   if (Sound._voicing) pad *= 0.55;                 // sit back under the voice
   rampGain(Sound.padGain, pad, 0.8);
+
+  // --- lo-fi percussion: rides with the pad, ducks well under the voice ---
+  let drum = (State.powered && locked) ? 0.35 : 0.0;
+  if (Sound._voicing) drum *= 0.4;
+  if (Sound.drumGain) rampGain(Sound.drumGain, drum, 0.6);
 }
 
 function rampGain(node, target, t){
@@ -834,6 +845,58 @@ function rampGain(node, target, t){
   node.gain.linearRampToValueAtTime(target, now + t);
 }
 
+// ---- lo-fi percussion: soft kick + brushed hat on a slow, sparse pattern ----
+function playKick(t){
+  if (!Sound.ctx || !Sound.drumGain) return;
+  const o = Sound.ctx.createOscillator(), g = Sound.ctx.createGain();
+  o.type = "sine";
+  o.frequency.setValueAtTime(115, t);
+  o.frequency.exponentialRampToValueAtTime(45, t + 0.12);
+  g.gain.setValueAtTime(0.0001, t);
+  g.gain.exponentialRampToValueAtTime(0.9, t + 0.005);
+  g.gain.exponentialRampToValueAtTime(0.0001, t + 0.30);
+  o.connect(g); g.connect(Sound.drumGain);
+  o.start(t); o.stop(t + 0.33);
+}
+function playHat(t){
+  if (!Sound.ctx || !Sound.drumGain || !Sound.noiseBuf) return;
+  const s = Sound.ctx.createBufferSource(), g = Sound.ctx.createGain(), hp = Sound.ctx.createBiquadFilter();
+  s.buffer = Sound.noiseBuf;
+  hp.type = "highpass"; hp.frequency.value = 7500;
+  g.gain.setValueAtTime(0.0001, t);
+  g.gain.exponentialRampToValueAtTime(0.16, t + 0.003);
+  g.gain.exponentialRampToValueAtTime(0.0001, t + 0.06);
+  s.connect(hp); hp.connect(g); g.connect(Sound.drumGain);
+  s.start(t); s.stop(t + 0.08);
+}
+function startDrums(){
+  if (Sound.drumTimer || !Sound.ctx) return;
+  const bpm = 76, stepDur = (60 / bpm) / 2;        // eighth notes
+  const KICK = [1,0,0,0,1,0,0,0], HAT = [0,0,1,0,0,0,1,0];
+  let step = 0, nextTime = Sound.ctx.currentTime + 0.12;
+  function tick(){
+    while (nextTime < Sound.ctx.currentTime + 0.25){
+      if (KICK[step % 8]) playKick(nextTime);
+      if (HAT[step % 8]) playHat(nextTime);
+      nextTime += stepDur; step++;
+    }
+    Sound.drumTimer = setTimeout(tick, 60);
+  }
+  tick();
+}
+function stopDrums(){
+  if (Sound.drumTimer){ clearTimeout(Sound.drumTimer); Sound.drumTimer = null; }
+}
+
+// ---- stall lines: prefetch instant filler clips to mask call latency ----
+async function fetchStalls(){
+  try{
+    const r = await fetch("/api/stalls");
+    if (r.ok){ const j = await r.json(); if (Array.isArray(j.stalls)) return j.stalls; }
+  }catch(_){}
+  return [];
+}
+
 // short burst of noise (glitch beat)
 function noiseBurst(dur, level){
   if (!Sound.ctx) return;
@@ -1143,7 +1206,7 @@ function handleArcCue(cue){
       const now = Sound.ctx.currentTime;
       Sound.bandpass.frequency.cancelScheduledValues(now);
       Sound.bandpass.frequency.setValueAtTime(Sound.bandpass.frequency.value, now);
-      Sound.bandpass.frequency.linearRampToValueAtTime(1100, now+0.8);
+      Sound.bandpass.frequency.linearRampToValueAtTime(2000, now+0.8);
       Sound.bandpass.Q.linearRampToValueAtTime(0.4, now+0.8);
     }
   } else {
@@ -1153,7 +1216,7 @@ function handleArcCue(cue){
       const now = Sound.ctx.currentTime;
       Sound.bandpass.frequency.cancelScheduledValues(now);
       Sound.bandpass.frequency.setValueAtTime(Sound.bandpass.frequency.value, now);
-      Sound.bandpass.frequency.linearRampToValueAtTime(1700, now+0.5);
+      Sound.bandpass.frequency.linearRampToValueAtTime(3400, now+0.5);
       Sound.bandpass.Q.linearRampToValueAtTime(0.7, now+0.5);
     }
   }
@@ -1237,11 +1300,18 @@ function stopCall(e){
 
 async function onCallStop(){
   const blob = new Blob(Sound.recChunks, { type: (Sound.recorder && Sound.recorder.mimeType) || "audio/webm" });
-  showCaption("… the DJ is responding …", "status");
   State.busy = true;
   let audio_b64 = "";
   try{ audio_b64 = await blobToB64(blob); }catch(e){}
-  const data = await api("/api/call", { stage:State.stage, meter:Math.round(State.meter), audio_b64 });
+  // Fire the real request FIRST, then mask its latency with an instant stall
+  // line that plays while the reply generates underneath -- no dead air.
+  const respP = api("/api/call", { stage:State.stage, meter:Math.round(State.meter), audio_b64 });
+  showCaption("… the DJ is responding …", "status");
+  if (Sound.stalls && Sound.stalls.length){
+    const stall = Sound.stalls[Math.floor(Math.random() * Sound.stalls.length)];
+    try{ await playVoiceB64(stall); }catch(_){}
+  }
+  const data = await respP;
   State.busy = false;
   if (data && typeof data.meter_delta === "number") addMeter(data.meter_delta);
   await playSegment(data, data && data.caller_text);
@@ -1280,6 +1350,8 @@ async function powerOn(){
   els.onairLabel.textContent = "RECEIVING";
   updateHissForTuning();
   rampGain(Sound.crackleGain, 0.05, 0.6);   // bring up the vinyl/room bed
+  startDrums();
+  if (!Sound.stalls) fetchStalls().then(s=>{ Sound.stalls = s; });
   State.lastVoiceEnd = performance.now();
   showCaption("… tuning in …", "status");
   setTimeout(()=>broadcast(), 400);
@@ -1294,7 +1366,8 @@ function powerOff(){
   els.onairLabel.textContent = "STANDBY";
   setBroadcasting(false);
   try{ if (Sound.voiceEl) Sound.voiceEl.pause(); }catch(e){}
-  if (Sound.ctx){ rampGain(Sound.hissGain, 0, 0.3); rampGain(Sound.padGain, 0, 0.3); rampGain(Sound.crackleGain, 0, 0.3); }
+  if (Sound.ctx){ rampGain(Sound.hissGain, 0, 0.3); rampGain(Sound.padGain, 0, 0.3); rampGain(Sound.crackleGain, 0, 0.3); rampGain(Sound.drumGain, 0, 0.3); }
+  stopDrums();
   showCaption("Turn the power knob to tune in…");
 }
 

server.py

@@ -131,4 +131,13 @@ def create_api() -> FastAPI:
     def api_seek(req: SeekReq):
         return {"stage": arc.meter_to_stage(req.meter)}
 
+    @api.get("/api/stalls")
+    def api_stalls():
+        # Pre-synthesized filler clips the radio plays instantly while a real
+        # call reply generates (so the call never has dead air).
+        try:
+            return {"stalls": proxy.get_stalls()}
+        except Exception:
+            return {"stalls": []}
+
     return api