Upload app.py

app.py

@@ -184,7 +184,7 @@ from scipy.ndimage import uniform_filter, binary_closing, binary_opening
 
 REF_SR      = 22050          # XTTS conditioning sample-rate
 XTTS_SR     = 24000          # XTTS output sample-rate
-VQ_VERSION  = "1"
+VQ_VERSION  = "2"
 
 # ── generic helpers ───────────────────────────────────────────────────
 def _db(x): return 20.0 * np.log10(np.maximum(x, 1e-9))
@@ -275,52 +275,6 @@ def _segments(mask):
     d = np.diff(np.concatenate([[0], mask.astype(np.int8), [0]]))
     return list(zip(np.where(d == 1)[0], np.where(d == -1)[0]))
 
-def _snap_low(db, i, span=50):
-    lo, hi = max(0, i - span), min(len(db), i + span + 1)
-    return lo + int(np.argmin(db[lo:hi]))
-
-def _compact_speech(x, sr, db, w, h, mask):
-    """Keep speech + short natural pauses; squeeze long dead air."""
-    segs = _segments(mask)
-    if not segs: return x
-    pad = int(0.06 * sr)
-    parts, prev_end = [], None
-    for s, e in segs:
-        a = max(0, s * h - pad); b = min(len(x), e * h + w + pad)
-        if prev_end is not None and a > prev_end:
-            gap = x[prev_end:a]
-            keep = int(0.30 * sr)
-            gap = gap if len(gap) <= keep else np.concatenate([gap[: keep // 2], gap[-keep // 2:]])
-            parts.append(_fade(gap, sr, 10, 10))
-        parts.append(x[max(a, prev_end or 0):b])
-        prev_end = b
-    return np.concatenate(parts).astype(np.float32)
-
-def _best_blocks(z, sr, target_sec, block_sec=6.0):
-    """Pick the cleanest ~target_sec of audio (blocks cut on low-energy frames)."""
-    if len(z) <= target_sec * sr: return z
-    db, w, h = frame_db(z, sr)
-    nfr = len(db)
-    per = int(block_sec * 100)                      # frames per block (10 ms hop)
-    cuts = sorted({0, nfr, *[_snap_low(db, i) for i in range(per, nfr - per // 2, per)]})
-    blocks = [(a, b) for a, b in zip(cuts[:-1], cuts[1:]) if b - a > 150]
-    if not blocks: return z[: int(target_sec * sr)]
-    scores = []
-    for a, b in blocks:
-        seg = db[a:b]; v = seg > max(np.percentile(seg, 10) + 10, np.percentile(seg, 95) - 28)
-        clip = float(np.mean(np.abs(z[a * h:b * h + w]) > 0.98))
-        snr = (seg[v].mean() - np.percentile(seg, 10)) if v.any() else 0.0
-        sd = float(seg[v].std()) if v.sum() > 3 else 12.0
-        scores.append(snr - 0.5 * sd - 300 * clip)
-    order = np.argsort(scores)[::-1]
-    chosen, tot = [], 0.0
-    for i in order:
-        a, b = blocks[i]; d = (b - a) / 100.0
-        if tot >= target_sec: break
-        chosen.append(i); tot += d
-    chosen.sort()
-    return np.concatenate([z[blocks[i][0] * h: blocks[i][1] * h + w] for i in chosen]).astype(np.float32)
-
 def _analyze(x_native_norm, fs_native, sr=REF_SR):
     """Diagnostics on a (peak-normalised) signal."""
     db, w, h = frame_db(x_native_norm, sr)
@@ -331,16 +285,57 @@ def _analyze(x_native_norm, fs_native, sr=REF_SR):
     return dict(noise_floor_db=round(noise, 1), snr_db=round(peak - noise, 1),
                 bandwidth_hz=int(min(rolloff, fs_native / 2)), native_sr=int(fs_native))
 
-def enhance_reference(path, strength=1.0, target_sec=24.0, denoise=True):
-    """→ (clean float32 @22050, report dict)."""
+def _stretches(mask, keep_gap=90):
+    """Group voiced segments separated by pauses ≤ 0.9 s into 'stretches', so natural
+    phrasing (sentence-to-sentence pauses) stays exactly as recorded."""
+    out = []
+    for s, e in _segments(mask):
+        s, e = int(s), int(e)
+        if out and s - out[-1][1] <= keep_gap: out[-1][1] = e
+        else: out.append([s, e])
+    return out
+
+def _split_stretch(db, s, e, max_frames):
+    """Cut an over-long stretch at its deepest-energy frames (= inside pauses).
+    Nothing is ever joined afterwards, so a cut can never become an audible splice."""
+    smooth = uniform_filter(db, size=7, mode="nearest")
+    cuts, pos = [], s
+    while e - pos > max_frames:
+        lo, hi = pos + int(0.55 * max_frames), pos + max_frames
+        c = lo + int(np.argmin(smooth[lo:hi]))
+        cuts.append((pos, c)); pos = c
+    cuts.append((pos, e))
+    return cuts
+
+def _score_window(x, db, w, h, a, b, mask):
+    seg, v = db[a:b], mask[a:b]
+    snr = float(seg[v].mean() - np.percentile(seg, 10)) if v.any() else 0.0
+    sd = float(seg[v].std()) if v.sum() > 3 else 12.0
+    clip = float(np.mean(np.abs(x[a * h: b * h + w]) > 0.98))
+    sp = float(v.sum() * 0.01)
+    return snr - 0.5 * sd - 300.0 * clip + 0.5 * min(sp, 20.0), sp
+
+def _finish_segment(x, sr):
+    """Level-match one CONTIGUOUS segment (voiced RMS → −20 dBFS) and fade its ends
+    inside the surrounding silence."""
+    z = x.astype(np.float32).copy()
+    db, w, h = frame_db(z, sr)
+    m = _voiced_mask(db)
+    vs = [z[s * h: e * h + w] for s, e in _segments(m)]
+    lvl = float(np.sqrt(np.mean(np.square(np.concatenate(vs)))) + 1e-9) if vs else float(np.sqrt(np.mean(z ** 2)) + 1e-9)
+    z = soft_limit(z * (10 ** (-20 / 20) / lvl), 0.95, 0.85)
+    return _fade(z, sr, 15, 45)
+
+def enhance_reference(path, strength=1.0, denoise=True, max_seg_sec=28.0, min_speech_sec=1.5):
+    """Clean one recording and return CONTIGUOUS candidate segments (no cutting-and-
+    pasting): → (candidates [{wav, speech, score}], report)."""
     raw, fs = load_mono(path)
     if len(raw) < 0.5 * REF_SR:
         raise ValueError("العينة قصيرة جداً (أقل من نصف ثانية).")
     dur_in = len(raw) / REF_SR
     clip_pct = float(np.mean(np.abs(raw) >= 0.995) * 100)
     raw = raw - float(np.mean(raw))
-    pk = float(np.max(np.abs(raw)) + 1e-9)
-    x = raw / pk * 0.7
+    x = raw / (float(np.max(np.abs(raw))) + 1e-9) * 0.7
     before = _analyze(x, fs)
 
     x = _highpass(x, REF_SR, 70)
@@ -348,21 +343,25 @@ def enhance_reference(path, strength=1.0, target_sec=24.0, denoise=True):
     if denoise and before["noise_floor_db"] > -62:
         s = float(np.clip((before["noise_floor_db"] + 62) / 20.0, 0.35, 1.0)) * strength
         x = spectral_denoise(x, REF_SR, s); did_denoise = True
+    after = _analyze(x, fs)
 
     db, w, h = frame_db(x, REF_SR)
     mask = _voiced_mask(db)
     speech_sec_all = float(mask.sum() * 0.01)
-    z = _compact_speech(x, REF_SR, db, w, h, mask) if mask.any() else x
-    z = _best_blocks(z, REF_SR, target_sec)
-
-    dbz, wz, hz = frame_db(z, REF_SR)
-    mz = _voiced_mask(dbz)
-    lvl = float(np.sqrt(np.mean(np.square(np.concatenate(
-        [z[s * hz:e * hz + wz] for s, e in _segments(mz)]) if mz.any() else z))) + 1e-9)
-    z = z * (10 ** (-20 / 20) / lvl)                       # voiced RMS → −20 dBFS
-    z = soft_limit(z, 0.95, 0.85)
-    z = _fade(z, REF_SR, 10, 30)
-    after = _analyze(z, fs)
+    cands = []
+    lead, tail = int(0.15 * REF_SR), int(0.30 * REF_SR)
+    for s, e in _stretches(mask):
+        for a, b in _split_stretch(db, s, e, int(max_seg_sec * 100)):
+            sc, sp = _score_window(x, db, w, h, a, b, mask)
+            if sp < min_speech_sec: continue
+            i0 = max(0, a * h - (lead if a == s else 0))
+            i1 = min(len(x), b * h + w + (tail if b == e else 0))
+            cands.append(dict(wav=_finish_segment(x[i0:i1], REF_SR), speech=sp, score=sc))
+    if not cands:                                    # no clear phrasing: keep one contiguous voiced span
+        idx = np.where(mask)[0]
+        i0, i1 = (max(0, idx[0] * h - lead), min(len(x), idx[-1] * h + w + tail)) if len(idx) else (0, len(x))
+        i1 = min(i1, i0 + int(max_seg_sec * REF_SR))
+        cands.append(dict(wav=_finish_segment(x[i0:i1], REF_SR), speech=speech_sec_all, score=0.0))
 
     warns, tips = [], []
     if speech_sec_all < 6:
@@ -375,18 +374,12 @@ def enhance_reference(path, strength=1.0, target_sec=24.0, denoise=True):
         warns.append(f"جودة ترددية منخفضة (حتى {before['bandwidth_hz']} Hz) — غالباً هاتف/ضغط شديد."); tips.append("استخدم WAV/FLAC أو تسجيلاً بجودة أعلى.")
     if before["native_sr"] < 16000:
         warns.append(f"معدل العينة الأصلي {before['native_sr']} Hz منخفض.")
-    score = 100.0
-    score -= max(0, 20 - before["snr_db"]) * 1.5
-    score -= min(30, clip_pct * 10)
-    score -= max(0, 6 - speech_sec_all) * 5
-    score -= 15 if before["bandwidth_hz"] < 6000 else 0
-    score = int(np.clip(score, 0, 100))
-
-    report = dict(duration_in=round(dur_in, 1), duration_out=round(len(z) / REF_SR, 1),
-                  speech_sec=round(speech_sec_all, 1), clipping_pct=round(clip_pct, 2),
-                  denoised=did_denoise, before=before, after=after,
-                  score=score, warnings=warns, tips=tips)
-    return z.astype(np.float32), report
+    score = 100.0 - max(0, 20 - before["snr_db"]) * 1.5 - min(30, clip_pct * 10) \
+            - max(0, 6 - speech_sec_all) * 5 - (15 if before["bandwidth_hz"] < 6000 else 0)
+    report = dict(duration_in=round(dur_in, 1), speech_sec=round(speech_sec_all, 1), clipping_pct=round(clip_pct, 2),
+                  denoised=did_denoise, before=before, after=after, score=int(np.clip(score, 0, 100)),
+                  warnings=warns, tips=tips, candidates=len(cands))
+    return cands, report
 
 def _file_sha(path):
     h = hashlib.sha1()
@@ -395,46 +388,52 @@ def _file_sha(path):
     return h.hexdigest()
 
 def enhance_reference_set(paths, cache_dir, strength=1.0, target_sec=24.0,
-                          max_total=30.0, denoise=True):
-    """Clean every file, merge best-first into ONE reference (XTTS only reads
-    the first `gpt_cond_len` s of the concatenation, so ordering matters).
-    → (merged_wav_path, [per-file reports], summary)."""
+                          max_segments=4, denoise=True):
+    """Clean the recordings and pick the best CONTIGUOUS segments (≤ max_segments, ≈target_sec
+    of speech in total).  Segments are written as SEPARATE files and never concatenated —
+    each one's conditioning latents are computed on their own and averaged by the caller.
+    → ([segment_wav_paths], [per-file reports], summary)."""
     os.makedirs(cache_dir, exist_ok=True)
     key = hashlib.sha1(("|".join(_file_sha(p) for p in paths) +
-                        f"|{strength}|{target_sec}|{max_total}|{denoise}|{VQ_VERSION}").encode()).hexdigest()[:20]
-    out, meta = os.path.join(cache_dir, f"ref_{key}.wav"), os.path.join(cache_dir, f"ref_{key}.json")
-    if os.path.exists(out) and os.path.exists(meta):
+                        f"|{strength}|{target_sec}|{max_segments}|{denoise}|{VQ_VERSION}").encode()).hexdigest()[:20]
+    meta = os.path.join(cache_dir, f"ref_{key}.json")
+    if os.path.exists(meta):
         d = json.load(open(meta, encoding="utf-8"))
-        return out, d["reports"], d["summary"]
+        if d["paths"] and all(os.path.exists(p) for p in d["paths"]):
+            return d["paths"], d["reports"], d["summary"]
 
-    per = target_sec if len(paths) == 1 else max(8.0, target_sec / len(paths) * 1.25)
-    items = []
-    for p in paths:
+    pool, reports = [], []
+    for fi, p in enumerate(paths):
         try:
-            z, rep = enhance_reference(p, strength, per, denoise)
+            cands, rep = enhance_reference(p, strength, denoise)
             rep["file"] = os.path.basename(p)[-40:]
-            items.append((z, rep))
+            reports.append(rep)
+            for c in cands: c["fscore"] = rep["score"]; pool.append(c)
         except Exception as e:
-            items.append((None, dict(file=os.path.basename(p)[-40:], error=str(e), score=0,
-                                     warnings=[f"تعذّرت معالجة الملف: {e}"], tips=[])))
-    good = [(z, r) for z, r in items if z is not None]
-    if not good:
-        raise ValueError("تعذّرت معالجة كل ملفات العينة: " + "; ".join(r.get("error", "?") for _, r in items))
-    good.sort(key=lambda t: t[1]["score"], reverse=True)
-    gap = np.zeros(int(0.25 * REF_SR), np.float32)
-    merged = np.concatenate([np.concatenate([z, gap]) for z, _ in good])[: int(max_total * REF_SR)]
-    sf.write(out, merged, REF_SR, subtype="PCM_16")
-    reports = [r for _, r in items]
-    best = good[0][1]
-    summary = dict(score=int(np.mean([r["score"] for _, r in good])),
-                   duration=round(len(merged) / REF_SR, 1),
-                   files=len(paths), used=len(good),
-                   warnings=[w for _, r in good for w in r["warnings"]][:6],
-                   tips=list(dict.fromkeys(t for _, r in good for t in r["tips"]))[:4],
+            reports.append(dict(file=os.path.basename(p)[-40:], error=str(e), score=0,
+                                warnings=[f"تعذّرت معالجة الملف: {e}"], tips=[]))
+    if not pool:
+        raise ValueError("تعذّرت معالجة كل ملفات العينة: " + "; ".join(r.get("error", "?") for r in reports))
+    chosen, total = [], 0.0
+    for c in sorted(pool, key=lambda c: c["score"] + 0.1 * c["fscore"], reverse=True):
+        if len(chosen) >= max_segments or total >= target_sec: break
+        chosen.append(c); total += c["speech"]
+
+    out_paths = []
+    for i, c in enumerate(chosen):
+        op = os.path.join(cache_dir, f"ref_{key}_{i}.wav")
+        sf.write(op, c["wav"], REF_SR, subtype="PCM_16"); out_paths.append(op)
+    good = [r for r in reports if "error" not in r]
+    best = max(good, key=lambda r: r["score"])
+    summary = dict(score=int(np.mean([r["score"] for r in good])),
+                   duration=round(sum(len(c["wav"]) for c in chosen) / REF_SR, 1),
+                   speech=round(total, 1), segments=len(chosen), files=len(paths), used=len(good),
+                   warnings=[w for r in good for w in r["warnings"]][:6],
+                   tips=list(dict.fromkeys(t for r in good for t in r["tips"]))[:4],
                    snr_before=best["before"]["snr_db"], snr_after=best["after"]["snr_db"],
-                   denoised=any(r["denoised"] for _, r in good))
-    json.dump(dict(reports=reports, summary=summary), open(meta, "w", encoding="utf-8"), ensure_ascii=False)
-    return out, reports, summary
+                   denoised=any(r["denoised"] for r in good))
+    json.dump(dict(paths=out_paths, reports=reports, summary=summary), open(meta, "w", encoding="utf-8"), ensure_ascii=False)
+    return out_paths, reports, summary
 
 # ═══════════════════════════════════════════════════════════════════════
 #  2. TEXT NORMALISATION
@@ -541,36 +540,53 @@ def text_similarity(a, b):
     if not a or not b: return 0.0
     return difflib.SequenceMatcher(None, a, b, autojunk=False).ratio()
 
-def take_info(wav, sr, text, asr_fn=None):
+CPS_RANGE = {"zh": (1.5, 14.0), "ja": (2.0, 16.0), "ko": (3.0, 20.0)}   # chars/sec sanity bounds
+
+def take_info(wav, sr, text, asr_fn=None, lang="ar"):
     dur = len(wav) / sr
     peak = float(np.max(np.abs(wav))) if len(wav) else 0.0
     cps = len(norm_for_compare(text)) / max(dur, 1e-3)
+    lo, hi = CPS_RANGE.get(lang.split("-")[0], (4.0, 28.0))
     sim = None
     if asr_fn is not None and dur > 0.2:
         try: sim = text_similarity(text, asr_fn(wav, sr))
         except Exception: sim = None
-    ok = peak > 0.02 and 4.0 <= cps <= 28.0
-    return dict(dur=dur, cps=cps, peak=peak, sim=sim, ok=ok,
+    ok = peak > 0.02 and lo <= cps <= hi
+    return dict(dur=dur, cps=cps, peak=peak, sim=sim, ok=ok, secs=None,
                 clip=float(np.mean(np.abs(wav) > 0.99)) if len(wav) else 0.0)
 
-def synth_best(gen_fn, text, attempts=1, asr_fn=None, sr=XTTS_SR, seed=1234, accept_sim=0.90):
-    """gen_fn(seed:int) → float32 wav.  Returns (wav, info, n_generated)."""
-    takes = []
-    for k in range(max(1, attempts)):
+def _take_score(i, med):
+    s = (i["sim"] * 100.0) if i["sim"] is not None else 60.0
+    if i.get("secs") is not None:
+        s += 80.0 * (i["secs"] - 0.6)                    # speaker-identity consistency
+    s -= 25.0 * abs(math.log(max(i["dur"], 1e-3) / max(med, 1e-3)))
+    s -= 300.0 * i["clip"]
+    s -= 0.0 if i["ok"] else 30.0
+    return s
+
+def synth_best(gen_fn, text, attempts=1, asr_fn=None, sr=XTTS_SR, seed=1234,
+               accept_sim=0.90, secs_fn=None, lang="ar", guard_retries=2):
+    """gen_fn(seed:int) → float32 wav.  Returns (wav, info, n_generated).
+    attempts==1 : cheap self-healing guard — regenerate (≤ guard_retries) only if the
+                  take is obviously broken (silent / absurd speech-rate / clipped).
+    attempts>1  : best-of-N ranked by ASR similarity + speaker similarity + duration."""
+    multi = attempts > 1
+    takes, k = [], 0
+    while True:
         wav = trim_take(gen_fn(seed + 7919 * k), sr)
-        info = take_info(wav, sr, text, asr_fn)
-        takes.append((wav, info))
-        if attempts > 1 and info["ok"] and info["sim"] is not None and info["sim"] >= accept_sim:
-            break
+        info = take_info(wav, sr, text, asr_fn if multi else None, lang)
+        if multi and secs_fn is not None and len(wav) > int(0.3 * sr):
+            try: info["secs"] = float(secs_fn(wav, sr))
+            except Exception: info["secs"] = None
+        takes.append((wav, info)); k += 1
+        if multi:
+            if k >= attempts: break
+            if info["ok"] and info["sim"] is not None and info["sim"] >= accept_sim: break
+        else:
+            if (info["ok"] and info["clip"] < 0.005) or k > guard_retries: break
     if len(takes) == 1: return takes[0][0], takes[0][1], 1
     med = float(np.median([i["dur"] for _, i in takes]))
-    def score(i):
-        s = (i["sim"] * 100.0) if i["sim"] is not None else 60.0
-        s -= 25.0 * abs(math.log(max(i["dur"], 1e-3) / max(med, 1e-3)))
-        s -= 300.0 * i["clip"]
-        s -= 0 if i["ok"] else 30.0
-        return s
-    best = max(takes, key=lambda t: score(t[1]))
+    best = max(takes, key=lambda t: _take_score(t[1], med))
     return best[0], best[1], len(takes)
 
 # ═══════════════════════════════════════════════════════════════════════
@@ -772,16 +788,38 @@ try:
 except ImportError:
     HUB_AVAILABLE = False
 
+_backup_lock  = threading.Lock()
+_backup_state = {"running": False, "pending": False, "last": 0.0}
+BACKUP_MIN_INTERVAL = 90          # seconds between uploads
+
 def trigger_cloud_backup():
+    """Single-flight + coalesced + rate-limited.  (Previously every save/delete spawned
+    its own thread uploading the whole data folder, so uploads could pile up.)"""
     if not (HUB_AVAILABLE and HF_TOKEN and DATASET_REPO_ID): return
+    with _backup_lock:
+        if _backup_state["running"]:
+            _backup_state["pending"] = True
+            return
+        _backup_state["running"] = True
     def _run():
-        try:
-            HfApi(token=HF_TOKEN).upload_folder(
-                folder_path=PERSISTENT_DIR, repo_id=DATASET_REPO_ID,
-                repo_type="dataset", commit_message=f"Auto-backup: {int(time.time())}")
-        except Exception as e:
-            print(f"[!] Cloud backup failed: {e}")
-    threading.Thread(target=_run).start()
+        while True:
+            wait = BACKUP_MIN_INTERVAL - (time.time() - _backup_state["last"])
+            if wait > 0: time.sleep(wait)
+            try:
+                HfApi(token=HF_TOKEN).upload_folder(
+                    folder_path=PERSISTENT_DIR, repo_id=DATASET_REPO_ID, repo_type="dataset",
+                    commit_message=f"Auto-backup: {int(time.time())}",
+                    ignore_patterns=["*.tmp", "*.corrupt", ".cache/*"])
+            except Exception as e:
+                print(f"[!] Cloud backup failed: {e}", flush=True)
+            with _backup_lock:
+                _backup_state["last"] = time.time()
+                if _backup_state["pending"]:
+                    _backup_state["pending"] = False
+                    continue
+                _backup_state["running"] = False
+                return
+    threading.Thread(target=_run, daemon=True, name="cloud-backup").start()
 
 # ── XTTS Model ────────────────��───────────────────────────────────────
 from TTS.api import TTS
@@ -877,19 +915,29 @@ except Exception:
     TRANSLATOR_OK = False
 
 # ── History helpers ───────────────────────────────────────────────────
+_history_lock = threading.RLock()
+MAX_HISTORY = 300
+MAX_OUTPUTS = 200
+
 def load_history():
-    try:
-        return json.load(open(HISTORY_FILE)) if os.path.exists(HISTORY_FILE) else []
-    except Exception:
-        return []
+    with _history_lock:
+        try:
+            if not os.path.exists(HISTORY_FILE): return []
+            with open(HISTORY_FILE, encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            try: shutil.copyfile(HISTORY_FILE, HISTORY_FILE + ".corrupt")   # keep it, don't silently overwrite
+            except Exception: pass
+            return []
 
 def save_history(h):
-    json.dump(h, open(HISTORY_FILE, "w"), ensure_ascii=False, indent=2)
+    with _history_lock:                                  # atomic: write temp → replace
+        tmp = HISTORY_FILE + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(h, f, ensure_ascii=False, indent=2)
+        os.replace(tmp, HISTORY_FILE)
     trigger_cloud_backup()
 
-MAX_HISTORY = 300
-MAX_OUTPUTS = 200
-
 def _prune_outputs():
     try:
         wavs = sorted(
@@ -898,17 +946,18 @@ def _prune_outputs():
         )
         for old in wavs[:-MAX_OUTPUTS]:
             try: os.remove(os.path.join(OUTPUT_DIR, old))
-            except: pass
+            except Exception: pass
     except Exception:
         pass
 
 def append_history(filename, text, language, mode, char_count=0):
-    h = load_history()
-    h.append(dict(filename=filename, text=text[:150], language=language,
-                  mode=mode, char_count=char_count, ts=int(time.time())))
-    if len(h) > MAX_HISTORY:
-        h = h[-MAX_HISTORY:]
-    save_history(h)
+    with _history_lock:                                  # read-modify-write must be one unit
+        h = load_history()
+        h.append(dict(filename=filename, text=text[:150], language=language,
+                      mode=mode, char_count=char_count, ts=int(time.time())))
+        if len(h) > MAX_HISTORY:
+            h = h[-MAX_HISTORY:]
+        save_history(h)
     _prune_outputs()
 
 # ── Parameter Engineering ─────────────────────────────────────────────
@@ -1702,24 +1751,39 @@ def prepare_refs(refs, enhance=True):
     if not enhance:
         return list(refs), None
     try:
-        path, _reports, summary = vq.enhance_reference_set(refs, REF_CACHE_DIR)
-        return [path], summary
+        paths, _reports, summary = vq.enhance_reference_set(refs, REF_CACHE_DIR)
+        return list(paths), summary
     except Exception as e:
         print(f"[!] Reference enhancement failed — using the raw sample: {e}", flush=True)
         return list(refs), None
 
 def get_latents(model, ref_paths):
+    """Conditioning latents for one or several reference files.
+    With several files each one is encoded ON ITS OWN and the results are averaged
+    (duration-weighted).  XTTS' own multi-file path glues the waveforms together with
+    torch.cat before encoding — an audible splice that the model then imitates."""
     key = tuple((p, os.path.getsize(p), int(os.path.getmtime(p))) for p in ref_paths)
     if key in _LAT_CACHE:
         _LAT_CACHE.move_to_end(key)
         return _LAT_CACHE[key]
     c = model.config
-    lat = model.get_conditioning_latents(
-        audio_path=list(ref_paths),
-        gpt_cond_len=int(getattr(c, "gpt_cond_len", 30)),
-        gpt_cond_chunk_len=int(getattr(c, "gpt_cond_chunk_len", 4)),
-        max_ref_length=int(getattr(c, "max_ref_len", 30)),
-        sound_norm_refs=bool(getattr(c, "sound_norm_refs", False)))
+    kw = dict(gpt_cond_len=int(getattr(c, "gpt_cond_len", 30)),
+              gpt_cond_chunk_len=int(getattr(c, "gpt_cond_chunk_len", 4)),
+              max_ref_length=int(getattr(c, "max_ref_len", 30)),
+              sound_norm_refs=bool(getattr(c, "sound_norm_refs", False)))
+    paths = list(ref_paths)
+    if len(paths) == 1:
+        lat = model.get_conditioning_latents(audio_path=paths, **kw)
+    else:
+        parts, weights = [], []
+        for p in paths:
+            parts.append(model.get_conditioning_latents(audio_path=[p], **kw))
+            try:    dur = float(sf.info(p).duration)
+            except Exception: dur = float(kw["gpt_cond_len"])
+            weights.append(max(0.5, min(dur, float(kw["gpt_cond_len"]))))
+        wsum = sum(weights)
+        lat = (sum(w * g for w, (g, _) in zip(weights, parts)) / wsum,
+               sum(w * s for w, (_, s) in zip(weights, parts)) / wsum)
     _LAT_CACHE[key] = lat
     while len(_LAT_CACHE) > 6:
         _LAT_CACHE.popitem(last=False)
@@ -1774,10 +1838,63 @@ def _asr_for_scoring(lang):
         return " ".join(s.text for s in segs)
     return fn
 
+DRY_CACHE_DIR = os.path.join(tempfile.gettempdir(), "vs_drycache")
+os.makedirs(DRY_CACHE_DIR, exist_ok=True)
+os.makedirs(REF_CACHE_DIR, exist_ok=True)
+RECENT_JOBS = collections.deque(maxlen=20)
+
+def _prune_dir(path, max_files, max_bytes):
+    try:
+        fs = [os.path.join(path, f) for f in os.listdir(path)]
+        fs = sorted((f for f in fs if os.path.isfile(f)), key=os.path.getmtime)
+        total = sum(os.path.getsize(f) for f in fs)
+        while fs and (len(fs) > max_files or total > max_bytes):
+            f = fs.pop(0); total -= os.path.getsize(f); os.remove(f)
+    except Exception:
+        pass
+
+_prune_dir(REF_CACHE_DIR, 40, 300 << 20)
+_prune_dir(DRY_CACHE_DIR, 60, 400 << 20)
+
+def _dry_cache_key(txt, lang, ref_paths, base_params, silence_ms, variation, attempts, asr_on):
+    """Everything that changes the synthesised (dry) audio.  Depth / boost are post-FX
+    and deliberately NOT part of the key → changing them re-renders instantly."""
+    payload = dict(v=vq.VQ_VERSION + "/dry2", t=txt, l=lang, r=[vq._file_sha(p) for p in ref_paths],
+                   p={k: round(float(v), 4) for k, v in base_params.items() if isinstance(v, (int, float))},
+                   s=int(silence_ms), var=round(float(variation), 3), a=int(attempts), asr=bool(asr_on))
+    return hashlib.sha1(json.dumps(payload, sort_keys=True, ensure_ascii=False).encode()).hexdigest()[:24]
+
+def _record_job(stats_out, job_id, **kw):
+    rec = dict(job=str(job_id)[:8], ts=int(time.time()), **kw)
+    if rec.get("audio_sec") and rec.get("wall") is not None:
+        rec["rtf"] = round(rec["wall"] / rec["audio_sec"], 2)
+    for k in ("wall", "audio_sec"):
+        if k in rec: rec[k] = round(float(rec[k]), 1)
+    RECENT_JOBS.append(rec)
+    if stats_out is not None: stats_out.update(rec)
+    print(f"[job {rec['job']}] " + ", ".join(f"{k}={v}" for k, v in rec.items() if k not in ("job", "ts")), flush=True)
+
+def _secs_fn(model, ref_spk):
+    """Cosine similarity between a take and the reference, using XTTS's own speaker encoder."""
+    ref = ref_spk.detach().flatten().float().cpu()
+    warned = []
+    def fn(wav, sr):
+        try:
+            with torch.inference_mode():
+                e = model.get_speaker_embedding(torch.from_numpy(np.ascontiguousarray(wav, dtype=np.float32))[None, :], sr)
+            return float(torch.nn.functional.cosine_similarity(e.detach().flatten().float().cpu(), ref, dim=0))
+        except Exception as ex:
+            if not warned:                                   # log once, never spam
+                warned.append(1)
+                print(f"[!] speaker-similarity scoring unavailable ({type(ex).__name__}: {ex}) — ranking without it.", flush=True)
+            raise
+    return fn
+
 def run_tts_chunked(text, refs, lang, base_params, out_path, job_id,
                     silence_ms: int = 110, variation: float = 0.0,
                     attempts: int = 1, enhance_ref: bool = True,
-                    clean_text: bool = True, ref_summary_out: dict = None) -> bool:
+                    clean_text: bool = True, ref_summary_out: dict = None,
+                    stats_out: dict = None) -> bool:
     """Quality pipeline. Falls back to the legacy pipeline if anything unexpected
     goes wrong, so a bug here can never block generation."""
     model = _tts_model()
@@ -1785,30 +1902,47 @@ def run_tts_chunked(text, refs, lang, base_params, out_path, job_id,
         return _run_tts_chunked_legacy(text, refs, lang, base_params, out_path, job_id, silence_ms, variation)
     try:
         return _run_tts_quality(model, text, refs, lang, base_params, out_path, job_id,
-                                silence_ms, variation, attempts, enhance_ref, clean_text, ref_summary_out)
+                                silence_ms, variation, attempts, enhance_ref, clean_text, ref_summary_out, stats_out)
     except Exception:
         print("[!] Quality pipeline failed — falling back to legacy pipeline:", flush=True)
         traceback.print_exc()
         return _run_tts_chunked_legacy(text, refs, lang, base_params, out_path, job_id, silence_ms, variation)
 
 def _run_tts_quality(model, text, refs, lang, base_params, out_path, job_id,
-                     silence_ms, variation, attempts, enhance_ref, clean_text, ref_summary_out):
+                     silence_ms, variation, attempts, enhance_ref, clean_text, ref_summary_out, stats_out=None):
     cancel_ev = cancel_events.get(job_id)
     job_progress[job_id] = {"current": 0, "total": 1, "status": "running"}
+    t_start = time.time()
     ref_paths, summary = prepare_refs(refs, enhance_ref)
     if summary and ref_summary_out is not None:
         ref_summary_out.update(summary)
-    lat_gpt, lat_spk = get_latents(model, ref_paths)
 
-    txt    = vq.normalize_text(text, lang) if clean_text else text.strip()
+    txt      = vq.normalize_text(text, lang) if clean_text else text.strip()
+    attempts = int(np.clip(attempts, 1, 4))
+    asr      = _asr_for_scoring(lang) if attempts > 1 else None
+    cache_path = os.path.join(DRY_CACHE_DIR, _dry_cache_key(
+        txt, lang, ref_paths, base_params, silence_ms, variation, attempts, asr is not None) + ".wav")
+    if os.path.exists(cache_path):                      # identical request → skip synthesis entirely
+        shutil.copyfile(cache_path, out_path)
+        try: os.utime(cache_path, None)
+        except Exception: pass
+        job_progress[job_id] = {"current": 1, "total": 1, "status": "done", "ts": time.time()}
+        _record_job(stats_out, job_id, cached=True, audio_sec=sf.info(out_path).duration,
+                    wall=time.time() - t_start)
+        return True
+    lat_gpt, lat_spk = get_latents(model, ref_paths)
     limits = getattr(getattr(model, "tokenizer", None), "char_limits", None)
     chunks = vq.split_for_xtts(txt, lang, limits)
     total  = len(chunks)
     job_progress[job_id] = {"current": 0, "total": total, "status": "running"}
 
     d        = _model_defaults(model)
-    attempts = int(np.clip(attempts, 1, 4))
-    asr      = _asr_for_scoring(lang) if attempts > 1 else None
+    try:
+        secs_fn = _secs_fn(model, lat_spk) if attempts > 1 else None
+    except Exception as ex:                      # scoring is a bonus — never block generation
+        print(f"[!] speaker-similarity scoring disabled: {ex}", flush=True)
+        secs_fn = None
+    retries  = 0
     use_var  = variation > 0.02
     emotions = [analyze_phrase_emotion(c, lang) for c, _ in chunks] if use_var else [("neutral", 0.0)] * total
     seed0    = zlib.crc32(txt.encode("utf-8")) & 0x7FFFFFFF
@@ -1830,7 +1964,9 @@ def _run_tts_quality(model, text, refs, lang, base_params, out_path, job_id,
             out = model.inference(chunk, lang, lat_gpt, lat_spk, enable_text_splitting=False, **kw)
             return np.asarray(out["wav"], np.float32).reshape(-1)
 
-        wav, _info, _n = vq.synth_best(gen, chunk, attempts, asr, vq.XTTS_SR, seed0 + 101 * i)
+        wav, _info, _n = vq.synth_best(gen, chunk, attempts, asr, vq.XTTS_SR, seed0 + 101 * i,
+                                       secs_fn=secs_fn, lang=lang)
+        retries += _n - 1
         wav = _residual_stretch(wav, resid)
         if use_var and emo != "neutral":
             wav = apply_phrase_dynamics(wav, vq.XTTS_SR, emo, variation * 0.5)
@@ -1841,8 +1977,15 @@ def _run_tts_quality(model, text, refs, lang, base_params, out_path, job_id,
 
     audio = vq.finalize_audio(vq.assemble(takes, pauses, vq.XTTS_SR, 1.0, seed0), vq.XTTS_SR)
     sf.write(out_path, audio, vq.XTTS_SR, subtype="PCM_16")
+    try:
+        shutil.copyfile(out_path, cache_path)
+        _prune_dir(DRY_CACHE_DIR, 60, 400 << 20)
+    except Exception:
+        pass
     job_progress[job_id]["status"] = "done"
     job_progress[job_id]["ts"]     = time.time()
+    _record_job(stats_out, job_id, cached=False, chunks=total, attempts=attempts, extra_takes=retries,
+                audio_sec=len(audio) / vq.XTTS_SR, wall=time.time() - t_start)
     return True
 
 def apply_depth(path, amount=0.5, space="studio"):
@@ -1859,18 +2002,74 @@ def apply_depth(path, amount=0.5, space="studio"):
         print("[!] depth processing failed — file left dry:", flush=True)
         traceback.print_exc()
 
+MAX_UPLOAD_BYTES  = 30 * 1024 * 1024          # per file
+MAX_REQUEST_BYTES = 130 * 1024 * 1024         # per request (Content-Length)
+MAX_REF_FILES     = 4
+_AUDIO_EXT        = (".wav", ".mp3", ".flac", ".ogg", ".m4a", ".opus", ".webm", ".aac")
+
+def _copy_limited(fobj, dest, limit=MAX_UPLOAD_BYTES):
+    """Copy an upload to disk, refusing anything above `limit` bytes."""
+    size = 0
+    try:
+        with open(dest, "wb") as out:
+            while True:
+                chunk = fobj.read(1 << 20)
+                if not chunk: break
+                size += len(chunk)
+                if size > limit:
+                    raise HTTPException(413, f"الملف أكبر من {limit >> 20} MB.")
+                out.write(chunk)
+    except Exception:
+        try: os.remove(dest)
+        except Exception: pass
+        raise
+
+_VOICE_NAME_RE = re.compile(r"[^\w\- ]", re.UNICODE)
+def safe_voice_name(name) -> str:
+    return _VOICE_NAME_RE.sub("_", (name or "").strip()).strip(" ._")[:40]
+
+def voice_dir(name, must_exist=False) -> str:
+    """Resolve a voice-library folder, guaranteed to live directly inside VOICE_LIB
+    (blocks '..', absolute paths and separators).  Names saved by older versions
+    are still found via an exact-name lookup."""
+    lib = os.path.realpath(VOICE_LIB)
+    raw = (name or "").strip()
+    found = None
+    for cand in dict.fromkeys([raw, safe_voice_name(raw)]):
+        if not cand or cand in (".", "..") or any(c in cand for c in "/\\\x00"):
+            continue
+        p = os.path.realpath(os.path.join(lib, cand))
+        if os.path.dirname(p) != lib:
+            continue
+        if os.path.isdir(p): return p
+        found = found or p
+    if found is None: raise HTTPException(400, "اسم الصوت غير صالح.")
+    if must_exist: raise HTTPException(404, "صوت غير موجود.")
+    return found
+
+def _output_path(filename: str) -> str:
+    safe = os.path.basename(filename or "")
+    if not safe or safe != filename or ".." in safe:
+        raise HTTPException(400, "اسم ملف غير صالح.")
+    return os.path.join(OUTPUT_DIR, safe)
+
 def collect_refs(files, voice_name):
     paths = []
-    for f in files:
-        if not f or not getattr(f, "filename", None): continue
-        p = f"/tmp/ref_{uuid.uuid4().hex}_{f.filename}"
-        with open(p, "wb") as buf: shutil.copyfileobj(f.file, buf)
-        paths.append(p)
-    if voice_name and voice_name not in ("", "null", "none", "undefined"):
-        lib_dir = os.path.join(VOICE_LIB, voice_name)
-        if os.path.isdir(lib_dir):
-            paths += [os.path.join(lib_dir, fn) for fn in sorted(os.listdir(lib_dir))
-                      if fn.lower().endswith((".wav", ".mp3", ".flac", ".ogg"))]
+    try:
+        for f in files:
+            if not f or not getattr(f, "filename", None): continue
+            if len(paths) >= MAX_REF_FILES: break
+            base = re.sub(r"[^\w.\-]", "_", os.path.basename(f.filename), flags=re.UNICODE)[-60:] or "ref.wav"
+            p = f"/tmp/ref_{uuid.uuid4().hex}_{base}"
+            _copy_limited(f.file, p)
+            paths.append(p)
+        if voice_name and voice_name not in ("", "null", "none", "undefined"):
+            lib_dir = voice_dir(voice_name)
+            if os.path.isdir(lib_dir):
+                paths += [os.path.join(lib_dir, fn) for fn in sorted(os.listdir(lib_dir))
+                          if fn.lower().endswith(_AUDIO_EXT)]
+    except Exception:
+        cleanup(paths); raise
     return paths
 
 def cleanup(paths):
@@ -1883,6 +2082,19 @@ def cleanup(paths):
 app = FastAPI(title="XTTS Voice Studio CPU Optimized")
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
+@app.middleware("http")
+async def _limit_request_size(request, call_next):
+    cl = request.headers.get("content-length", "")
+    if request.method in ("POST", "PUT") and cl.isdigit() and int(cl) > MAX_REQUEST_BYTES:
+        return JSONResponse({"detail": f"الطلب أكبر من {MAX_REQUEST_BYTES >> 20} MB."}, status_code=413)
+    return await call_next(request)
+
+@app.exception_handler(Exception)
+async def _unhandled_error(request, exc):
+    print(f"[!] Unhandled error on {request.method} {request.url.path}:", flush=True)
+    traceback.print_exception(type(exc), exc, exc.__traceback__)
+    return JSONResponse({"detail": f"خطأ داخلي ({type(exc).__name__}). راجع سجلات الخادم."}, status_code=500)
+
 LANGUAGES = {
     "ar":"العربية","en":"English","es":"Español","fr":"Français",
     "de":"Deutsch","it":"Italiano","pt":"Português","ru":"Русский",
@@ -3141,6 +3353,7 @@ function GenerateTab({ voices, onVoicesRefresh, sharedSettings }) {
       if (!data) return; // cancelled
       setResult({url:`/audio/${data.filename}`,filename:data.filename});
       toast("success","✅ تم توليد الصوت بنجاح");
+      if(data.cached) toast("info","⚡ أُعيدت المعالجة النهائية فقط من الذاكرة المؤقتة (لم يُعاد توليد الصوت).",5000);
       const rr=data.ref_report;
       if(rr&&(rr.score<70||(rr.warnings||[]).length))
         toast("info",`جودة العينة ${rr.score}/100 — ${(rr.warnings||[])[0]||"جرّب عينة أنقى"}`,8000);
@@ -3191,7 +3404,7 @@ function GenerateTab({ voices, onVoicesRefresh, sharedSettings }) {
               </button>
               {refCheck&&refCheck.report&&(
                 <div className="col" style={{gap:6}}>
-                  <div className="fz-12"><b>جودة العينة: {refCheck.report.score}/100</b> · المدة بعد التنقية {refCheck.report.duration}ث · SNR {refCheck.report.snr_before}→{refCheck.report.snr_after} dB{refCheck.report.denoised?" · تم تقليل الضجيج":""}</div>
+                  <div className="fz-12"><b>جودة العينة: {refCheck.report.score}/100</b> · المدة بعد التنقية {refCheck.report.duration}ث{refCheck.segments>1?" ("+refCheck.segments+" مقاطع متجاورة، المعروض أفضلها)":""} · SNR {refCheck.report.snr_before}→{refCheck.report.snr_after} dB{refCheck.report.denoised?" · تم تقليل الضجيج":""}</div>
                   {(refCheck.report.warnings||[]).map((w,i)=><div key={"w"+i} className="fz-12" style={{color:"#f59e0b"}}>⚠ {w}</div>)}
                   {(refCheck.report.tips||[]).map((w,i)=><div key={"t"+i} className="fz-12 text-muted">💡 {w}</div>)}
                   <audio controls src={refCheck.url} style={{width:"100%"}}/>
@@ -3820,8 +4033,41 @@ def model_status():
         "ready":   xtts_ready,
         "error":   xtts_error,
         "device":  device,
+        "whisper": bool(WHISPER_OK),
+        "zerogpu": bool(ZEROGPU),
     })
 
+_STARTED_AT = time.time()
+
+@app.get("/health")
+def health():
+    """Always HTTP 200 (so health checks never restart a model that is still loading)."""
+    return {"status": "ok" if xtts_ready else ("loading" if xtts_loading else "error"),
+            "model_ready": bool(xtts_ready), "whisper_ready": bool(WHISPER_OK),
+            "busy": get_tts_lock().locked(), "uptime_s": int(time.time() - _STARTED_AT)}
+
+@app.get("/diagnostics")
+def diagnostics():
+    import importlib.metadata as md
+    def ver(n):
+        try: return md.version(n)
+        except Exception: return "n/a"
+    def folder(d):
+        try:
+            fs = [os.path.join(d, f) for f in os.listdir(d)]
+            return {"files": len(fs), "mb": round(sum(os.path.getsize(f) for f in fs if os.path.isfile(f)) / 1e6, 1)}
+        except Exception:
+            return None
+    return {
+        "versions": {k: ver(k) for k in ("torch", "coqui-tts", "transformers", "faster-whisper", "numpy", "spaces")},
+        "device": device, "zerogpu": bool(ZEROGPU), "cpu_threads": CPU_THREADS,
+        "model_ready": bool(xtts_ready), "model_error": xtts_error, "whisper_ready": bool(WHISPER_OK),
+        "caches": {"reference": folder(REF_CACHE_DIR), "dry_audio": folder(DRY_CACHE_DIR), "outputs": folder(OUTPUT_DIR)},
+        "latent_cache_entries": len(_LAT_CACHE),
+        "engine": "voice-quality v" + vq.VQ_VERSION,
+        "recent_jobs": list(RECENT_JOBS),
+    }
+
 # ── Job control endpoints ─────────────────────────────────────────────
 @app.get("/progress/{job_id}")
 def get_progress(job_id: str):
@@ -3851,7 +4097,7 @@ async def edit_audio(
 ):
     """Edit a generated audio file without re-running TTS.
     Always writes a NEW file — the original is never modified."""
-    src = os.path.join(OUTPUT_DIR, filename)
+    src = _output_path(filename)
     if not os.path.exists(src):
         raise HTTPException(404, "الملف غير موجود.")
 
@@ -3935,7 +4181,7 @@ async def humanize_endpoint(
 ):
     """Apply acoustic environment simulation to a generated WAV.
     Returns a brand-new file — original untouched."""
-    src = os.path.join(OUTPUT_DIR, filename)
+    src = _output_path(filename)
     if not os.path.exists(src):
         raise HTTPException(404, "الملف غير موجود.")
     if preset not in HUMANIZE_PRESETS:
@@ -3981,6 +4227,7 @@ async def generate(
     if not xtts_ready: raise HTTPException(503, f"❌ فشل تحميل النموذج: {xtts_error}")
     if not text.strip():      raise HTTPException(400, "النص فارغ.")
     if len(text) > MAX_CHARS: raise HTTPException(400, f"النص يتجاوز {MAX_CHARS} حرف.")
+    if language not in LANGUAGES: raise HTTPException(400, f"لغة غير مدعومة: {language}")
     if not job_id:
         job_id = uuid.uuid4().hex
 
@@ -4000,13 +4247,13 @@ async def generate(
     cancel_events[job_id] = threading.Event()
     silence_ms = {"story":160,"sad":180,"news":80,"excited":70}.get(expression_mode, 110)
     variation  = float(np.clip(variation_strength, 0.0, 2.0))
-    ref_summary = {}
+    ref_summary, job_stats = {}, {}
     try:
         async with get_tts_lock():
             success = await asyncio.to_thread(
                 run_tts_chunked, enhanced_text, refs, language,
                 tts_params, out, job_id, silence_ms, variation,
-                attempts, enhance_ref, clean_text, ref_summary
+                attempts, enhance_ref, clean_text, ref_summary, job_stats
             )
         if not success:
             if os.path.exists(out): os.remove(out)
@@ -4019,7 +4266,8 @@ async def generate(
         cancel_events.pop(job_id, None)
 
     append_history(os.path.basename(out), text, language, "tts", len(text))
-    return {"filename": os.path.basename(out), "ref_report": ref_summary or None}
+    return {"filename": os.path.basename(out), "ref_report": ref_summary or None,
+            "cached": bool(job_stats.get("cached")), "stats": job_stats or None}
 
 
 # ── Reference check: clean the sample and let the user LISTEN to it ───
@@ -4031,10 +4279,11 @@ async def enhance_ref_endpoint(
     refs = collect_refs(files, voice_name)
     if not refs: raise HTTPException(400, "حدد عينة صوتية أولاً.")
     try:
-        path, _reports, summary = await asyncio.to_thread(vq.enhance_reference_set, refs, REF_CACHE_DIR)
-        fn = "refclean_" + os.path.basename(path)[4:-4] + ".wav"
-        shutil.copyfile(path, os.path.join(OUTPUT_DIR, fn))
-        return {"url": f"/audio/{fn}", "report": summary}
+        paths, _reports, summary = await asyncio.to_thread(vq.enhance_reference_set, refs, REF_CACHE_DIR)
+        primary = paths[0]                       # best contiguous segment (others are used too, never joined)
+        fn = "refclean_" + os.path.basename(primary)[4:-4] + ".wav"
+        shutil.copyfile(primary, os.path.join(OUTPUT_DIR, fn))
+        return {"url": f"/audio/{fn}", "report": summary, "segments": len(paths)}
     except ValueError as e:
         raise HTTPException(422, str(e))
     finally:
@@ -4064,7 +4313,7 @@ async def sts(
     if not WHISPER_OK: raise HTTPException(503, "Faster-Whisper غير جاهز بعد (لا يزال يُحمَّل أو فشل تحميله)، أعد المحاولة بعد قليل.")
     if not job_id: job_id = uuid.uuid4().hex
     src = f"/tmp/sts_{uuid.uuid4().hex}.wav"
-    with open(src, "wb") as f: shutil.copyfileobj(source_audio.file, f)
+    _copy_limited(source_audio.file, src)
     refs = []
     cancel_events[job_id] = threading.Event()
     try:
@@ -4122,7 +4371,7 @@ async def dub(
     if not TRANSLATOR_OK: raise HTTPException(503, "deep-translator غير مثبّت.")
     if not job_id: job_id = uuid.uuid4().hex
     src = f"/tmp/dub_{uuid.uuid4().hex}.wav"
-    with open(src, "wb") as f: shutil.copyfileobj(source_audio.file, f)
+    _copy_limited(source_audio.file, src)
     refs = []
     cancel_events[job_id] = threading.Event()
     try:
@@ -4232,30 +4481,37 @@ async def save_voice(background_tasks: BackgroundTasks,
                      name: str = Form(...),
                      file: UploadFile = File(...),
                      file2: UploadFile = File(default=None)):
-    safe = name.strip().replace("/","_").replace("..","_")[:40]
-    lib  = os.path.join(VOICE_LIB, safe)
+    safe = safe_voice_name(name)
+    if not safe: raise HTTPException(400, "اسم الصوت غير صالح.")
+    uploads = [f for f in ([file, file2] if file2 and file2.filename else [file]) if f and f.filename]
+    names = []
+    for i, f in enumerate(uploads):
+        fn = re.sub(r"[^\w.\-]", "_", os.path.basename(f.filename), flags=re.UNICODE)[:80] or f"ref{i}.wav"
+        if not fn.lower().endswith(_AUDIO_EXT):
+            raise HTTPException(400, "صيغة الملف غير مدعومة (wav / mp3 / flac / ogg / m4a).")
+        names.append(fn)
+    if not uploads: raise HTTPException(400, "لا يوجد ملف صوتي.")
+    lib = voice_dir(safe)
     os.makedirs(lib, exist_ok=True)
-    for f in ([file, file2] if file2 and file2.filename else [file]):
-        safe_fn = re.sub(r"[^A-Za-z0-9_.\-]", "_", os.path.basename(f.filename))[:80]
-        with open(os.path.join(lib, safe_fn), "wb") as buf:
-            shutil.copyfileobj(f.file, buf)
+    for f, fn in zip(uploads, names):
+        _copy_limited(f.file, os.path.join(lib, fn))
     background_tasks.add_task(trigger_cloud_backup)
-    return {"name": safe}
+    return {"name": os.path.basename(lib)}
 
 @app.delete("/voices/{name}")
 def delete_voice(background_tasks: BackgroundTasks, name: str):
-    lib = os.path.join(VOICE_LIB, name)
-    if os.path.isdir(lib): shutil.rmtree(lib)
+    lib = voice_dir(name, must_exist=True)
+    shutil.rmtree(lib)
     background_tasks.add_task(trigger_cloud_backup)
     return {"deleted": name}
 
 @app.get("/voices/{name}/preview")
 def preview_voice(name: str):
-    lib = os.path.join(VOICE_LIB, name)
-    if not os.path.isdir(lib): raise HTTPException(404, "صوت غير موجود.")
-    for fn in os.listdir(lib):
-        if fn.lower().endswith((".wav",".mp3",".flac",".ogg")):
-            mt = "audio/wav" if fn.endswith(".wav") else "audio/mpeg"
+    lib = voice_dir(name, must_exist=True)
+    for fn in sorted(os.listdir(lib)):
+        if fn.lower().endswith(_AUDIO_EXT):
+            mt = {"wav": "audio/wav", "mp3": "audio/mpeg", "flac": "audio/flac", "ogg": "audio/ogg",
+                  "m4a": "audio/mp4", "opus": "audio/ogg", "webm": "audio/webm", "aac": "audio/aac"}[fn.rsplit(".", 1)[-1].lower()]
             return FileResponse(os.path.join(lib, fn), media_type=mt)
     raise HTTPException(404, "لا توجد ملفات صوتية.")