react-native-sherpa-onnx 0.3.6 → 0.3.7

package/android/src/main/java/com/sherpaonnx/SherpaOnnxModule.kt

@@ -8,6 +8,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.k2fsa.sherpa.onnx.WaveReader
 
 @ReactModule(name = SherpaOnnxModule.NAME)
 class SherpaOnnxModule(reactContext: ReactApplicationContext) :
@@ -314,6 +315,11 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     promise.resolve(null)
   }
 
+  override fun cancelExtractBySourcePath(sourcePath: String, promise: Promise) {
+    archiveHelper.cancelExtractBySourcePath(sourcePath)
+    promise.resolve(null)
+  }
+
   override fun computeFileSha256(filePath: String, promise: Promise) {
     archiveHelper.computeFileSha256(filePath, promise)
   }
@@ -452,6 +458,7 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     val provider = if (options.hasKey("provider")) options.getString("provider") else null
     val ruleFsts = if (options.hasKey("ruleFsts")) options.getString("ruleFsts") else null
     val ruleFars = if (options.hasKey("ruleFars")) options.getString("ruleFars") else null
+    val dither = if (options.hasKey("dither")) options.getDouble("dither") else null
     val blankPenalty = if (options.hasKey("blankPenalty")) options.getDouble("blankPenalty") else null
     val debug = if (options.hasKey("debug")) options.getBoolean("debug") else null
     val rule1MustContainNonSilence = if (options.hasKey("rule1MustContainNonSilence")) options.getBoolean("rule1MustContainNonSilence") else null
@@ -476,6 +483,7 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
       provider,
       ruleFsts,
       ruleFars,
+      dither,
       blankPenalty,
       debug,
       rule1MustContainNonSilence,
@@ -712,6 +720,72 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  /**
+   * Decode audio to mono float samples (approx. [-1, 1]) and effective sample rate.
+   * Same path/URI handling as [convertAudioToFormat]. WAV may use [WaveReader] when no resample is requested.
+   */
+  override fun decodeAudioFileToFloatSamples(inputPath: String, targetSampleRateHz: Double?, promise: Promise) {
+    var tmpFile: java.io.File? = null
+    try {
+      val targetHz = (targetSampleRateHz ?: 0.0).toInt()
+      if (targetHz < 0) {
+        promise.reject("DECODE_ERROR", "targetSampleRateHz must be >= 0")
+        return
+      }
+      val (pathToUse, tmp) = resolveInputForConvert(inputPath)
+      tmpFile = tmp
+
+      if (pathToUse.endsWith(".wav", ignoreCase = true)) {
+        try {
+          val wave = WaveReader.readWave(pathToUse)
+          val s = wave.samples
+          if (s != null && s.isNotEmpty() && wave.sampleRate > 0 && (targetHz == 0 || targetHz == wave.sampleRate)) {
+            val map = Arguments.createMap()
+            val arr = Arguments.createArray()
+            for (i in s.indices) {
+              arr.pushDouble(s[i].toDouble())
+            }
+            map.putArray("samples", arr)
+            map.putInt("sampleRate", wave.sampleRate)
+            promise.resolve(map)
+            return
+          }
+        } catch (_: Throwable) {
+          // Fall through to FFmpeg/native path (e.g. odd WAV or resample requested).
+        }
+      }
+
+      val result = Companion.nativeDecodeAudioFileToFloatSamples(pathToUse, targetHz)
+      if (result.size == 1 && result[0] is String) {
+        promise.reject("DECODE_ERROR", result[0] as String)
+        return
+      }
+      if (result.size != 2 || result[0] !is FloatArray) {
+        promise.reject("DECODE_ERROR", "Unexpected native decode result")
+        return
+      }
+      val floats = result[0] as FloatArray
+      val rateObj = result.getOrNull(1) as? Number ?: run {
+        promise.reject("DECODE_ERROR", "Unexpected sample rate in native decode result")
+        return
+      }
+      val sr = rateObj.toInt()
+      val map = Arguments.createMap()
+      val arr = Arguments.createArray()
+      for (i in floats.indices) {
+        arr.pushDouble(floats[i].toDouble())
+      }
+      map.putArray("samples", arr)
+      map.putInt("sampleRate", sr)
+      promise.resolve(map)
+    } catch (e: Exception) {
+      android.util.Log.e(NAME, "DECODE_EXCEPTION: ${e.message}", e)
+      promise.reject("DECODE_EXCEPTION", e.message ?: "Failed to decode audio", e)
+    } finally {
+      tmpFile?.delete()
+    }
+  }
+
   // ==================== TTS Methods ====================
 
   /**
@@ -1057,6 +1131,25 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  override fun readAssetFileAsUtf8(assetPath: String, promise: Promise) {
+    // Validate assetPath to prevent path traversal: reject paths containing
+    // "..", starting with "/" or "\", or containing backslashes.
+    if (assetPath.contains("..") ||
+        assetPath.startsWith("/") ||
+        assetPath.startsWith("\\") ||
+        assetPath.contains("\\")) {
+      promise.reject("ASSET_READ_ERROR", "Invalid asset path: $assetPath")
+      return
+    }
+    try {
+      val content = reactApplicationContext.assets.open(assetPath).bufferedReader().use { it.readText() }
+      promise.resolve(content)
+    } catch (e: Exception) {
+      android.util.Log.e(NAME, "Failed to read asset $assetPath: ${e.message}", e)
+      promise.reject("ASSET_READ_ERROR", "Failed to read asset $assetPath: ${e.message}", e)
+    }
+  }
+
   companion object {
     const val NAME = "SherpaOnnx"
 
@@ -1099,5 +1192,11 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     /** Convert any supported audio file to WAV 16 kHz mono 16-bit PCM. Returns empty string on success, error message otherwise. Requires FFmpeg prebuilts. */
     @JvmStatic
     private external fun nativeConvertAudioToWav16k(inputPath: String, outputPath: String): String
+
+    /**
+     * On success: [FloatArray samples, Integer sampleRate]. On error: [String message].
+     */
+    @JvmStatic
+    private external fun nativeDecodeAudioFileToFloatSamples(inputPath: String, targetSampleRateHz: Int): Array<Any>
   }
 }

package/android/src/main/java/com/sherpaonnx/SherpaOnnxOnlineSttHelper.kt

@@ -132,6 +132,7 @@ internal class SherpaOnnxOnlineSttHelper(
     provider: String?,
     ruleFsts: String?,
     ruleFars: String?,
+    dither: Float?,
     blankPenalty: Float?,
     debug: Boolean?,
     rule1MustContainNonSilence: Boolean?,
@@ -233,7 +234,7 @@ internal class SherpaOnnxOnlineSttHelper(
     }
 
     return OnlineRecognizerConfig(
-      featConfig = FeatureConfig(sampleRate = 16000, featureDim = 80, dither = 0f),
+      featConfig = FeatureConfig(sampleRate = 16000, featureDim = 80, dither = dither ?: 0f),
       modelConfig = modelConfig,
       endpointConfig = endpointConfig,
       enableEndpoint = enableEndpoint,
@@ -260,6 +261,7 @@ internal class SherpaOnnxOnlineSttHelper(
     provider: String?,
     ruleFsts: String?,
     ruleFars: String?,
+    dither: Double?,
     blankPenalty: Double?,
     debug: Boolean?,
     rule1MustContainNonSilence: Boolean?,
@@ -286,6 +288,7 @@ internal class SherpaOnnxOnlineSttHelper(
         provider = provider,
         ruleFsts = ruleFsts,
         ruleFars = ruleFars,
+        dither = dither?.toFloat(),
         blankPenalty = blankPenalty?.toFloat(),
         debug = debug,
         rule1MustContainNonSilence = rule1MustContainNonSilence,

package/android/src/main/java/com/sherpaonnx/SherpaOnnxTtsHelper.kt

@@ -30,6 +30,7 @@ import com.k2fsa.sherpa.onnx.OfflineTtsVitsModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsMatchaModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsKokoroModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsKittenModelConfig
+import com.k2fsa.sherpa.onnx.OfflineTtsZipVoiceModelConfig
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
@@ -64,8 +65,7 @@ internal class SherpaOnnxTtsHelper(
 
   private data class TtsEngineInstance(
     @Volatile var tts: OfflineTts? = null,
-    @Volatile var zipvoiceTts: ZipvoiceTtsWrapper? = null,
-    var ttsInitState: TtsInitState? = null,
+    @Volatile var ttsInitState: TtsInitState? = null,
     val ttsStreamRunning: AtomicBoolean = AtomicBoolean(false),
     val ttsStreamCancelled: AtomicBoolean = AtomicBoolean(false),
     var ttsStreamThread: Thread? = null,
@@ -73,15 +73,13 @@ internal class SherpaOnnxTtsHelper(
   ) {
     private val lock = Any()
 
-    fun hasEngine(): Boolean = synchronized(lock) { tts != null || zipvoiceTts != null }
-    val isZipvoice: Boolean get() = synchronized(lock) { zipvoiceTts != null }
+    fun hasEngine(): Boolean = synchronized(lock) { tts != null }
+    val isZipvoice: Boolean get() = ttsInitState?.modelType == "zipvoice"
     val isPocket: Boolean get() = ttsInitState?.modelType == "pocket"
     fun releaseEngines() {
       synchronized(lock) {
         tts?.release()
         tts = null
-        zipvoiceTts?.release()
-        zipvoiceTts = null
         ttsInitState = null
       }
     }
@@ -186,6 +184,13 @@ internal class SherpaOnnxTtsHelper(
           rejectOnUiThread(promise, "TTS_INIT_ERROR", msg)
           return@init
         }
+        val lexiconPath = path(paths, "lexicon")
+        if (lexiconPath.isBlank()) {
+          val msg = "Zipvoice requires lexicon.txt (or lexicon-<lang>.txt) in the model directory. The sherpa-onnx engine aborts if it is missing. Copy lexicon from the official k2-fsa sherpa-onnx Zipvoice model package or hr-files release next to tokens.txt."
+          Log.e("SherpaOnnxTts", "TTS_INIT_ERROR: $msg")
+          rejectOnUiThread(promise, "TTS_INIT_ERROR", msg)
+          return@init
+        }
         val am = context.applicationContext.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
         if (am != null) {
           val memInfo = ActivityManager.MemoryInfo()
@@ -206,34 +211,26 @@ internal class SherpaOnnxTtsHelper(
           Log.i("SherpaOnnxTts", "Zipvoice init: availMem=${memInfoBefore.availMem / (1024 * 1024)} MB (before load)")
         }
         val zipvoiceNumThreads = 1
-        val wrapper = ZipvoiceTtsWrapper.create(
-          tokens = path(paths, "tokens"),
-          encoder = path(paths, "encoder"),
-          decoder = path(paths, "decoder"),
-          vocoder = vocoderPath,
-          dataDir = path(paths, "dataDir"),
-          lexicon = path(paths, "lexicon"),
-          numThreads = zipvoiceNumThreads,
-          debug = debug,
-          ruleFsts = ruleFsts?.takeIf { it.isNotBlank() } ?: "",
-          ruleFars = ruleFars?.takeIf { it.isNotBlank() } ?: "",
-          maxNumSentences = maxNumSentences?.toInt()?.coerceAtLeast(1) ?: 1,
-          silenceScale = silenceScale?.toFloat()?.coerceIn(0f, 10f) ?: 0.2f,
-          provider = provider?.takeIf { it.isNotBlank() } ?: "cpu"
+        val config = buildTtsConfig(
+          paths, "zipvoice", zipvoiceNumThreads, debug,
+          noiseScale, noiseScaleW, lengthScale,
+          ruleFsts, ruleFars, maxNumSentences?.toInt(), silenceScale,
+          provider
         )
         if (am != null) {
           val memInfo = ActivityManager.MemoryInfo()
           am.getMemoryInfo(memInfo)
           Log.i("SherpaOnnxTts", "Zipvoice init: availMem=${memInfo.availMem / (1024 * 1024)} MB (after load)")
         }
-        if (wrapper == null) {
-          Log.e("SherpaOnnxTts", "TTS_INIT_ERROR: Failed to create Zipvoice TTS engine via C-API. Check logcat for details.")
-          rejectOnUiThread(promise, "TTS_INIT_ERROR", "Failed to create Zipvoice TTS engine via C-API. Check logcat for details.")
+        try {
+          inst.tts = OfflineTts(config = config)
+        } catch (e: Exception) {
+          Log.e("SherpaOnnxTts", "TTS_INIT_ERROR: Failed to create Zipvoice OfflineTts: ${e.message}", e)
+          rejectOnUiThread(promise, "TTS_INIT_ERROR", "Failed to create Zipvoice TTS engine: ${e.message}", e)
           return@init
         }
-        inst.zipvoiceTts = wrapper
-        sampleRate = wrapper.sampleRate()
-        numSpeakers = wrapper.numSpeakers()
+        sampleRate = inst.tts!!.sampleRate()
+        numSpeakers = inst.tts!!.numSpeakers()
       } else {
         val config = buildTtsConfig(
           paths, modelTypeStr, numThreads.toInt(), debug,
@@ -246,8 +243,6 @@ internal class SherpaOnnxTtsHelper(
         numSpeakers = inst.tts!!.numSpeakers()
       }
 
-      Log.i("SherpaOnnxTts", "initializeTts: instanceId=$instanceId, engine=${if (inst.isZipvoice) "zipvoice-c-api" else "kotlin-api"}, sampleRate=$sampleRate, numSpeakers=$numSpeakers")
-
       val modelsArray = Arguments.createArray()
       detectedModels?.forEach { modelObj ->
         if (modelObj is HashMap<*, *>) {
@@ -273,6 +268,8 @@ internal class SherpaOnnxTtsHelper(
         provider?.takeIf { it.isNotBlank() }
       )
 
+      Log.i("SherpaOnnxTts", "initializeTts: instanceId=$instanceId, engine=kotlin-api modelType=$modelTypeStr, sampleRate=$sampleRate, numSpeakers=$numSpeakers")
+
       val resultMap = Arguments.createMap()
       resultMap.putBoolean("success", true)
       resultMap.putArray("detectedModels", modelsArray)
@@ -309,18 +306,6 @@ internal class SherpaOnnxTtsHelper(
       return
     }
 
-    if (inst.isZipvoice) {
-      initializeTts(
-        instanceId,
-        state.modelDir, state.modelType, state.numThreads.toDouble(), state.debug,
-        noiseScale, noiseScaleW, lengthScale,
-        state.ruleFsts, state.ruleFars, state.maxNumSentences?.toDouble(), state.silenceScale,
-        state.provider,
-        promise
-      )
-      return
-    }
-
     val nextNoiseScale = when {
       noiseScale == null -> null
       noiseScale.isNaN() -> state.noiseScale
@@ -401,26 +386,35 @@ internal class SherpaOnnxTtsHelper(
       val sid = getSid(options)
       val speed = getSpeed(options)
       val audio = when {
-        hasReferenceOptions(options) && inst.isZipvoice -> {
-          val refAudio = options?.getArray("referenceAudio")
-            ?: run {
-              Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: referenceAudio required for Zipvoice voice cloning")
-              promise.reject("TTS_GENERATE_ERROR", "referenceAudio required for Zipvoice voice cloning")
+        hasReferenceAudio(options) && (inst.isZipvoice || inst.isPocket) -> {
+          if (inst.isZipvoice) {
+            val promptText = options!!.getString("referenceText")?.trim().orEmpty()
+            if (promptText.isEmpty()) {
+              Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: Zipvoice voice cloning requires non-empty referenceText")
+              promise.reject(
+                "TTS_GENERATE_ERROR",
+                "Zipvoice voice cloning requires non-empty referenceText (transcript of reference audio)."
+              )
               return
             }
-          val promptSr = if (options.hasKey("referenceSampleRate")) options.getDouble("referenceSampleRate").toInt() else 0
-          val promptText = options.getString("referenceText").orEmpty()
-          val numSteps = if (options.hasKey("numSteps")) options.getDouble("numSteps").toInt() else 20
-          val samples = FloatArray(refAudio.size()) { i -> refAudio.getDouble(i).toFloat() }
-          inst.zipvoiceTts!!.generateWithZipvoice(text, promptText, samples, promptSr, speed, numSteps)
-        }
-        hasReferenceOptions(options) && inst.tts != null -> {
+          }
           val config = parseGenerationConfig(options) ?: GenerationConfig(speed = speed, sid = sid)
           inst.tts!!.generateWithConfig(text, config)
         }
-        inst.isPocket && !hasReferenceOptions(options) -> {
+        hasReferenceAudio(options) -> {
+          Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: Reference audio is not supported for this TTS model type")
+          promise.reject(
+            "TTS_GENERATE_ERROR",
+            "Reference audio is only supported for Zipvoice and Pocket TTS."
+          )
+          return
+        }
+        inst.isPocket -> {
           Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: Pocket TTS requires reference audio for voice cloning")
-          promise.reject("TTS_GENERATE_ERROR", "Pocket TTS requires reference audio for voice cloning. Pass referenceAudio and referenceSampleRate in options.")
+          promise.reject(
+            "TTS_GENERATE_ERROR",
+            "Pocket TTS requires reference audio for voice cloning. Pass referenceAudio and referenceSampleRate (> 0) in options."
+          )
           return
         }
         else -> dispatchGenerate(inst, text, sid, speed)
@@ -459,26 +453,35 @@ internal class SherpaOnnxTtsHelper(
       val sid = getSid(options)
       val speed = getSpeed(options)
       val audio = when {
-        hasReferenceOptions(options) && inst.isZipvoice -> {
-          val refAudio = options?.getArray("referenceAudio")
-            ?: run {
-              Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: referenceAudio required for Zipvoice voice cloning")
-              promise.reject("TTS_GENERATE_ERROR", "referenceAudio required for Zipvoice voice cloning")
+        hasReferenceAudio(options) && (inst.isZipvoice || inst.isPocket) -> {
+          if (inst.isZipvoice) {
+            val promptText = options!!.getString("referenceText")?.trim().orEmpty()
+            if (promptText.isEmpty()) {
+              Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: Zipvoice voice cloning requires non-empty referenceText")
+              promise.reject(
+                "TTS_GENERATE_ERROR",
+                "Zipvoice voice cloning requires non-empty referenceText (transcript of reference audio)."
+              )
               return
             }
-          val promptSr = if (options.hasKey("referenceSampleRate")) options.getDouble("referenceSampleRate").toInt() else 0
-          val promptText = options.getString("referenceText").orEmpty()
-          val numSteps = if (options.hasKey("numSteps")) options.getDouble("numSteps").toInt() else 20
-          val samples = FloatArray(refAudio.size()) { i -> refAudio.getDouble(i).toFloat() }
-          inst.zipvoiceTts!!.generateWithZipvoice(text, promptText, samples, promptSr, speed, numSteps)
-        }
-        hasReferenceOptions(options) && inst.tts != null -> {
+          }
           val config = parseGenerationConfig(options) ?: GenerationConfig(speed = speed, sid = sid)
           inst.tts!!.generateWithConfig(text, config)
         }
-        inst.isPocket && !hasReferenceOptions(options) -> {
+        hasReferenceAudio(options) -> {
+          Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: Reference audio is not supported for this TTS model type")
+          promise.reject(
+            "TTS_GENERATE_ERROR",
+            "Reference audio is only supported for Zipvoice and Pocket TTS."
+          )
+          return
+        }
+        inst.isPocket -> {
           Log.e("SherpaOnnxTts", "TTS_GENERATE_ERROR: Pocket TTS requires reference audio for voice cloning")
-          promise.reject("TTS_GENERATE_ERROR", "Pocket TTS requires reference audio for voice cloning. Pass referenceAudio and referenceSampleRate in options.")
+          promise.reject(
+            "TTS_GENERATE_ERROR",
+            "Pocket TTS requires reference audio for voice cloning. Pass referenceAudio and referenceSampleRate (> 0) in options."
+          )
           return
         }
         else -> dispatchGenerate(inst, text, sid, speed)
@@ -529,16 +532,27 @@ internal class SherpaOnnxTtsHelper(
       promise.reject("TTS_STREAM_ERROR", "TTS not initialized")
       return
     }
-    if (inst.isPocket && !hasReferenceOptions(options)) {
+    if (inst.isPocket && !hasReferenceAudio(options)) {
       Log.e("SherpaOnnxTts", "TTS_STREAM_ERROR: Pocket TTS requires reference audio for voice cloning")
-      promise.reject("TTS_STREAM_ERROR", "Pocket TTS requires reference audio for voice cloning. Pass referenceAudio and referenceSampleRate in options.")
+      promise.reject(
+        "TTS_STREAM_ERROR",
+        "Pocket TTS requires reference audio for voice cloning. Pass referenceAudio and referenceSampleRate (> 0) in options."
+      )
       return
     }
-    if (hasReferenceOptions(options) && inst.isZipvoice) {
+    if (hasReferenceAudio(options) && inst.isZipvoice) {
       Log.e("SherpaOnnxTts", "TTS_STREAM_ERROR: Streaming with reference audio not supported for Zipvoice")
       promise.reject("TTS_STREAM_ERROR", "Streaming with reference audio not supported for Zipvoice")
       return
     }
+    if (hasReferenceAudio(options) && !inst.isPocket) {
+      Log.e("SherpaOnnxTts", "TTS_STREAM_ERROR: Reference audio streaming is only supported for Pocket TTS")
+      promise.reject(
+        "TTS_STREAM_ERROR",
+        "Reference audio streaming is only supported for Pocket TTS."
+      )
+      return
+    }
     val sid = getSid(options)
     val speed = getSpeed(options)
     inst.ttsStreamCancelled.set(false)
@@ -547,7 +561,7 @@ internal class SherpaOnnxTtsHelper(
       try {
         val sampleRate = dispatchSampleRate(inst)
         when {
-          hasReferenceOptions(options) && inst.tts != null -> {
+          hasReferenceAudio(options) && inst.isPocket -> {
             val config = parseGenerationConfig(options) ?: GenerationConfig(speed = speed, sid = sid)
             inst.tts!!.generateWithConfigAndCallback(text, config) { chunk ->
               if (inst.ttsStreamCancelled.get()) return@generateWithConfigAndCallback 0
@@ -555,13 +569,6 @@ internal class SherpaOnnxTtsHelper(
               chunk.size
             }
           }
-          inst.zipvoiceTts != null -> {
-            inst.zipvoiceTts!!.generateWithCallback(text, sid, speed) { chunk ->
-              if (inst.ttsStreamCancelled.get()) return@generateWithCallback 0
-              emitChunk(instanceId, requestId, chunk, sampleRate, 0f, false)
-              chunk.size
-            }
-          }
           else -> {
             inst.tts!!.generateWithCallback(text, sid, speed) { chunk ->
               if (inst.ttsStreamCancelled.get()) return@generateWithCallback 0
@@ -885,14 +892,21 @@ internal class SherpaOnnxTtsHelper(
 
   // -- Dual-engine dispatch helpers --
 
-  /** True if options contain reference-audio fields for voice cloning. */
-  private fun hasReferenceOptions(options: ReadableMap?): Boolean {
+  /**
+   * True when voice-cloning reference audio is present and valid for native use:
+   * non-empty [referenceAudio] array and [referenceSampleRate] > 0.
+   * [referenceText] alone does not enable cloning (matches sherpa-onnx behavior).
+   */
+  private fun hasReferenceAudio(options: ReadableMap?): Boolean {
     if (options == null) return false
-    val refAudio = options.getArray("referenceAudio")
-    val refText = options.getString("referenceText")
-    return (refAudio != null && refAudio.size() > 0) || !refText.isNullOrEmpty()
+    val refAudio = options.getArray("referenceAudio") ?: return false
+    if (refAudio.size() == 0) return false
+    return readReferenceSampleRate(options) > 0
   }
 
+  private fun readReferenceSampleRate(options: ReadableMap): Int =
+    if (options.hasKey("referenceSampleRate")) options.getDouble("referenceSampleRate").toInt() else 0
+
   /** Parse sid and speed from options with defaults. */
   private fun getSid(options: ReadableMap?): Int =
     if (options != null && options.hasKey("sid")) options.getDouble("sid").toInt() else 0
@@ -936,18 +950,14 @@ internal class SherpaOnnxTtsHelper(
 
   /** Dispatch generate to whichever engine is active on the instance. Returns null if none loaded. */
   private fun dispatchGenerate(inst: TtsEngineInstance, text: String, sid: Int, speed: Float): GeneratedAudio? {
-    inst.zipvoiceTts?.let { return it.generate(text, sid, speed) }
-    inst.tts?.let { return it.generate(text, sid, speed) }
-    return null
+    return inst.tts?.generate(text, sid, speed)
   }
 
   private fun dispatchSampleRate(inst: TtsEngineInstance): Int {
-    inst.zipvoiceTts?.let { return it.sampleRate() }
     return inst.tts?.sampleRate() ?: 0
   }
 
   private fun dispatchNumSpeakers(inst: TtsEngineInstance): Int {
-    inst.zipvoiceTts?.let { return it.numSpeakers() }
     return inst.tts?.numSpeakers() ?: 0
   }
 
@@ -1039,14 +1049,19 @@ internal class SherpaOnnxTtsHelper(
         debug = debug,
         provider = prov
       )
-      "zipvoice" -> {
-        // Zipvoice is handled by ZipvoiceTtsWrapper (C-API), not OfflineTts (Kotlin API).
-        // This branch should not be reached because initializeTts/updateTtsParams handle
-        // the "zipvoice" case before calling buildTtsConfig.
-        throw IllegalStateException(
-          "buildTtsConfig should not be called for zipvoice models. Use ZipvoiceTtsWrapper instead."
-        )
-      }
+      "zipvoice" -> OfflineTtsModelConfig(
+        zipvoice = OfflineTtsZipVoiceModelConfig(
+          tokens = path(paths, "tokens"),
+          encoder = path(paths, "encoder"),
+          decoder = path(paths, "decoder"),
+          vocoder = path(paths, "vocoder"),
+          dataDir = path(paths, "dataDir"),
+          lexicon = path(paths, "lexicon")
+        ),
+        numThreads = numThreads,
+        debug = debug,
+        provider = prov
+      )
       else -> {
         if (path(paths, "acousticModel").isNotEmpty()) {
           OfflineTtsModelConfig(