fix(boost): rebuild trie on vocab change, not on every status flip

The phrase-boost trie rebuild effect depended on the raw `status` string as a
proxy for "the model's tokenizer changed". But `status` also flips on recording
start/stop, file transcribe, and each chunk-progress tick (setStatus with a
percentage string). Every flip re-ran parseBoostPhrases (~88ms on the 64k-line
medical list) and the trie rebuild, and pushed fresh boost-warning arrays that
forced the giant phrase-list textarea to reconcile. On load, status cycles
idle -> loadingModel -> creatingSessions -> modelReady, so this fired several
times back to back: the "My Computer tab frozen on load" the user saw. The
earlier fix (d103856) only stopped the casing-expand on the prebuilt path; the
parse + rebuild + warning-state churn on every status value remained.

Fix: publish the loaded tokenizer's vocab signature as `tokenizerVocabSig` state
(set after the model is created, cleared on dispose) and key the rebuild effect
on it instead of `status`. The vocab signature changes only on a real model
load/swap, so the trie rebuilds exactly once per model change and unrelated
status churn no longer touches it.

Covered by a tier-3 e2e (boost-rebuild-on-status.spec.js): with verbose logging
on and a Custom boost list, it asserts the "[Boost] rebuilding trie" count does
not grow across a full transcribe cycle. Verified the test fails when the effect
is reverted to depend on `status`.

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

Author: thiswillbeyourgithub

app/ui/src/App.jsx

@@ -517,6 +517,17 @@ export default function App() {
   const [boostRebuilding, setBoostRebuilding] = useState(false);
   const phraseBoostRef = useRef(null);   // BoostingTrie | null (null = inert)
   const boostStrengthRef = useRef(1);
+  // Vocab signature of the currently loaded tokenizer (null when no model is
+  // loaded). This is the *only* model-side input the boost-trie rebuild needs:
+  // it changes when (and only when) the model's vocab does, so the rebuild
+  // effect keys on it instead of `status`. Keying on `status` was the bug
+  // behind the "My Computer tab frozen on load": `status` also flips on every
+  // recording start/stop, file transcribe, and even each chunk-progress tick
+  // (setStatus with a percentage string), and each flip re-ran the heavy
+  // parseBoostPhrases + trie rebuild and pushed fresh boost-warning arrays that
+  // forced the giant phrase-list textarea to reconcile. Now the rebuild fires
+  // once per real model change, not once per status string.
+  const [tokenizerVocabSig, setTokenizerVocabSig] = useState(null);
   // Current verbose-logging flag for use inside the debounced rebuild closure
   // (which captures a stale `verboseLog`); synced by the effect below.
   const verboseLogRef = useRef(false);
@@ -1660,8 +1671,12 @@ export default function App() {
   // is debounced (a large paste shouldn't re-encode per keystroke) and the
   // encode runs in the worker, so the main thread never blocks on tokenizing a
   // big list; only the cheap trie insert happens here. Strength is applied
-  // separately (below) so moving the slider does not force a re-encode. We
-  // rebuild on `status` so a model load/swap refreshes the trie.
+  // separately (below) so moving the slider does not force a re-encode. We key
+  // on `tokenizerVocabSig` (not `status`) so a model load/swap refreshes the
+  // trie exactly once: `status` also flips on every recording/transcribe/chunk
+  // transition, none of which change the vocab, and re-running the parse +
+  // rebuild + warning-state writes on each of those froze the UI on a large
+  // curated list (the textarea reconciled the whole list every time).
   useEffect(() => {
     // parseBoostPhrases is cheap (a line scan) and feeds the inline warnings,
     // so it always runs. The expensive step is expandCasingVariants below, so
@@ -1746,7 +1761,7 @@ export default function App() {
       }
     }, BOOST_REBUILD_DEBOUNCE_MS);
     return () => { cancelled = true; clearTimeout(timer); if (showSpinner) setBoostRebuilding(false); };
-  }, [boostPhrases, boostCaseInsensitive, status, encodeBoostPhrases]);
+  }, [boostPhrases, boostCaseInsensitive, tokenizerVocabSig, encodeBoostPhrases]);
 
   // Apply the strength slider without rebuilding the trie.
   useEffect(() => {
@@ -1769,6 +1784,9 @@ export default function App() {
       console.log('[App] Disposing existing model before loading new one...');
       modelRef.current.dispose();
       modelRef.current = null;
+      // Drop the old vocab signature so the boost effect clears its trie now
+      // (no tokenizer) and rebuilds once the new model publishes its signature.
+      setTokenizerVocabSig(null);
     }
 
     setStatus('loadingModel');
@@ -1842,6 +1860,11 @@ export default function App() {
       });
 
       console.timeEnd('LoadModel');
+      // Publish the loaded tokenizer's vocab signature so the boost-trie rebuild
+      // effect runs now (model became ready) and on a later vocab-changing swap,
+      // but NOT on the unrelated status churn of recording/transcribing.
+      const tk = modelRef.current?.tokenizer;
+      setTokenizerVocabSig(tk?.id2token ? vocabSignature(tk.id2token) : 'ready');
       setStatus('modelReady');
       setProgressText('');
       setProgressPct(null);

test/e2e/boost-rebuild-on-status.spec.js

@@ -0,0 +1,94 @@
+// Tier-3 regression E2E: the phrase-boost trie must rebuild once per real model
+// change, NOT on every `status` transition. The boost rebuild effect used to
+// depend on the raw `status` string, which also flips on recording start/stop,
+// file transcribe, and each chunk-progress tick. On a large curated list each
+// flip re-ran parseBoostPhrases + the trie rebuild and pushed fresh
+// boost-warning arrays that forced the giant phrase-list textarea to reconcile,
+// freezing the "My Computer" tab. The fix keys the effect on the loaded
+// tokenizer's vocab signature instead, so unrelated status churn no longer
+// rebuilds.
+//
+// This pins it end to end: with verbose logging on, "[Boost] rebuilding trie"
+// is logged once per rebuild. We record the count once the model is ready, run
+// a full transcription (which flips `status` through transcribing -> modelReady
+// and would re-trigger the buggy effect when it lands back on modelReady), and
+// assert the count did not grow. Reuses the WASM-int8 local-model setup of
+// transcription.spec.js.
+//
+// Built with Claude Code.
+
+import { test, expect } from '@playwright/test';
+import { fileURLToPath } from 'node:url';
+import { resolve, dirname } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_AUDIO = resolve(here, '../fixtures/sample.aac');
+
+// Seed the settings DB so the app loads the model from /models with WASM, with
+// verbose logging on and a Custom boost list present (a few phrases is enough to
+// build a trie and emit the rebuild log; the bug is about *how often* it
+// rebuilds, not list size).
+async function seedSettings(page) {
+  await page.evaluate(async () => {
+    const DB = 'parakeetweb-settings-db', STORE = 'settings-store', PREFIX = 'parakeetweb_';
+    const db = await new Promise((res, rej) => {
+      const req = indexedDB.open(DB, 1);
+      req.onupgradeneeded = (e) => {
+        const d = e.target.result;
+        if (!d.objectStoreNames.contains(STORE)) d.createObjectStore(STORE);
+      };
+      req.onsuccess = () => res(req.result);
+      req.onerror = () => rej(req.error);
+    });
+    await new Promise((res, rej) => {
+      const tx = db.transaction([STORE], 'readwrite');
+      const os = tx.objectStore(STORE);
+      os.put('local', PREFIX + 'modelSource');
+      os.put('wasm', PREFIX + 'backend');
+      os.put(true, PREFIX + 'verboseLog');
+      os.put('__custom__', PREFIX + 'boostSource');
+      os.put('venlafaxine\nacetaminophen\nmetoprolol', PREFIX + 'boostPhrases');
+      tx.oncomplete = () => res();
+      tx.onerror = () => rej(tx.error);
+    });
+  });
+}
+
+test('boost trie does not rebuild on transcribe status churn', async ({ page }) => {
+  let boostRebuilds = 0;
+  page.on('console', (m) => {
+    if (m.type() === 'log' && m.text().includes('[Boost] rebuilding trie')) boostRebuilds += 1;
+  });
+
+  // First load creates the settings DB/store; seed it, then reload so the app
+  // picks up local model source + wasm backend + the boost list.
+  await page.goto('/');
+  await seedSettings(page);
+  await page.reload();
+
+  await page.locator('[data-umami-event="load_model_button"]').click();
+
+  // Model ready: the app renders a ✔ once weights are loaded and initialised.
+  await expect(page.locator('body')).toContainText('✔', { timeout: 6 * 60 * 1000 });
+
+  // Let the post-model-ready rebuild (and its 300ms debounce) settle, then take
+  // the baseline: this is the one legitimate rebuild (the vocab became known).
+  await expect.poll(() => boostRebuilds, { timeout: 30 * 1000 }).toBeGreaterThanOrEqual(1);
+  await page.waitForTimeout(1000);
+  const afterReady = boostRebuilds;
+
+  // Transcribe the fixture clip. autoTranscribe is on by default, so feeding the
+  // file starts it; this churns `status` (transcribing... -> modelReady) which
+  // is exactly what used to re-trigger the rebuild.
+  await page.locator('#audio-file-input').setInputFiles(FIXTURE_AUDIO);
+  const historyText = page.locator('.history-text').first();
+  await expect(historyText).toBeVisible({ timeout: 6 * 60 * 1000 });
+  await expect(historyText).not.toBeEmpty({ timeout: 6 * 60 * 1000 });
+
+  // Give any (buggy) status-driven rebuild its debounce window to fire.
+  await page.waitForTimeout(1000);
+  expect(
+    boostRebuilds,
+    `boost trie rebuilt ${boostRebuilds - afterReady} extra time(s) on transcribe status churn (expected 0)`,
+  ).toBe(afterReady);
+});