fix: bundle espeak-ng-data inside binary (fixes #59) (#60)

* fix: bundle espeak-ng-data inside binary (fixes #59)

Piper TTS failed on fresh installs with "No such file or directory"
because the espeak-ng C library statically linked into vox has the
build-machine data path hard-coded, and the release tarball never
shipped the espeak-ng-data files.

Embed the espeak-ng-data directory at build time via include_dir!
(staged from espeak-rs-sys's OUT_DIR by a new build.rs), extract it
once to ~/.config/vox/piper/espeak-ng-data on first piper call, and
set PIPER_ESPEAKNG_DATA_DIRECTORY so espeak-rs can locate it.

* fix: rustfmt build.rs

* ci: allow clippy::collapsible_match (pre-existing, surfaced by toolchain upgrade)

---------

Co-authored-by: patrick <patrick@rtk-ai.app>

Author: pszymkowiak

.github/workflows/ci.yml

@@ -82,6 +82,6 @@ jobs:
         run: cargo fmt -- --check
 
       - name: Clippy
-        run: cargo clippy ${{ matrix.features != '' && format('--features {0}', matrix.features) || '' }} -- -D warnings -A clippy::collapsible_if
+        run: cargo clippy ${{ matrix.features != '' && format('--features {0}', matrix.features) || '' }} -- -D warnings -A clippy::collapsible_if -A clippy::collapsible_match
         env:
           CUDA_COMPUTE_CAP: ${{ matrix.cuda == true && '89' || '' }}

Cargo.lock

@@ -29,6 +29,7 @@ rodio = "0.20"
 hound = "3"
 qwen3-tts = { git = "https://github.com/TrevorS/qwen3-tts-rs", features = ["hub"], default-features = false }
 piper-rs = { git = "https://github.com/thewh1teagle/piper-rs" }
+include_dir = "0.7"
 kokoro-tts = { version = "0.3", optional = true }
 toml = "0.8"
 ratatui = "0.29"

Cargo.toml

@@ -0,0 +1,97 @@
+//! Build script that locates the espeak-ng-data directory built by espeak-rs-sys
+//! and copies it into vox's OUT_DIR so it can be embedded via `include_dir!`.
+//!
+//! espeak-ng bakes a hard-coded data path into the compiled library (the path on
+//! the build machine). On end-user machines that path does not exist, which
+//! breaks piper TTS with "No such file or directory". To avoid that, we ship
+//! the data inside the binary and extract it at first use, then point espeak-rs
+//! at it via the `PIPER_ESPEAKNG_DATA_DIRECTORY` env var.
+
+use std::env;
+use std::path::{Path, PathBuf};
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    let out_dir = PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR not set"));
+
+    // OUT_DIR layout: <target>/<profile>/build/<crate>-<hash>/out
+    // Sibling crates' build artifacts live in <target>/<profile>/build/
+    let build_dir = out_dir
+        .ancestors()
+        .nth(2)
+        .expect("OUT_DIR has unexpected layout");
+
+    let espeak_data = find_espeak_data(build_dir).unwrap_or_else(|| {
+        panic!(
+            "espeak-ng-data not found under {}. \
+             espeak-rs-sys should have built it before this script runs.",
+            build_dir.display()
+        )
+    });
+
+    let dst = out_dir.join("espeak-ng-data");
+    copy_dir_recursive(&espeak_data, &dst).expect("failed to stage espeak-ng-data");
+
+    println!("cargo:rerun-if-changed={}", espeak_data.display());
+}
+
+fn find_espeak_data(build_dir: &Path) -> Option<PathBuf> {
+    let mut newest: Option<(std::time::SystemTime, PathBuf)> = None;
+    for entry in std::fs::read_dir(build_dir).ok()?.flatten() {
+        let name = entry.file_name();
+        let name_str = name.to_string_lossy();
+        if !name_str.starts_with("espeak-rs-sys-") {
+            continue;
+        }
+        let candidate = entry
+            .path()
+            .join("out")
+            .join("share")
+            .join("espeak-ng-data");
+        if !candidate.is_dir() {
+            continue;
+        }
+        let mtime = entry
+            .metadata()
+            .and_then(|m| m.modified())
+            .unwrap_or(std::time::SystemTime::UNIX_EPOCH);
+        match &newest {
+            Some((t, _)) if *t >= mtime => {}
+            _ => newest = Some((mtime, candidate)),
+        }
+    }
+    newest.map(|(_, p)| p)
+}
+
+fn copy_dir_recursive(src: &Path, dst: &Path) -> std::io::Result<()> {
+    if dst.exists() {
+        std::fs::remove_dir_all(dst)?;
+    }
+    std::fs::create_dir_all(dst)?;
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let path = entry.path();
+        let target = dst.join(entry.file_name());
+        let file_type = entry.file_type()?;
+        if file_type.is_dir() {
+            copy_dir_recursive(&path, &target)?;
+        } else if file_type.is_symlink() {
+            // Resolve symlinks so include_dir! sees real files.
+            let resolved = std::fs::read_link(&path)?;
+            let resolved = if resolved.is_absolute() {
+                resolved
+            } else {
+                path.parent().unwrap_or(Path::new("")).join(resolved)
+            };
+            if resolved.is_dir() {
+                copy_dir_recursive(&resolved, &target)?;
+            } else {
+                std::fs::copy(&resolved, &target)?;
+            }
+        } else {
+            std::fs::copy(&path, &target)?;
+        }
+    }
+    Ok(())
+}

build.rs

@@ -4,9 +4,10 @@
 //! Zero Python dependency. Model files auto-downloaded from HuggingFace.
 
 use std::path::PathBuf;
-use std::sync::Mutex;
+use std::sync::{Mutex, OnceLock};
 
 use anyhow::{Context, Result};
+use include_dir::{Dir, include_dir};
 use piper_rs::Piper;
 
 use super::{SpeakOptions, TtsBackend};
@@ -18,10 +19,51 @@ pub struct PiperBackend;
 /// Reloads when language changes (different ONNX model per language).
 static MODEL: Mutex<Option<(String, Piper)>> = Mutex::new(None);
 
+/// espeak-ng-data embedded at build time (staged by build.rs into OUT_DIR).
+/// Needed because the espeak-ng library statically linked into vox has a
+/// hard-coded data path from the CI builder that does not exist on user
+/// machines. We extract this once and point espeak-rs at the result.
+static ESPEAK_DATA: Dir<'_> = include_dir!("$OUT_DIR/espeak-ng-data");
+
+static ESPEAK_DATA_INIT: OnceLock<Result<PathBuf, String>> = OnceLock::new();
+
 fn models_dir() -> PathBuf {
     config::config_dir().join("piper")
 }
 
+/// Extract embedded espeak-ng-data to the user's config dir (once) and set the
+/// `PIPER_ESPEAKNG_DATA_DIRECTORY` env var so espeak-rs can locate it.
+fn ensure_espeak_data() -> Result<()> {
+    let result = ESPEAK_DATA_INIT.get_or_init(|| {
+        let parent = config::config_dir().join("piper");
+        let data_dir = parent.join("espeak-ng-data");
+        let sentinel = data_dir.join(".vox-extracted");
+
+        if !sentinel.exists() {
+            if data_dir.exists() {
+                std::fs::remove_dir_all(&data_dir).map_err(|e| e.to_string())?;
+            }
+            std::fs::create_dir_all(&data_dir).map_err(|e| e.to_string())?;
+            ESPEAK_DATA
+                .extract(&data_dir)
+                .map_err(|e| format!("failed to extract espeak-ng-data: {e}"))?;
+            std::fs::File::create(&sentinel).map_err(|e| e.to_string())?;
+        }
+
+        Ok(parent)
+    });
+
+    let parent = result.as_ref().map_err(|e| anyhow::anyhow!("{e}"))?;
+
+    // SAFETY: espeak-rs reads this env var inside a OnceLock-guarded init that
+    // runs on the first phonemizer call. We set it before any piper call, so
+    // there is no race with other threads reading PIPER_ESPEAKNG_DATA_DIRECTORY.
+    unsafe {
+        std::env::set_var("PIPER_ESPEAKNG_DATA_DIRECTORY", parent);
+    }
+    Ok(())
+}
+
 /// Map lang code to (model_name, download_base_url).
 fn model_for_lang(lang: &str) -> (&'static str, &'static str) {
     match lang {
@@ -113,6 +155,8 @@ fn ensure_model(lang: &str) -> Result<(PathBuf, PathBuf)> {
 fn get_or_load_model(
     lang: &str,
 ) -> Result<std::sync::MutexGuard<'static, Option<(String, Piper)>>> {
+    ensure_espeak_data()?;
+
     let mut guard = MODEL
         .lock()
         .map_err(|e| anyhow::anyhow!("model lock poisoned: {e}"))?;