Update app.py

app.py

@@ -11,7 +11,6 @@ import base64
 import hashlib
 import tempfile
 import subprocess
-import inspect
 from typing import Iterator, Iterable, Optional, Tuple, Any, List
 from dataclasses import dataclass
 import pathlib
@@ -28,13 +27,9 @@ from scipy.io.wavfile import write
 # ---------------------------------------------------------
 REPO_URL = "https://github.com/tuteishygpt/coqui-ai-TTS.git"
 REPO_DIR = "coqui-ai-TTS"
-
-if not os.path.exists(REPO_DIR):
-    subprocess.run(["git", "clone", REPO_URL, REPO_DIR], check=True)
-
+if not os.path.exists(REPO_DIR): subprocess.run(["git", "clone", REPO_URL, REPO_DIR], check=True)
 repo_root = os.path.abspath(REPO_DIR)
-if repo_root not in sys.path:
-    sys.path.insert(0, repo_root)
+if repo_root not in sys.path: sys.path.insert(0, repo_root)
 
 from TTS.tts.configs.xtts_config import XttsConfig
 from TTS.tts.models.xtts import Xtts
@@ -44,81 +39,40 @@ from TTS.tts.layers.xtts.tokenizer import VoiceBpeTokenizer, split_sentence
 # 2) мадэльныя файлы
 # ---------------------------------------------------------
 repo_id = "archivartaunik/BE_XTTS_V2_10ep250k"
-model_dir = "./model"
-os.makedirs(model_dir, exist_ok=True)
-
+model_dir = pathlib.Path("./model")
+model_dir.mkdir(exist_ok=True)
 for fname in ("model.pth", "config.json", "vocab.json", "voice.wav"):
-    fpath = os.path.join(model_dir, fname)
-    if not os.path.exists(fpath):
-        hf_hub_download(repo_id, filename=fname, local_dir=model_dir)
+    if not (model_dir / fname).exists(): hf_hub_download(repo_id, filename=fname, local_dir=model_dir)
 
 # ---------------------------------------------------------
 # 3) загрузка мадэлі
 # ---------------------------------------------------------
 config = XttsConfig()
-config.load_json(os.path.join(model_dir, "config.json"))
+config.load_json(str(model_dir / "config.json"))
 XTTS_MODEL = Xtts.init_from_config(config)
-XTTS_MODEL.load_checkpoint(
-    config,
-    checkpoint_path=os.path.join(model_dir, "model.pth"),
-    vocab_path=os.path.join(model_dir, "vocab.json"),
-    use_deepspeed=False,
-)
+XTTS_MODEL.load_checkpoint(config, checkpoint_path=str(model_dir / "model.pth"), vocab_path=str(model_dir / "vocab.json"), use_deepspeed=False)
 
 device = "cuda:0" if torch.cuda.is_available() else "cpu"
-
-torch.set_num_threads(1)
 if device.startswith("cuda"):
+    torch.cuda.manual_seed(0)
     torch.backends.cuda.matmul.allow_tf32 = True
     torch.backends.cudnn.allow_tf32 = True
-    torch.backends.cudnn.benchmark = True
-    torch.set_float32_matmul_precision("high")
-
-XTTS_MODEL.to(device).eval()
+XTTS_MODEL.to(device)
 sampling_rate = int(XTTS_MODEL.config.audio["sample_rate"])
 
-tokenizer = VoiceBpeTokenizer(vocab_file=os.path.join(model_dir, "vocab.json"))
-XTTS_MODEL.tokenizer = tokenizer
-
 # =========================================================
 # 4) Streaming-канфіг і дапаўненні
 # =========================================================
-INITIAL_MIN_BUFFER_S = 0.35
-MIN_BUFFER_S = 0.1
-FADE_S = 0.004
+INITIAL_MIN_BUFFER_S = 0.40 # Рэкамендаванае значэнне для балансу
+MIN_BUFFER_S = 0.15
+FADE_S = 0.005
 ENABLE_TEXT_SPLITTING = True
 
 def _to_np_audio(x) -> np.ndarray:
     if isinstance(x, dict) and "wav" in x: x = x["wav"]
-    if isinstance(x, torch.Tensor): x = x.detach().cpu().float().contiguous().view(-1)
+    if isinstance(x, torch.Tensor): x = x.detach().cpu().float().contiguous().view(-1).numpy()
     x = np.asarray(x, dtype=np.float32)
-    if x.ndim > 1: x = x.reshape(-1)
-    return x
-
-def _native_stream(model: Xtts, **kwargs) -> Iterator[np.ndarray]:
-    # <--- ВЫПРАЎЛЕННЕ: Выдалены непадтрымоўваемы параметр `stream_chunk_size_s`
-    # Ён перадаваўся няяўна праз kwargs, таму мы проста не будзем яго дадаваць
-    with torch.inference_mode(), torch.autocast(device_type="cuda", dtype=torch.float16, enabled=device.startswith("cuda")):
-        for out in model.inference_stream(**kwargs):
-            yield _to_np_audio(out)
-
-class NewTTSGenerationMixin:
-    @torch.inference_mode()
-    def generate(self: Xtts, text: str, do_stream: bool = False, **kwargs):
-        if not do_stream:
-            with torch.autocast(device_type="cuda", dtype=torch.float16, enabled=device.startswith("cuda")):
-                return _to_np_audio(self.inference(text=text, **kwargs))
-        return self.sample_stream(text=text, **kwargs)
-
-    @torch.inference_mode()
-    def sample_stream(self: Xtts, **kwargs) -> Iterator[np.ndarray]:
-        yield from _native_stream(self, **kwargs)
-
-def init_stream_support():
-    Xtts.generate = NewTTSGenerationMixin.generate
-    Xtts.sample_stream = NewTTSGenerationMixin.sample_stream
-
-init_stream_support()
+    return x.reshape(-1)
 
 # ---------------------------------------------------------
 # 5) пастаянны кэш латэнтаў
@@ -129,7 +83,7 @@ PERSIST_LATENTS_DIR.mkdir(parents=True, exist_ok=True)
 class LatentsMeta: model_id: str; gpt_cond_len: int; max_ref_len: int; sound_norm_refs: bool
 LATENT_CACHE: dict[str, Tuple[torch.Tensor, torch.Tensor]] = {}
 GPU_LATENT_CACHE: dict[Tuple[str, str], Tuple[torch.Tensor, torch.Tensor]] = {}
-default_voice_file = os.path.join(model_dir, "voice.wav")
+default_voice_file = str(model_dir / "voice.wav")
 
 def _latents_key(path: str | None, meta: LatentsMeta) -> str:
     base = f"{os.path.abspath(path)}:{os.path.getmtime(path)}:{os.path.getsize(path)}" if path and os.path.exists(path) else "default_voice"
@@ -138,8 +92,8 @@ def _latents_key(path: str | None, meta: LatentsMeta) -> str:
 def _latents_for(path: str | None, *, to_device: Optional[str] = None) -> Tuple[torch.Tensor, torch.Tensor]:
     meta = LatentsMeta(model_id=repo_id, gpt_cond_len=XTTS_MODEL.config.gpt_cond_len, max_ref_len=XTTS_MODEL.config.max_ref_len, sound_norm_refs=XTTS_MODEL.config.sound_norm_refs)
     key = _latents_key(path, meta)
-    if key in LATENT_CACHE: g, s = LATENT_CACHE[key]
-    else:
+    g, s = LATENT_CACHE.get(key) or (None, None)
+    if g is None:
         disk_path = PERSIST_LATENTS_DIR / f"{key}.pt"
         if disk_path.exists():
             data = torch.load(disk_path, map_location="cpu"); g, s = data["gpt_cond_latent"], data["speaker_embedding"]
@@ -155,228 +109,204 @@ def _latents_for(path: str | None, *, to_device: Optional[str] = None) -> Tuple[
         GPU_LATENT_CACHE[dev_key] = (g, s)
     return g, s
 
-# ---------------------------------------------------------
-# 6) "Прагрэў" прыкладання пры запуску
-# ---------------------------------------------------------
-print("Application warmup started...")
-t_warmup_start = time.perf_counter()
-try:
-    default_latents = _latents_for(default_voice_file, to_device=device)
-    print(f"Default voice latents cached and moved to {device}.")
-    _ = split_sentence("Прывітанне, свет.", lang="be")
-    print("Text splitter warmed up.")
-    with torch.inference_mode(), torch.autocast(device_type="cuda", dtype=torch.float16, enabled=device.startswith("cuda")):
-        _ = XTTS_MODEL.inference(" ", "be", default_latents[0], default_latents[1])
-    print("Main TTS model warmed up.")
-except Exception as e:
-    print(f"An error occurred during application warmup: {e}")
-t_warmup_end = time.perf_counter()
-print(f"Application warmup finished in {t_warmup_end - t_warmup_start:.2f} seconds.")
+# "Прагрэў" кэша для голасу па змаўчанні пры запуску
+try: _latents_for(default_voice_file, to_device=device)
+except Exception as e: print(f"Warning: Could not pre-cache default voice: {e}")
 
 # ---------------------------------------------------------
 # 7) Дапаможныя функцыі для стрыму
 # ---------------------------------------------------------
 def _seconds_to_samples(sec: float, sr: int) -> int: return max(1, int(sec * sr))
-def _crossfade_concat(a: np.ndarray, b: np.ndarray, sr: int, fade_s: float) -> np.ndarray:
-    if a.size == 0: return b
-    if b.size == 0: return a
-    fade_n = min(_seconds_to_samples(fade_s, sr), a.size, b.size)
-    if fade_n <= 1: return np.concatenate([a, b])
-    fade_out, fade_in = np.linspace(1.0, 0.0, fade_n, dtype=np.float32), np.linspace(0.0, 1.0, fade_n, dtype=np.float32)
-    tail = (a[-fade_n:] * fade_out) + (b[:fade_n] * fade_in)
-    return np.concatenate([a[:-fade_n], tail, b[fade_n:]])
-
-def _chunker_with_initial_buffer(chunks: Iterable[np.ndarray], sr: int, initial_target_s: float, target_s: float) -> Iterable[np.ndarray]:
+def _crossfade_concat(chunks: List[np.ndarray], sr: int, fade_s: float) -> np.ndarray:
+    if not chunks: return np.array([], dtype=np.float32)
+    result = chunks[0]
+    for i in range(1, len(chunks)):
+        b = chunks[i]
+        fade_n = min(_seconds_to_samples(fade_s, sr), result.size, b.size)
+        if fade_n <= 1: result = np.concatenate([result, b]); continue
+        fade_out, fade_in = np.linspace(1.0, 0.0, fade_n, dtype=np.float32), np.linspace(0.0, 1.0, fade_n, dtype=np.float32)
+        tail = (result[-fade_n:] * fade_out) + (b[:fade_n] * fade_in)
+        result = np.concatenate([result[:-fade_n], tail, b[fade_n:]])
+    return result
+
+def _chunker(chunks: Iterable[np.ndarray], sr: int, initial_target_s: float, target_s: float) -> Iterator[np.ndarray]:
     is_first, target_samples = True, _seconds_to_samples(initial_target_s, sr)
-    buffer_list, buffer_len = [], 0
+    buffer = np.array([], dtype=np.float32)
     for c_np in map(_to_np_audio, chunks):
         if c_np.size == 0: continue
-        buffer_list.append(c_np); buffer_len += c_np.size
-        if buffer_len >= target_samples:
-            yield np.concatenate(buffer_list)
-            buffer_list, buffer_len = [], 0
+        buffer = np.concatenate([buffer, c_np])
+        if buffer.size >= target_samples:
+            yield buffer
+            buffer = np.array([], dtype=np.float32)
             if is_first: is_first = False; target_samples = _seconds_to_samples(target_s, sr)
-    if buffer_len > 0: yield np.concatenate(buffer_list)
+    if buffer.size > 0: yield buffer
 
 def _pcm_f32_to_b64(x: np.ndarray) -> str: return base64.b64encode(x.tobytes()).decode("ascii")
 
-def _split_text_smart(text_in: str, lang: str, limit: int) -> List[str]:
-    # <--- ВЫПРАЎЛЕННЕ: Больш надзейная логіка падзелу тэксту
-    try:
-        sentences = split_sentence(text_in, lang=lang)
-        chunks = []
-        current_chunk = ""
-        for sentence in sentences:
-            if len(current_chunk) + len(sentence) + 1 > limit:
-                if current_chunk: chunks.append(current_chunk)
-                current_chunk = sentence
-            else:
-                current_chunk = (current_chunk + " " + sentence).strip()
-        if current_chunk: chunks.append(current_chunk)
-        # Калі нейкі кавалак усё роўна занадта доўгі, прымусова яго падзелім
-        final_chunks = []
-        for chunk in chunks:
-            if len(chunk) > limit:
-                final_chunks.extend([chunk[i:i+limit] for i in range(0, len(chunk), limit)])
-            else:
-                final_chunks.append(chunk)
-        return [c.strip() for c in final_chunks if c and c.strip()]
-    except Exception as e:
-        print(f"Error in text splitter: {e}. Falling back to basic split.")
-        return [text_in[i:i+limit] for i in range(0, len(text_in), limit)]
+def _split_text_smart(text: str, lang: str, limit: int) -> List[str]:
+    try: sentences = split_sentence(text, lang=lang)
+    except Exception: sentences = [text]
+    chunks, current_chunk = [], ""
+    for sentence in sentences:
+        if len(current_chunk) + len(sentence) + 1 > limit and current_chunk:
+            chunks.append(current_chunk); current_chunk = ""
+        current_chunk = (current_chunk + " " + sentence).strip()
+    if current_chunk: chunks.append(current_chunk)
+    final_chunks = []
+    for chunk in chunks:
+        if len(chunk) > limit: final_chunks.extend(chunk[i:i+limit] for i in range(0, len(chunk), limit))
+        else: final_chunks.append(chunk)
+    return [c.strip() for c in final_chunks if c.strip()]
 
 # ---------------------------------------------------------
 # 8) TTS — асноўная функцыя
 # ---------------------------------------------------------
 @spaces.GPU(duration=120)
-def text_to_speech(belarusian_story, speaker_audio_file, initial_buffer_s, subsequent_buffer_s):
-    t0 = time.perf_counter()
-    if not belarusian_story or not str(belarusian_story).strip(): raise gr.Error("Увядзі хоць нейкі тэкст 🙂")
+def text_to_speech(text_input, speaker_audio, initial_buffer_s, subsequent_buffer_s):
+    t_start_req = time.perf_counter()
+    if not text_input or not str(text_input).strip(): raise gr.Error("Увядзі хоць нейкі тэкст 🙂")
     
-    t_lat0 = time.perf_counter()
-    gpt_cond_latent, speaker_embedding = _latents_for(speaker_audio_file or default_voice_file, to_device=device)
-    t_lat1 = time.perf_counter()
+    t_lat_0 = time.perf_counter()
+    gpt_cond_latent, speaker_embedding = _latents_for(speaker_audio or default_voice_file, to_device=device)
+    t_lat_1 = time.perf_counter()
 
-    t_split0 = time.perf_counter()
+    t_split_0 = time.perf_counter()
     char_limit = XTTS_MODEL.tokenizer.char_limits.get("be", 250)
-    texts = _split_text_smart(str(belarusian_story).strip(), "be", char_limit) if ENABLE_TEXT_SPLITTING else [str(belarusian_story).strip()]
-    t_split1 = time.perf_counter()
-
-    server_metrics = {
-        "latents_s": t_lat1 - t_lat0, "text_split_s": t_split1 - t_split0,
-        "initial_buffer_s": initial_buffer_s, "subsequent_buffer_s": subsequent_buffer_s,
-    }
+    texts = _split_text_smart(str(text_input).strip(), "be", char_limit) if ENABLE_TEXT_SPLITTING else [str(text_input).strip()]
+    t_split_1 = time.perf_counter()
+    
+    # Фаза 1: Адпраўка пачатковых метрык неадкладна
+    server_metrics = { "latents_s": t_lat_1 - t_lat_0, "text_split_s": t_split_1 - t_split_0, "initial_buffer_s": initial_buffer_s, "subsequent_buffer_s": subsequent_buffer_s }
     yield ("", None, None, json.dumps(server_metrics))
-
-    full_audio_chunks, first_chunk_seen = [], False
-    t_gen0 = time.perf_counter()
-    for part in texts:
-        gen = XTTS_MODEL.generate(
-            text=part, do_stream=True, language="be",
-            gpt_cond_latent=gpt_cond_latent, speaker_embedding=speaker_embedding,
-            temperature=0.1, length_penalty=1.0, repetition_penalty=10.0, top_k=10, top_p=0.3,
+    
+    # Фаза 2: Генерацыя і стрымінг
+    full_audio_chunks, first_chunk_sent = [], False
+    t_gen_start = time.perf_counter()
+    
+    all_chunks_iterator = (
+        chunk for part in texts for chunk in XTTS_MODEL.inference_stream(
+            text=part, language="be", gpt_cond_latent=gpt_cond_latent, speaker_embedding=speaker_embedding,
+            temperature=0.2, length_penalty=1.0, repetition_penalty=10.0, top_k=20, top_p=0.85
         )
-        chunk_iterator = _chunker_with_initial_buffer(gen, sampling_rate, initial_buffer_s, subsequent_buffer_s)
-        for buf in chunk_iterator:
-            if not first_chunk_seen:
-                t_first = time.perf_counter()
-                server_metrics["gen_init_to_first_chunk_s"] = t_first - t_gen0
-                server_metrics["until_first_chunk_total_s"] = t_first - t0
-                known = sum(v for k, v in server_metrics.items() if isinstance(v, (int, float)) and k.endswith('_s'))
-                server_metrics["server_unaccounted_before_first_chunk_s"] = max(0.0, server_metrics["until_first_chunk_total_s"] - known)
-                first_chunk_seen = True
-                yield (_pcm_f32_to_b64(buf), None, None, json.dumps(server_metrics))
-            else:
-                yield (_pcm_f32_to_b64(buf), None, None, None)
-            full_audio_chunks.append(buf)
+    )
+
+    for audio_chunk in _chunker(all_chunks_iterator, sampling_rate, initial_buffer_s, subsequent_buffer_s):
+        if not first_chunk_sent:
+            t_first_chunk_ready = time.perf_counter()
+            server_metrics["gen_init_to_first_chunk_s"] = t_first_chunk_ready - t_gen_start
+            server_metrics["until_first_chunk_total_s"] = t_first_chunk_ready - t_start_req
+            yield (_pcm_f32_to_b64(audio_chunk), None, None, json.dumps(server_metrics))
+            first_chunk_sent = True
+        else:
+            yield (_pcm_f32_to_b64(audio_chunk), None, None, None)
+        full_audio_chunks.append(audio_chunk)
 
     if not full_audio_chunks:
         yield ("__STOP__", None, None, json.dumps(server_metrics)); return
 
-    t_w0 = time.perf_counter()
-    full_audio = full_audio_chunks[0]
-    for i in range(1, len(full_audio_chunks)):
-        full_audio = _crossfade_concat(full_audio, full_audio_chunks[i], sampling_rate, FADE_S)
-    
+    t_write_0 = time.perf_counter()
+    full_audio = _crossfade_concat(full_audio_chunks, sampling_rate, FADE_S)
     with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
         write(tmp.name, sampling_rate, full_audio)
-    server_metrics["file_write_s"] = time.perf_counter() - t_w0
+    server_metrics["file_write_s"] = time.perf_counter() - t_write_0
     yield ("__STOP__", tmp.name, tmp.name, json.dumps(server_metrics))
 
 # ---------------------------------------------------------
 # 9) UI
 # ---------------------------------------------------------
 examples = [["Прывітанне! Гэта праверка жывога струменя беларускага TTS.", None, INITIAL_MIN_BUFFER_S, MIN_BUFFER_S]]
-
 with gr.Blocks() as demo:
     gr.Markdown("## Belarusian TTS — Streaming (стабільны старт) + фінальны файл")
     with gr.Row():
         inp_text = gr.Textbox(lines=5, label="Тэкст на беларускай мове")
-        inp_voice = gr.Audio(type="filepath", label="Прыклад голасу (6–10 сек)", interactive=True)
+        inp_voice = gr.Audio(type="filepath", label="Прыклад голасу (6–10 сек)")
     with gr.Accordion("Дадатковыя налады стрымінгу", open=True):
-        initial_buffer_slider = gr.Slider(minimum=0.1, maximum=1.0, value=INITIAL_MIN_BUFFER_S, step=0.05, label="Пачатковы буфер (с)")
+        initial_buffer_slider = gr.Slider(minimum=0.1, maximum=1.5, value=INITIAL_MIN_BUFFER_S, step=0.05, label="Пачатковы буфер (с)")
         subsequent_buffer_slider = gr.Slider(minimum=0.05, maximum=0.5, value=MIN_BUFFER_S, step=0.01, label="Наступны буфер (с)")
-    with gr.Row():
-        run_btn = gr.Button("Згенераваць")
-        gr.Markdown(f"**Sample rate:** {sampling_rate} Hz")
+    with gr.Row(): run_btn = gr.Button("Згенераваць"); gr.Markdown(f"**Sample rate:** {sampling_rate} Hz")
     log_panel = gr.HTML(value='<div id="wa-log" style="font-family:monospace;font-size:12px;white-space:pre-line">[лог пусты]</div>', label="Лагі плэера")
     stream_pipe, log_pipe, final_file, final_audio = gr.Textbox(visible=False), gr.Textbox(visible=False), gr.File(label="Згенераваны WAV"), gr.Audio(label="Фінальнае аўдыя", type="filepath")
 
-    INIT_RESET_JS = f"""
+    JS_CODE = f"""
 () => {{
   const sampleRate = {sampling_rate};
-  if (window.__wa) {{ window.__wa.reset(); return; }}
-  const AC = window.AudioContext || window.webkitAudioContext;
-  if (!AC) return;
-  const ctx = new AC({{ sampleRate }});
-  const node = ctx.createScriptProcessor(4096, 0, 1);
-  let queue = [], playing = false, eos = false;
-  const meta = {{ t_click_ms: performance.now(), chunk_durations: [] }};
-  node.onaudioprocess = (e) => {{
-    const out = e.outputBuffer.getChannelData(0); let i = 0;
-    while (i < out.length) {{
-      if (queue.length === 0 || !playing) {{ out[i++] = 0.0; continue; }}
-      let cur = queue[0];
-      const take = Math.min(cur.length, out.length - i);
-      if (meta.t_first_audio_ms === null) {{ meta.t_first_audio_ms = performance.now(); logUpdate(); }}
-      out.set(cur.subarray(0, take), i); i += take;
-      if (take === cur.length) queue.shift(); else queue[0] = cur.subarray(take);
-    }}
-    if (eos && queue.length === 0 && playing) {{ playing = false; logUpdate(); }}
-  }};
-  node.connect(ctx.destination);
-  function fmtS(x) {{ return x === null || x === undefined ? "n/a" : x.toFixed(3) + " s"; }}
-  function logUpdate() {{
-    const el = document.getElementById('wa-log'); if (!el) return;
-    const s = meta.server || {{}};
-    const lines = ["Клік (Згенераваць): 0.000 s"];
-    if (meta.t_first_push_ms) {{
-      lines.push("Першы чанк прыйшоў:   " + fmtS((meta.t_first_push_ms - meta.t_click_ms) / 1000));
-      if (meta.t_first_audio_ms) {{
-        lines.push("Пачатак прайгравання: " + fmtS((meta.t_first_audio_ms - meta.t_click_ms) / 1000));
-        lines.push("Затрымка (чанк→аўдыя): " + fmtS((meta.t_first_audio_ms - meta.t_first_push_ms) / 1000));
+  // Ініцыялізацыя або скід стану плэера
+  function initOrResetPlayer() {{
+    if (window.__wa) {{ window.__wa.reset(); return; }}
+    const AC = window.AudioContext || window.webkitAudioContext;
+    if (!AC) {{ console.error("AudioContext is not supported."); return; }}
+    const ctx = new AC({{ sampleRate }});
+    const node = ctx.createScriptProcessor(4096, 1, 1);
+    let queue = [], playing = false, eos = false;
+    let meta = {{ t_click_ms: performance.now(), chunk_durations: [] }};
+    
+    node.onaudioprocess = (e) => {{
+      const out = e.outputBuffer.getChannelData(0); let i = 0;
+      while (i < out.length) {{
+        if (queue.length === 0 || !playing) {{ out[i++] = 0.0; continue; }}
+        let cur = queue[0];
+        const take = Math.min(cur.length, out.length - i);
+        if (meta.t_first_audio_ms === null) {{ meta.t_first_audio_ms = performance.now(); logUpdate(); }}
+        out.set(cur.subarray(0, take), i); i += take;
+        if (take === cur.length) queue.shift(); else queue[0] = cur.subarray(take);
+      }}
+      if (eos && queue.length === 0 && playing) {{ playing = false; logUpdate(); }}
+    }};
+    node.connect(ctx.destination);
+
+    function fmtS(x) {{ return x === null || x === undefined ? "n/a" : x.toFixed(3) + " s"; }}
+    function logUpdate() {{
+      const el = document.getElementById('wa-log'); if (!el) return;
+      const s = meta.server || {{}}; const lines = ["Клік (Згенераваць): 0.000 s"];
+      if (meta.t_first_push_ms) {{
+        lines.push("Першы чанк прыйшоў:   " + fmtS((meta.t_first_push_ms - meta.t_click_ms) / 1000));
+        if (meta.t_first_audio_ms) {{
+          lines.push("Пачатак прайгравання: " + fmtS((meta.t_first_audio_ms - meta.t_click_ms) / 1000));
+          lines.push("Затрымка (чанк→аўдыя): " + fmtS((meta.t_first_audio_ms - meta.t_first_push_ms) / 1000));
+        }}
       }}
+      lines.push("\\n— Налады стрыму —", "Пачатковы буфер (запыт):  " + fmtS(s.initial_buffer_s), "Наступны буфер (запыт):   " + fmtS(s.subsequent_buffer_s));
+      if (meta.chunk_durations.length > 0) {{ lines.push("Працягласць 1-га чанка:    " + meta.chunk_durations[0] + " s", "Атрымана чанкаў:          " + meta.chunk_durations.length); }}
+      lines.push("\\n— Серверныя метрыкі —", "Latents (умоўны голас):  " + fmtS(s.latents_s), "Падзел тэксту:           " + fmtS(s.text_split_s), "Ініт→1-ы чанк:           " + fmtS(s.gen_init_to_first_chunk_s), "Усё да 1-га чанка:       " + fmtS(s.until_first_chunk_total_s));
+      if (meta.t_first_push_ms && s.until_first_chunk_total_s) {{ lines.push("\\nАцэнка чаргі ZeroGPU + сеткі: " + fmtS(Math.max(0, (meta.t_first_push_ms - meta.t_click_ms) / 1000 - s.until_first_chunk_total_s))); }}
+      lines.push("\\nСтатус стриму: " + (playing ? "playing" : "stopped"));
+      el.innerHTML = lines.join("\\n");
     }}
-    lines.push("\\n— Налады стрыму —", "Пачатковы буфер (запыт):  " + fmtS(s.initial_buffer_s), "Наступны буфер (запыт):   " + fmtS(s.subsequent_buffer_s));
-    if (meta.chunk_durations.length > 0) {{ lines.push("Працягласць 1-га чанка:    " + meta.chunk_durations[0] + " s", "Атрымана чанкаў:          " + meta.chunk_durations.length); }}
-    lines.push("\\n— Серверныя метрыкі —", "Latents (умоўны голас):  " + fmtS(s.latents_s), "Падзел тэксту:           " + fmtS(s.text_split_s), "Ініт→1-ы чанк:           " + fmtS(s.gen_init_to_first_chunk_s), "Усё да 1-га чанка:       " + fmtS(s.until_first_chunk_total_s), "Іншая серверная апрац.:  " + fmtS(s.server_unaccounted_before_first_chunk_s), "Запіс WAV:               " + fmtS(s.file_write_s));
-    if (meta.t_first_push_ms && s.until_first_chunk_total_s) {{ lines.push("\\nАцэнка чаргі ZeroGPU + сеткі: " + fmtS(Math.max(0, (meta.t_first_push_ms - meta.t_click_ms) / 1000 - s.until_first_chunk_total_s))); }}
-    lines.push("\\nСтатус стриму: " + (playing ? "playing" : "stopped"));
-    el.innerHTML = lines.join("\\n");
+
+    window.__wa = {{
+      push: (b64) => {{
+        if (b64 === "__STOP__") {{ eos = true; logUpdate(); return; }}
+        const bin = atob(b64); const buf = new ArrayBuffer(bin.length); const view = new Uint8Array(buf);
+        for (let i=0; i<bin.length; i++) view[i] = bin.charCodeAt(i);
+        const f32 = new Float32Array(buf);
+        if (meta.chunk_durations.length === 0 && f32.length > 0) meta.t_first_push_ms = performance.now();
+        meta.chunk_durations.push((f32.length / ctx.sampleRate).toFixed(3));
+        queue.push(f32);
+        if (!playing && queue.length > 0) {{ playing = true; if(ctx.state === "suspended") ctx.resume(); }}
+        logUpdate();
+      }},
+      update_server_metrics: (js) => {{ if(js) meta.server = JSON.parse(js); logUpdate(); }},
+      reset: () => {{
+        playing = false; eos = false; queue.length = 0;
+        meta = {{ t_click_ms: performance.now(), chunk_durations: [], server: null }}; logUpdate();
+      }},
+    }};
+  }}
+  // Асноўная функцыя, якая выклікаецца па падзеі
+  return function(...args) {{
+    initOrResetPlayer();
+    // Вяртаем аргументы для Gradio, каб ён працягнуў ланцужок выклікаў
+    return args;
   }}
-  window.__wa = {{
-    ctx, meta,
-    push: (b64) => {{
-      if (b64 === "__STOP__") {{ eos = true; logUpdate(); return; }}
-      const bin = atob(b64); const buf = new ArrayBuffer(bin.length); const view = new Uint8Array(buf);
-      for (let i=0; i<bin.length; i++) view[i] = bin.charCodeAt(i);
-      const f32 = new Float32Array(buf);
-      meta.chunk_durations.push((f32.length / ctx.sampleRate).toFixed(3));
-      queue.push(f32);
-      if (!meta.t_first_push_ms) meta.t_first_push_ms = performance.now();
-      if (!playing && queue.length >= 1) {{ playing = true; try{{ctx.resume()}}catch(e){{}} }}
-      logUpdate();
-    }},
-    update_server_metrics: (js) => {{ if(js) meta.server = JSON.parse(js); logUpdate(); }},
-    reset: () => {{
-      playing = false; eos = false; queue = [];
-      meta.t_click_ms = performance.now(); meta.t_first_push_ms = null; meta.t_first_audio_ms = null;
-      meta.chunk_durations = []; meta.server = null; logUpdate();
-    }},
-  }};
-}}
+}}()
 """
-    PUSH_JS = "(b64) => { if (window.__wa) window.__wa.push(b64); }"
-    LOG_JS = "(js) => { if (window.__wa) window.__wa.update_server_metrics(js); }"
-    
-    run_btn.click(fn=None, js=INIT_RESET_JS)
-    run_btn.click(
+    run_btn.click(fn=None, js=JS_CODE, inputs=None, outputs=None).then(
         fn=text_to_speech,
         inputs=[inp_text, inp_voice, initial_buffer_slider, subsequent_buffer_slider],
         outputs=[stream_pipe, final_file, final_audio, log_pipe]
     )
-    stream_pipe.change(fn=None, inputs=[stream_pipe], js=PUSH_JS)
-    log_pipe.change(fn=None, inputs=[log_pipe], js=LOG_JS)
+    stream_pipe.change(fn=lambda b64: window.__wa.push(b64) if window.__wa else None, inputs=[stream_pipe], js="(b64) => { if(window.__wa) window.__wa.push(b64); }")
+    log_pipe.change(fn=lambda js: window.__wa.update_server_metrics(js) if window.__wa else None, inputs=[log_pipe], js="(js) => { if(window.__wa) window.__wa.update_server_metrics(js); }")
     gr.Examples(examples=examples, inputs=[inp_text, inp_voice, initial_buffer_slider, subsequent_buffer_slider], cache_examples=False)
 
 if __name__ == "__main__":