TTS: fail fast + spread load across the Cloudflare worker farm

The 6-proxy farm 'rot' identically under concurrent load: a single worker's
synthesis jobs contend for CPU and trip Cloudflare's hard ~21s request
ceiling, so a weighted-down request wedges ~21s then dies. The rotator had no
per-worker timeout (fetch waited out the full ~21s kill) and #getBestWorker()
piled concurrent jobs onto one worker.

- #fetchWithTimeout(): 9s per-worker timeout (Promise.race), so a hung worker
  fails fast and the loop rotates to the next worker.
- #getBestWorker(): random round-robin so concurrent requests spread across
  the farm instead of stacking on the least-recently-used worker.

Recorded in CLAUDE.md self-correcting notes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: hellpanderrr

wiktionary_pron/CLAUDE.md

@@ -142,6 +142,7 @@ Each of these cost real debugging time in past sessions. Check this list before
 - **Regex char classes with `-` between Unicode literals form ranges**: `[^\p{L}\p{M}'’-‿]` parsed `’-‿` as U+2019–U+203F and stripped ASCII hyphens from every word. Put `-` last in the class. (Was a live bug in `sanitize()` for years.)
 - **`#header > a > i` selects the HOME link's icon** — the dark-mode toggle on macronizer.html restyled the wrong button for this reason. Use `#dark_mode i`.
 - **Duplicated language lists in `main.js` drift**: `lang === "Lituanian"` (typo, missing h) appears in several copies of the multi-value language list — Lithuanian silently loses features in some modes. If touching those lists, extract one shared constant.
+- **Cloudflare Workers kill a request at a hard ~21s wall, not a clean error.** Under concurrent load a single worker's synthesis jobs contend for CPU and trip this ceiling → one job per burst wedges ~21s then dies (`000` / truncated audio). This made the 6-proxy TTS farm "rot" identically; it's a platform throttle, not per-worker config. Fixes (in `tts.js`): a **per-worker client timeout** (~9s via `Promise.race`) so a hung worker fails fast and the rotator moves on instead of waiting out the ~21s kill; and **shuffle the farm per call** so concurrent requests spread instead of piling onto the least-recently-used worker. Worker side (CF `silent-unit-b6ca`): reject on socket close before `turn.end` (the promise was hanging forever) and retry with fresh `Sec-MS-GEC`/`ConnectionId`; keep `Sec-MS-GEC-Version` in step with the current Edge release (`…3650.75` → `…3650.96`).
 
 **IndexedDB performance (measured in Chromium, 100k rows)**
 - Row-per-entry `put()` with a secondary index is the killer: ~58s/100k. `durability: 'relaxed'` changes nothing (already default). Grouping by unique key: 1.8×. **Packing ~1000 rows per record: 20×** (2.8s/100k). This is why both the macronizer wordlist and the app lexicons use sorted range-chunk records.

wiktionary_pron/scripts/tts.js

@@ -85,9 +85,44 @@ class StreamingTTS {
   }
 
   #getBestWorker() {
-    return this.#workers.reduce((best, current) => {
-      return (current.lastUsed < best.lastUsed) ? current : best;
+    // Round-robin starting from a random point, so concurrent requests spread
+    // across the whole farm instead of piling onto whichever worker has the
+    // oldest lastUsed timestamp (which stacks concurrent jobs on one worker
+    // and trips Cloudflare's ~21s request ceiling -> the observed hangs).
+    const startIdx = Math.floor(Math.random() * this.#workers.length);
+    return this.#workers[(startIdx + 1) % this.#workers.length];
+  }
+
+  // Abort a request to one worker after this long so a hung worker fails fast
+  // and the rotation loop moves on, instead of waiting out Cloudflare's full
+  // ~21s platform kill before failing over.
+  #workerTimeoutMs = 9000;
+
+  // Promise.race wrapper: settles on the worker response OR the abort signal OR
+  // a per-worker timeout. A timed-out worker counts as a failed attempt so the
+  // loop rotates to the next worker.
+  async #fetchWithTimeout(url, init) {
+    const controller = this.#currentAbortController;
+    let timer = null;
+    let timedOut = false;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        timedOut = true;
+        reject(new Error('Worker timeout'));
+      }, this.#workerTimeoutMs);
+      controller.signal.addEventListener('abort', () => clearTimeout(timer), {once: true});
     });
+    try {
+      const result = await Promise.race([
+        fetch(url, { ...init, signal: controller.signal }),
+        timeout
+      ]);
+      if (!timedOut) clearTimeout(timer);
+      return result;
+    } finally {
+      // swallows any leftover timer rejection after the race is won
+      timeout.catch(() => {});
+    }
   }
 
   get isPlaying() {
@@ -205,7 +240,7 @@ class StreamingTTS {
       worker.lastUsed = Date.now();
 
       try {
-        const response = await fetch(`${worker.base}/tts`, {
+        const response = await this.#fetchWithTimeout(`${worker.base}/tts`, {
           method: "POST",
           headers: {"Content-Type": "application/json"},
           body: JSON.stringify({
@@ -214,8 +249,7 @@ class StreamingTTS {
             rate: rateStr,
             pitch: pitchStr,
             volume: "+0%"
-          }),
-          signal: this.#currentAbortController.signal
+          })
         });
 
         if (!response.ok) {