Sync from felladrin/MiniSearch@74f42b1

changelog.md

@@ -7,6 +7,8 @@ Notable changes, grouped by date, most recent first.
 - The in-browser engine, wllama, moves from 3.8.1 to 3.13.0. It now handles a model download that stopped midway by itself, so MiniSearch no longer deletes those files before each load.
 - Dictation's on-device model is now Qwen3-ASR 0.6B, run through wllama, instead of Moonshine. It understands every language MiniSearch answers in, not only English, so the setting that prefers it is now on by default for every browser; a profile saved before keeps its value, so a non-English profile turns it on in the Voice settings. The text now appears when the user stops recording rather than while they speak (about 2 seconds for a short query on WebGPU), and a recording ends on its own after two minutes. The first press downloads about 700 MB from Hugging Face, against 51 MB before, and later presses load it from the browser's storage in about 2 seconds; leaving the page or turning dictation off mid-download aborts it. The Moonshine runtime leaves the build, which shrinks from 35.7 MB to 22.2 MB, and the `/dictation-models/` route and `DICTATION_MODELS_DIR` are gone, since the server no longer serves model files. `docs/speech-model-evaluation.md` records the speech models tried for dictation and reading aloud, and why the others were turned down.
 
+- Reading answers aloud now speaks the answer's language. With no voice chosen, the voice is picked for the language the answer is written in, detected with `franc-min`, instead of the browser's: on an English browser, an answer in Portuguese is read by a Portuguese voice. The Voice settings panel lists every local voice (124 in 34 languages today) grouped by language, with the browser's language first, where it used to list only the browser's language, and the engine is no longer labeled "English-only". The detector is a new dependency, a 109 KB script (51 KB compressed) loaded on the first Listen press rather than with the page. A browser language the detector does not know (Danish, Finnish and Catalan among them) keeps its voice, as before, and a chosen voice reads every answer. Japanese, Korean and Hindi have no local voice, so their answers are read by an OS voice of that language.
+
 ## 2026-11-08
 
 - MiniSearch now checks that the GPU can run wllama's shaders before using it, instead of only checking that the browser has WebGPU. The shaders use subgroups and the `subgroup_id` builtin, so the GPU is used only when the browser's shader compiler supports `subgroup_id`, an adapter answers within 5 seconds, it is not a software fallback, and it has the `subgroups` feature. Otherwise the model runs on the CPU and a new profile starts on the CPU default model. On Chrome 137, which has WebGPU but not `subgroup_id`, every model used to abort; it now answers on the CPU with LittleLamb 290M. The logs say which check failed.

client/components/Pages/Main/Menu/VoiceSettingsForm.test.tsx

@@ -9,8 +9,17 @@ const localVoice: VoiceOption = {
   label: "lessac • English (high)",
   engine: "local",
   languageCode: "en_US",
+  languageName: "English",
 };
 
+const portugueseVoices: VoiceOption[] = ["pt_BR", "pt_PT"].map((code) => ({
+  value: `piper:${code}-voice-medium`,
+  label: `voice • Portuguese (medium)`,
+  engine: "local",
+  languageCode: code,
+  languageName: "Portuguese",
+}));
+
 const systemVoice: VoiceOption = {
   value: "system:os-voice",
   label: "OS Voice • en-US",
@@ -99,6 +108,30 @@ describe("VoiceSettingsForm", () => {
     ]);
   });
 
+  it("groups the local voices by language, in the order they are listed", async () => {
+    listVoices.mockResolvedValue([...portugueseVoices, localVoice]);
+    renderForm();
+    await screen.findByText("Voice Selection");
+
+    const listbox = openSelect(voiceInput());
+    const groups = listbox
+      .getAllByRole("group", { hidden: true })
+      .map((group) => [
+        group.firstElementChild?.textContent,
+        within(group)
+          .getAllByRole("option", { hidden: true })
+          .map((option) => option.textContent),
+      ]);
+
+    expect(groups).toEqual([
+      [
+        "Portuguese",
+        ["🇧🇷 voice • Portuguese (medium)", "🇵🇹 voice • Portuguese (medium)"],
+      ],
+      ["English", ["🇺🇸 lessac • English (high)"]],
+    ]);
+  });
+
   it("lists only the system voices while the system engine is selected", async () => {
     settings.current.textToSpeechEngine = "system";
     renderForm();
@@ -146,7 +179,7 @@ describe("VoiceSettingsForm", () => {
     const engine = screen.getAllByRole("combobox")[0] as HTMLElement;
     fireEvent.click(
       openSelect(engine).getByRole("option", {
-        name: "System voices (Multi-lingual)",
+        name: "System voices",
         hidden: true,
       }),
     );

client/components/Pages/Main/Menu/VoiceSettingsForm.tsx

@@ -1,4 +1,11 @@
-import { Select, Stack, Switch, Text } from "@mantine/core";
+import {
+  type ComboboxItem,
+  type ComboboxItemGroup,
+  Select,
+  Stack,
+  Switch,
+  Text,
+} from "@mantine/core";
 import { useForm } from "@mantine/form";
 import getUnicodeFlagIcon from "country-flag-icons/unicode";
 import { usePubSub } from "create-pubsub/react";
@@ -52,6 +59,25 @@ export default function VoiceSettingsForm() {
     };
   }, [settings.textToSpeechEngine]);
 
+  // `listVoices` keeps each language's voices together, so a group only ever
+  // continues the one before it.
+  const voiceData: (ComboboxItem | ComboboxItemGroup<ComboboxItem>)[] = [];
+  for (const option of voiceOptions) {
+    const item = {
+      value: option.value,
+      label: `${getCountryFlag(option.languageCode)} ${option.label}`,
+    };
+    const previous = voiceData.at(-1);
+    if (!option.languageName) voiceData.push(item);
+    else if (
+      previous &&
+      "group" in previous &&
+      previous.group === option.languageName
+    )
+      previous.items.push(item);
+    else voiceData.push({ group: option.languageName, items: [item] });
+  }
+
   return (
     <Stack gap="xs">
       <Switch
@@ -88,8 +114,8 @@ export default function VoiceSettingsForm() {
           }));
         }}
         data={[
-          { value: "local", label: "Local neural voice (English-only)" },
-          { value: "system", label: "System voices (Multi-lingual)" },
+          { value: "local", label: "Local neural voice (many languages)" },
+          { value: "system", label: "System voices" },
         ]}
         allowDeselect={false}
       />
@@ -97,17 +123,15 @@ export default function VoiceSettingsForm() {
       <Text size="xs" c="dimmed">
         Choose the voice to use when reading AI responses aloud. Only the voices
         of the selected engine are listed. Leave it empty to pick one
-        automatically for your language.
+        automatically for the language of each response; a voice you choose
+        reads every response, whatever its language.
       </Text>
       <Select
         // Remounting drops the label Mantine keeps for the previous value, which
         // would otherwise filter the new engine's list as if it were typed.
         key={settings.textToSpeechEngine}
         {...form.getInputProps("selectedVoiceId")}
-        data={voiceOptions.map((option) => ({
-          value: option.value,
-          label: `${getCountryFlag(option.languageCode)} ${option.label}`,
-        }))}
+        data={voiceData}
         searchable
         nothingFoundMessage="No voices found"
         placeholder="Auto-detected"

client/modules/textToSpeech.test.ts

@@ -41,6 +41,37 @@ const englishVoice = {
   language: { code: "en_US", name_english: "English" },
 };
 
+const portugueseVoice = {
+  key: "pt_BR-faber-medium",
+  name: "faber",
+  quality: "medium",
+  language: { code: "pt_BR", name_english: "Portuguese" },
+};
+
+const germanVoice = {
+  key: "de_DE-thorsten-medium",
+  name: "thorsten",
+  quality: "medium",
+  language: { code: "de_DE", name_english: "German" },
+};
+
+const swedishVoice = {
+  key: "sv_SE-nst-medium",
+  name: "nst",
+  quality: "medium",
+  language: { code: "sv_SE", name_english: "Swedish" },
+};
+
+const danishVoice = {
+  key: "da_DK-talesyntese-medium",
+  name: "talesyntese",
+  quality: "medium",
+  language: { code: "da_DK", name_english: "Danish" },
+};
+
+const portugueseAnswer =
+  "A Torre Eiffel foi construída em 1889 para a Exposição Universal de Paris e tem cerca de 330 metros de altura.";
+
 /** A worker stub the test drives by hand, standing in for the real one. */
 function createFakeWorker() {
   const sent: WorkerRequest[] = [];
@@ -55,6 +86,7 @@ function createFakeWorker() {
 }
 
 let spoken: string[] = [];
+let spokenLanguages: string[] = [];
 let createdObjectUrls = 0;
 let handlersAtSourceClear: {
   onended: (() => void) | null;
@@ -65,6 +97,7 @@ beforeEach(async () => {
   vi.clearAllMocks();
   vi.resetModules();
   spoken = [];
+  spokenLanguages = [];
   settings.selectedVoiceId = "";
   settings.textToSpeechEngine = "local";
   mockVoices.mockResolvedValue([englishVoice]);
@@ -111,8 +144,13 @@ beforeEach(async () => {
       { voiceURI: "os-voice", name: "OS Voice", lang: "en-US" },
     ],
     cancel: vi.fn(),
-    speak: (utterance: { text: string; onend: (() => void) | null }) => {
+    speak: (utterance: {
+      text: string;
+      lang: string;
+      onend: (() => void) | null;
+    }) => {
       spoken.push(utterance.text);
+      spokenLanguages.push(utterance.lang);
       queueMicrotask(() => utterance.onend?.());
     },
   });
@@ -339,6 +377,74 @@ describe("speak", () => {
     expect(mockUpdateState).toHaveBeenLastCalledWith("idle");
   });
 
+  it("picks the local voice for the answer's language, not the browser's", async () => {
+    mockVoices.mockResolvedValue([englishVoice, portugueseVoice]);
+    const worker = createFakeWorker();
+    tts.setWorkerFactory(() => worker as unknown as Worker);
+
+    void tts.speak(portugueseAnswer);
+    await vi.waitFor(() => expect(worker.sent).toHaveLength(1));
+
+    expect(worker.sent[0].voiceId).toBe("pt_BR-faber-medium");
+  });
+
+  it("keeps a chosen voice whatever the answer's language", async () => {
+    mockVoices.mockResolvedValue([englishVoice, portugueseVoice]);
+    settings.selectedVoiceId = "piper:en_US-lessac-high";
+    const worker = createFakeWorker();
+    tts.setWorkerFactory(() => worker as unknown as Worker);
+
+    void tts.speak(portugueseAnswer);
+    await vi.waitFor(() => expect(worker.sent).toHaveLength(1));
+
+    expect(worker.sent[0].voiceId).toBe("en_US-lessac-high");
+  });
+
+  it("keeps the browser language when the detector cannot recognize it", async () => {
+    // franc-min has no Danish and reads this sentence as Swedish.
+    vi.stubGlobal("navigator", { language: "da-DK" });
+    mockVoices.mockResolvedValue([swedishVoice, danishVoice]);
+    const worker = createFakeWorker();
+    tts.setWorkerFactory(() => worker as unknown as Worker);
+
+    void tts.speak(
+      "Eiffeltårnet blev bygget i 1889 til verdensudstillingen i Paris og er omkring 330 meter højt.",
+    );
+    await vi.waitFor(() => expect(worker.sent).toHaveLength(1));
+
+    expect(worker.sent[0].voiceId).toBe("da_DK-talesyntese-medium");
+  });
+
+  it("uses the browser language when the detector fails to load", async () => {
+    vi.doMock("franc-min", () => {
+      throw new Error("chunk failed to load");
+    });
+    try {
+      tts = await import("./textToSpeech");
+      mockVoices.mockResolvedValue([englishVoice, portugueseVoice]);
+      const worker = createFakeWorker();
+      tts.setWorkerFactory(() => worker as unknown as Worker);
+
+      void tts.speak(portugueseAnswer);
+      await vi.waitFor(() => expect(worker.sent).toHaveLength(1));
+
+      expect(worker.sent[0].voiceId).toBe("en_US-lessac-high");
+      expect(mockAddLogEntry).toHaveBeenCalledWith(
+        expect.stringContaining("Could not detect the answer's language"),
+      );
+    } finally {
+      vi.doUnmock("franc-min");
+    }
+  });
+
+  it("asks the system engine for the answer's language", async () => {
+    settings.textToSpeechEngine = "system";
+
+    await tts.speak(portugueseAnswer);
+
+    expect(spokenLanguages).toEqual(["pt"]);
+  });
+
   it("stops playback without falling back to the system voice", async () => {
     const worker = createFakeWorker();
     tts.setWorkerFactory(() => worker as unknown as Worker);
@@ -382,14 +488,17 @@ describe("no speech engine at all", () => {
 });
 
 describe("listVoices", () => {
-  it("offers only the local voices for the language", async () => {
-    const options = await tts.listVoices("en-US");
+  it("offers the local voices of every language, the given language first", async () => {
+    mockVoices.mockResolvedValue([germanVoice, englishVoice, portugueseVoice]);
 
-    expect(options).toEqual([
-      expect.objectContaining({
-        value: "piper:en_US-lessac-high",
-        engine: "local",
-      }),
+    const options = await tts.listVoices("pt-BR");
+
+    expect(
+      options.map(({ value, languageName }) => [value, languageName]),
+    ).toEqual([
+      ["piper:pt_BR-faber-medium", "Portuguese"],
+      ["piper:en_US-lessac-high", "English"],
+      ["piper:de_DE-thorsten-medium", "German"],
     ]);
   });
 

client/modules/textToSpeech.ts

@@ -23,6 +23,8 @@ export interface VoiceOption {
   label: string;
   engine: TextToSpeechEngine;
   languageCode: string;
+  /** Set on local voices only, which the settings form groups by language. */
+  languageName?: string;
 }
 
 /** The markers come from user settings, so a character like `(` must not be read as syntax. */
@@ -69,6 +71,110 @@ function primaryLanguage(code: string): string {
   return code.replace("_", "-").split("-")[0].toLowerCase();
 }
 
+/**
+ * franc-min names languages in ISO 639-3, while the voices use the two-letter
+ * codes. Its languages without a two-letter code are left out.
+ */
+const LANGUAGE_BY_FRANC_CODE: Record<string, string> = {
+  amh: "am",
+  arb: "ar",
+  azj: "az",
+  bel: "be",
+  ben: "bn",
+  bos: "bs",
+  bul: "bg",
+  ces: "cs",
+  cmn: "zh",
+  deu: "de",
+  ell: "el",
+  eng: "en",
+  fra: "fr",
+  guj: "gu",
+  hau: "ha",
+  hin: "hi",
+  hrv: "hr",
+  hun: "hu",
+  ibo: "ig",
+  ind: "id",
+  ita: "it",
+  jav: "jv",
+  jpn: "ja",
+  kan: "kn",
+  kaz: "kk",
+  kin: "rw",
+  kor: "ko",
+  lin: "ln",
+  mal: "ml",
+  mar: "mr",
+  mya: "my",
+  nld: "nl",
+  npi: "ne",
+  nya: "ny",
+  pan: "pa",
+  pbu: "ps",
+  pes: "fa",
+  plt: "mg",
+  pol: "pl",
+  por: "pt",
+  ron: "ro",
+  run: "rn",
+  rus: "ru",
+  sin: "si",
+  som: "so",
+  spa: "es",
+  srp: "sr",
+  sun: "su",
+  swe: "sv",
+  swh: "sw",
+  tam: "ta",
+  tel: "te",
+  tgl: "tl",
+  tha: "th",
+  tur: "tr",
+  ukr: "uk",
+  urd: "ur",
+  uzn: "uz",
+  vie: "vi",
+  yor: "yo",
+  zlm: "ms",
+  zul: "zu",
+};
+
+const DETECTABLE_LANGUAGES = new Set(Object.values(LANGUAGE_BY_FRANC_CODE));
+
+/**
+ * The language an answer is written in, which can differ from the browser's:
+ * the model answers in the language of the question. Falls back to the browser
+ * language when the text is too short to tell, and keeps it outright when
+ * franc-min cannot recognize it (Danish, Finnish, Catalan...), because it would
+ * then read an answer in that language as a neighbouring one.
+ */
+async function detectAnswerLanguage(
+  text: string,
+  browserLanguage: string,
+): Promise<string> {
+  const browserPrimary = primaryLanguage(browserLanguage);
+  if (!DETECTABLE_LANGUAGES.has(browserPrimary)) return browserLanguage;
+
+  try {
+    const { franc } = await import("franc-min");
+    const detected =
+      LANGUAGE_BY_FRANC_CODE[
+        franc(text, { only: Object.keys(LANGUAGE_BY_FRANC_CODE) })
+      ];
+    return !detected || detected === browserPrimary
+      ? browserLanguage
+      : detected;
+  } catch (error) {
+    addLogEntry(
+      `Could not detect the answer's language, using the browser's: ${
+        error instanceof Error ? error.message : "unknown error"
+      }`,
+    );
+    return browserLanguage;
+  }
+}
+
 let cachedLocalVoices: Promise<Voice[]> | null = null;
 
 /**
@@ -88,10 +194,11 @@ function getLocalVoices(): Promise<Voice[]> {
 }
 
 /**
- * Lists only the voices the given engine can actually play: the local voices for
- * the given language, or every `speechSynthesis` voice. Listing the local
- * voices means fetching the catalogue over the network, so it must not happen
- * when the user has opted out of the local engine.
+ * Lists only the voices the given engine can actually play: every local voice,
+ * those of the given language first and the rest by language name, or every
+ * `speechSynthesis` voice. Listing the local voices means fetching the
+ * catalogue over the network, so it must not happen when the user has opted
+ * out of the local engine.
  */
 export async function listVoices(
   languageCode: string = navigator.language,
@@ -102,13 +209,20 @@ export async function listVoices(
 
   if (engine !== "system") {
     try {
-      for (const voice of await getLocalVoices()) {
-        if (primaryLanguage(voice.language.code) !== wanted) continue;
+      const rank = (voice: Voice) =>
+        primaryLanguage(voice.language.code) === wanted ? 0 : 1;
+      const sorted = [...(await getLocalVoices())].sort(
+        (a, b) =>
+          rank(a) - rank(b) ||
+          a.language.name_english.localeCompare(b.language.name_english),
+      );
+      for (const voice of sorted) {
         options.push({
           value: `${LOCAL_VOICE_PREFIX}${voice.key}`,
           label: `${voice.name} • ${voice.language.name_english} (${voice.quality})`,
           engine: "local",
           languageCode: voice.language.code,
+          languageName: voice.language.name_english,
         });
       }
     } catch (error) {
@@ -188,6 +302,7 @@ export function stopSpeaking(): void {
 function speakWithSystemVoice(
   text: string,
   storedVoiceId: string,
+  languageCode: string,
   session: SpeechSession,
 ): Promise<void> {
   return new Promise((resolve) => {
@@ -198,6 +313,8 @@ function speakWithSystemVoice(
     }
 
     const utterance = new SpeechSynthesisUtterance(text);
+    // Without a voice, the OS picks its own voice for this language.
+    utterance.lang = languageCode;
     const wantedUri = storedVoiceId.startsWith(SYSTEM_VOICE_PREFIX)
       ? storedVoiceId.slice(SYSTEM_VOICE_PREFIX.length)
       : storedVoiceId;
@@ -414,13 +531,15 @@ export async function speak(text: string): Promise<void> {
     const wantsSystemVoice =
       settings.textToSpeechEngine === "system" ||
       storedVoiceId.startsWith(SYSTEM_VOICE_PREFIX);
+    const languageCode = await detectAnswerLanguage(
+      spokenText,
+      navigator.language,
+    );
+    if (stopRequested) return;
 
     if (!wantsSystemVoice) {
       try {
-        const voiceId = await resolveLocalVoiceId(
-          storedVoiceId,
-          navigator.language,
-        );
+        const voiceId = await resolveLocalVoiceId(storedVoiceId, languageCode);
         if (stopRequested) return;
         if (voiceId) {
           // Returning here is what keeps a stop silent: `speakWithLocalVoice`
@@ -446,7 +565,12 @@ export async function speak(text: string): Promise<void> {
     }
 
     if (stopRequested) return;
-    await speakWithSystemVoice(spokenText, storedVoiceId, session);
+    await speakWithSystemVoice(
+      spokenText,
+      storedVoiceId,
+      languageCode,
+      session,
+    );
   } finally {
     // A session that has already been replaced must not clear the live one.
     if (activeSession === session) {

docs/ai-integration.md

@@ -368,7 +368,20 @@ not a failure and never falls back.
 The catalogue is fetched at runtime from the published voice index rather than
 hardcoded: it already lists more voices than the package's own `VoiceId` union,
 and a stale copy would offer voices that fail to download. The settings form
-groups local voices for the current language separately from the OS voices.
+lists every local voice, grouped by language, with the browser's language
+first. It lists the OS voices only when the system engine is selected.
+
+With no voice chosen, `speak()` picks one for the language of the answer,
+which follows the question's language rather than the browser's. `franc-min`
+detects it, loaded on the first Listen press rather than with the page, and the
+first local voice of that language reads the answer. With the system engine,
+or when no local voice speaks that language (Japanese, Korean and Hindi have
+none), the language is passed to `speechSynthesis` so the OS picks its own
+voice. The browser's language is used instead when the detector cannot tell,
+fails to load, or does not know the browser's language at all (Danish, Finnish
+and Catalan among them), since it would then read an answer in that language
+as a neighbouring one. A chosen voice reads every answer, whatever its
+language.
 
 ### Third-party requests
 

docs/configuration.md

@@ -216,7 +216,7 @@ Search results:
 
 | Setting                     | Type                  | Default      | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | --------------------------- | --------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `selectedVoiceId`           | string                | `""`         | Voice for reading answers aloud. `piper:<voice>` picks a local neural voice, `system:<voiceURI>` an OS voice, and `""` picks one automatically for the browser language. The Voice settings panel lists only the voices of the selected engine, and switching that engine resets this to `""`. A bare value stored by an earlier version is read as an OS voice whenever the system engine runs; with the local engine it is ignored in favor of a language match                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `selectedVoiceId`           | string                | `""`         | Voice for reading answers aloud. `piper:<voice>` picks a local neural voice, `system:<voiceURI>` an OS voice, and `""` picks one automatically for the language of each answer (see [ai-integration.md](ai-integration.md#voices)). The Voice settings panel lists only the voices of the selected engine, the local ones in every language, and switching that engine resets this to `""`. A bare value stored by an earlier version is read as an OS voice whenever the system engine runs; with the local engine it is ignored in favor of a language match                                                                                                                                                                                                                                                                                                                                        |
 | `textToSpeechEngine`        | `"local" \| "system"` | `"local"`    | Which engine reads answers aloud, and which set of voices the Voice settings panel lists. `"system"` also overrides a local voice picked above, and stops the voice list from being fetched, so it never contacts a third-party host. A profile that had picked an OS voice before this setting existed starts on `"system"`, so the upgrade does not replace that choice with a model download                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `enableDictation`           | boolean               | `true`       | Shows the microphone button inside the search field and the chat follow-up field, which fills whichever one it sits in while the user speaks. Turning this off hides the button and loads nothing. The button is also hidden outside a secure context, so an instance served over plain HTTP on a LAN will not show it: no browser grants microphone access there                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `enableLocalDictationModel` | boolean               | `true`       | Whether the dictation button prefers the on-device Qwen3-ASR model, which transcribes many languages without the audio leaving the device. The first press downloads ~700 MB from Hugging Face, and later presses load it from the browser's storage. The model writes the text once the recording stops, and a recording ends on its own after two minutes. With this off, the button uses the browser's built-in `SpeechRecognition`, which shows the text while the user speaks but may send the audio to the browser vendor. The preference reorders the two engines and never removes one: on browsers without `SpeechRecognition` the on-device model is used regardless. Until the model became multilingual, the default was `true` only for an English browser, and a profile saved back then keeps its stored value, so the Voice settings panel is where a non-English profile turns it on |

docs/failure-injection.md

@@ -77,6 +77,7 @@ needed.
 | Generation interrupted mid-stream                                                                               | Partial answer preserved, state stays `interrupted`                                                                                                                                                                     | `client/modules/textGeneration.degradation.test.ts`                                                                                                                                                                                                                                                |
 | The local voice catalogue cannot be fetched                                                                     | The local engine is skipped and the answer is read by an OS voice                                                                                                                                                       | `client/modules/textToSpeech.test.ts` › falls back when the voice catalogue cannot be reached                                                                                                                                                                                                      |
 | No local voice matches the language                                                                             | Same, with a log entry naming the reason                                                                                                                                                                                | `client/modules/textToSpeech.test.ts` › falls back when no local voice matches the language                                                                                                                                                                                                        |
+| The language detector fails to load                                                                             | The answer is read in the browser's language, with a log entry naming the reason                                                                                                                                        | `client/modules/textToSpeech.test.ts` › uses the browser language when the detector fails to load                                                                                                                                                                                                  |
 | The synthesis worker fails before anything is audible                                                           | The answer is read by an OS voice instead                                                                                                                                                                               | `client/modules/textToSpeech.test.ts` › falls back to the system voice when the local engine cannot load, falls back when the worker fails and no chunk was ever audible                                                                                                                           |
 | Every synthesized chunk fails to play (blocked autoplay)                                                        | Treated as a local-engine failure, so an OS voice reads the answer rather than the user getting silence                                                                                                                 | `client/modules/textToSpeech.test.ts` › falls back when every synthesized chunk fails to play                                                                                                                                                                                                      |
 | The browser provides no `speechSynthesis` at all and the local engine failed                                    | Playback resolves and returns to idle with a log entry, instead of an unhandled rejection                                                                                                                               | `client/modules/textToSpeech.test.ts` › resolves and logs when the local engine failed and there are no OS voices                                                                                                                                                                                  |

package-lock.json

@@ -31,6 +31,7 @@
         "dexie": "^4.0.11",
         "dotenv": "^18.0.0",
         "embla-carousel-react": "^8.3.0",
+        "franc-min": "^6.2.0",
         "gpt-tokenizer": "^4.0.0",
         "hash-wasm": "4.12.0",
         "helper-git-hash": "^1.0.0",
@@ -3123,6 +3124,16 @@
         "node": ">=6"
       }
     },
+    "node_modules/collapse-white-space": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-2.1.0.tgz",
+      "integrity": "sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/comma-separated-tokens": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
@@ -3699,6 +3710,19 @@
         "node": ">=18.14.0"
       }
     },
+    "node_modules/franc-min": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/franc-min/-/franc-min-6.2.0.tgz",
+      "integrity": "sha512-1uDIEUSlUZgvJa2AKYR/dmJC66v/PvGQ9mWfI9nOr/kPpMFyvswK0gPXOwpYJYiYD008PpHLkGfG58SPjQJFxw==",
+      "license": "MIT",
+      "dependencies": {
+        "trigram-utils": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -5778,6 +5802,16 @@
       "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
       "license": "MIT"
     },
+    "node_modules/n-gram": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/n-gram/-/n-gram-2.0.2.tgz",
+      "integrity": "sha512-S24aGsn+HLBxUGVAUFOwGpKs7LBcG4RudKU//eWzt/mQ97/NMKQxDWHyHx63UNWk/OOdihgmzoETn1tf5nQDzQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/nanoid": {
       "version": "3.3.20",
       "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.20.tgz",
@@ -7362,6 +7396,20 @@
         "node": "^22.14.0 || >=24.0.0"
       }
     },
+    "node_modules/trigram-utils": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/trigram-utils/-/trigram-utils-2.0.1.tgz",
+      "integrity": "sha512-nfWIXHEaB+HdyslAfMxSqWKDdmqY9I32jS7GnqpdWQnLH89r6A5sdk3fDVYqGAZ0CrT8ovAFSAo6HRiWcWNIGQ==",
+      "license": "MIT",
+      "dependencies": {
+        "collapse-white-space": "^2.0.0",
+        "n-gram": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/trim-lines": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",

package.json

@@ -64,6 +64,7 @@
     "dexie": "^4.0.11",
     "dotenv": "^18.0.0",
     "embla-carousel-react": "^8.3.0",
+    "franc-min": "^6.2.0",
     "gpt-tokenizer": "^4.0.0",
     "hash-wasm": "4.12.0",
     "helper-git-hash": "^1.0.0",