Corpán Cacophony (#169)

* cacophony - not on android though

* 0.9.4

Author: skyl

corpan/corpan-app/src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "corpan"
-version = "0.9.3"
+version = "0.9.4"
 description = "Language learning app"
 authors = ["you"]
 edition = "2021"

corpan/corpan-app/src-tauri/Cargo.toml

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "corpan",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "identifier": "com.corpora.corpan",
   "build": {
     "beforeDevCommand": "npm run dev",

corpan/corpan-app/src-tauri/tauri.conf.json

@@ -23,7 +23,7 @@ import {
     getPlatformTopPaddingTranslations,
 } from "@/util/browser";
 import { useScrollNavigation } from "@/hooks/useScrollNavigation";
-import { speakWithStackPrefs } from "@/util/speakWithStackPrefs";
+import { speakConcurrentWithStackPrefs } from "@/util/speakWithStackPrefs";
 
 /* -------------------------------- Types -------------------------------- */
 
@@ -337,7 +337,7 @@ export function MainExperience() {
 
     const speak = (uiCode: string, txt: string) => {
         if (!txt) return;
-        speakWithStackPrefs(uiCode, txt, rate);
+        speakConcurrentWithStackPrefs(uiCode, txt, rate);
     };
 
     // --- UI --------------------------------------------------------------------

corpan/corpan-app/src/components/MainExperience.tsx

@@ -1,6 +1,6 @@
 import { invoke } from "@tauri-apps/api/core"
 
-import { speakWithStackPrefs } from "@/util/speakWithStackPrefs"
+import { speakWithStackPrefs, speakConcurrentWithStackPrefs } from "@/util/speakWithStackPrefs"
 import { useSettingsStore } from "@/store/settings"
 import type { HostApi, PackDbQuery } from "./types"
 
@@ -87,6 +87,14 @@ export const createHostApi = (packId?: string): HostApi => {
     await speakWithStackPrefs(uiCode, text, rate)
   }
 
+  const speakConcurrent = async (uiCode: string, text: string): Promise<string> => {
+    if (disposed) {
+      return ""
+    }
+    const { rate } = useSettingsStore.getState()
+    return await speakConcurrentWithStackPrefs(uiCode, text, rate)
+  }
+
   const dispose = () => {
     disposed = true
   }
@@ -99,6 +107,9 @@ export const createHostApi = (packId?: string): HostApi => {
     speak: async (uiCode, text) => {
       await speakImmediate(uiCode, text)
     },
+    speakConcurrent: async (uiCode, text) => {
+      return await speakConcurrent(uiCode, text)
+    },
     stopSpeech,
     dispose,
     getStackConfig: () => {

corpan/corpan-app/src/contentPacks/hostApi.ts

@@ -36,6 +36,8 @@ export type PackDbQueryResult = {
 
 export type HostApi = {
   speak: (uiCode: string, text: string) => Promise<void>
+  /** Speak concurrently (allows overlapping audio). Returns utterance ID. */
+  speakConcurrent?: (uiCode: string, text: string) => Promise<string>
   stopSpeech?: () => Promise<void>
   dispose?: () => void
   getStackConfig: () => StackConfig

corpan/corpan-app/src/contentPacks/types.ts

@@ -96,6 +96,23 @@ async function speakNative(text: string, langPrefix: string, rate: number, voice
     });
 }
 
+/**
+ * Speak concurrently using the synthesizer pool (allows overlapping audio on macOS/iOS).
+ * On Android, falls back to sequential playback due to platform limitations.
+ * Returns an utterance ID for tracking completion.
+ */
+async function speakNativeConcurrent(text: string, langPrefix: string, rate: number, voiceId?: string): Promise<string> {
+    const result = await invoke<{ utteranceId: string }>("plugin:tts|speak_concurrent", {
+        args: {
+            text,
+            language: langPrefix,
+            rate,
+            voice_id: voiceId,
+        }
+    });
+    return result.utteranceId;
+}
+
 async function speakBrowser(text: string, langPrefix: string, rate: number, voiceId?: string) {
     if (!BROWSER_TTS) throw new Error("Web Speech API not available");
 
@@ -167,3 +184,34 @@ export function createVoiceTTS(langPrefix: string) {
         }
     };
 }
+
+/**
+ * Factory returning a concurrent `speak` function that allows overlapping audio.
+ * On macOS/iOS: true concurrent playback via synthesizer pool.
+ * On Android: sequential playback (platform limitation) but returns utterance ID.
+ * Returns an utterance ID for tracking completion.
+ * Usage: createVoiceTTSConcurrent("en-US")(text, 0.9, "com.apple....") => Promise<string>
+ */
+export function createVoiceTTSConcurrent(langPrefix: string) {
+    return async function speakConcurrent(text: string, rate: number = 0.7, voiceId?: string): Promise<string> {
+        // 1) Prefer native concurrent on macOS/iOS/Android when in Tauri.
+        try {
+            if (await preferNativeTTS()) {
+                return await speakNativeConcurrent(text, langPrefix, rate, voiceId);
+            }
+        } catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn(`[TTS:${langPrefix}] Native concurrent failed; falling back to browser`, err);
+        }
+
+        // 2) Fallback to browser (sequential - browser doesn't support concurrent easily).
+        try {
+            await speakBrowser(text, langPrefix, rate, voiceId);
+            return `browser_${Date.now()}`;
+        } catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn(`[TTS:${langPrefix}] Browser TTS failed`, err);
+            return `error_${Date.now()}`;
+        }
+    };
+}

corpan/corpan-app/src/util/speak.ts

@@ -2,11 +2,15 @@
 // honoring random/sequence; fall back to speaking by language if no preferred
 // IDs are currently available.
 
-import { createVoiceTTS } from "@/util/speak";
+import { createVoiceTTS, createVoiceTTSConcurrent } from "@/util/speak";
 import { useSettingsStore } from "@/store/settings";
 import { getVoicesCached } from "@/util/tts-voices";
 
-export async function speakWithStackPrefs(uiCode: string, text: string, rate: number) {
+/**
+ * Helper to get the voice ID to use based on stack preferences.
+ * Returns undefined if no preferred voice is available.
+ */
+async function getPreferredVoiceId(uiCode: string): Promise<string | undefined> {
     const state = useSettingsStore.getState();
     const { voicePrefs, nextVoiceId } = state;
 
@@ -20,28 +24,35 @@ export async function speakWithStackPrefs(uiCode: string, text: string, rate: nu
     const baseIds = basePref?.ids ?? [];
     const mergedPrefIds = Array.from(new Set([...exactIds, ...baseIds]));
 
-    // If there are no prefs at all, just speak with language
-    // console.log("mergedPrefIds", mergedPrefIds);
     if (mergedPrefIds.length === 0) {
-        await createVoiceTTS(uiCode)(text, rate);
-        return;
+        return undefined;
     }
 
     // Validate against currently available voices (native first, browser fallback)
     const available = await getVoicesCached({ maxAgeMs: 30_000 });
     const availableIds = new Set(available.map((v) => v.id));
     const pool = mergedPrefIds.filter((id) => availableIds.has(id));
 
-    // console.warn(pool)
     if (pool.length === 0) {
-        // Preferred IDs aren’t installed/available right now; speak by language
-        await createVoiceTTS(uiCode)(text, rate);
-        return;
+        return undefined;
     }
 
-    // Use the exact entry’s mode if present; otherwise base
+    // Use the exact entry's mode if present; otherwise base
     const langKeyForMode = exactPref ? uiCode : base;
-    const chosenId = nextVoiceId(langKeyForMode, pool);
+    return nextVoiceId(langKeyForMode, pool);
+}
 
+export async function speakWithStackPrefs(uiCode: string, text: string, rate: number) {
+    const chosenId = await getPreferredVoiceId(uiCode);
     await createVoiceTTS(uiCode)(text, rate, chosenId);
 }
+
+/**
+ * Speak concurrently using the synthesizer pool (allows overlapping audio on macOS/iOS).
+ * On Android, falls back to sequential playback due to platform limitations.
+ * Returns an utterance ID for tracking completion.
+ */
+export async function speakConcurrentWithStackPrefs(uiCode: string, text: string, rate: number): Promise<string> {
+    const chosenId = await getPreferredVoiceId(uiCode);
+    return await createVoiceTTSConcurrent(uiCode)(text, rate, chosenId);
+}

corpan/corpan-app/src/util/speakWithStackPrefs.ts

@@ -304,9 +304,12 @@ export const createJuiceSqueeze = (
     }
   }
 
-  // Speak without interrupting - allows audio to overlap
+  // Speak without interrupting - allows audio to overlap using concurrent TTS
   const speak = (lang: string, text: string) => {
-    if (typeof hostApi.speak === "function") {
+    // Prefer speakConcurrent for true overlapping audio
+    if (typeof hostApi.speakConcurrent === "function") {
+      hostApi.speakConcurrent(lang, text)
+    } else if (typeof hostApi.speak === "function") {
       hostApi.speak(lang, text)
     }
   }

corpan/packs/juice-squeeze/src/game.ts

@@ -23,6 +23,8 @@ export type EntryOut = {
 
 export type HostApi = {
   speak: (lang: string, text: string) => void
+  /** Speak concurrently (allows overlapping audio). Returns utterance ID. */
+  speakConcurrent?: (lang: string, text: string) => Promise<string>
   stopSpeech?: () => void
   getStackConfig: () => StackConfig
   onStackConfigChange?: (listener: (next: StackConfig) => void) => () => void