react-native-sherpa-onnx 0.3.7 → 0.3.9

package/README.md

@@ -78,6 +78,8 @@ If you use the [download manager](docs/download-manager.md) to fetch models at r
 
 Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-manager.md#setup-ios--android). Expo users can use the library’s config plugin to apply this automatically.
 
+**Android:** Foreground service permissions (Play Console), visible download notifications, and **`POST_NOTIFICATIONS` (API 33+)** are covered in [Download manager – Android: foreground service & notifications](docs/download-manager.md#android-foreground-service--notifications).
+
 ## Table of contents
 
 - [Bundled sherpa-onnx version](#bundled-sherpa-onnx-version)
@@ -124,8 +126,8 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 | Model quantization | ✅ **Supported** | [Model setup](./docs/model-setup.md) | Automatic detection and preference for quantized (int8) models. |
 | Flexible model loading | ✅ **Supported** | [Model setup](./docs/model-setup.md) | Asset models, file system models, or auto-detection. |
 | TypeScript | ✅ **Supported** | — | Full type definitions included. |
-| Speaker Diarization | ❌ Not yet supported | [Diarization](./docs/diarization.md) | Scheduled for release 0.4.0 |
-| Speech Enhancement | ❌ Not yet supported | [Enhancement](./docs/enhancement.md) | Scheduled for release 0.5.0 |
+| Speech Enhancement | ❌ Not yet supported | [Enhancement](./docs/enhancement.md) | Scheduled for release 0.4.0 |
+| Speaker Diarization | ❌ Not yet supported | [Diarization](./docs/diarization.md) | Scheduled for release 0.5.0 |
 | Source Separation | ❌ Not yet supported | [Separation](./docs/separation.md) | Scheduled for release 0.6.0 |
 | VAD (Voice Activity Detection) | ❌ Not yet supported | [VAD](./docs/vad.md) | Scheduled for release 0.7.0 |
 
@@ -146,6 +148,7 @@ Full step-by-step: [Download manager – Setup (iOS & Android)](docs/download-ma
 
 | Model Type               | `modelType` Value | Description                                                                              | Download Links                                                                                   |
 | ------------------------ | ----------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| **Auto Detect**          | `'auto'`          | Automatically detects model layout/type from files in the model folder and picks the best supported STT type. | n/a |
 | **Zipformer/Transducer** | `'transducer'`    | Encoder–decoder–joiner (e.g. icefall). Good balance of speed and accuracy. Folder name should contain **zipformer** or **transducer** for auto-detection. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-transducer/index.html) |
 | **LSTM Transducer**      | `'transducer'`    | Same layout as Zipformer (encoder–decoder–joiner). LSTM-based streaming ASR; detected as transducer. Folder name may contain **lstm**. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/online-transducer/lstm-transducer-models.html) |
 | **Paraformer**           | `'paraformer'`    | Single-model non-autoregressive ASR; fast and accurate. Detected by `model.onnx`; no folder token required. | [Download](https://k2-fsa.github.io/sherpa/onnx/pretrained_models/offline-paraformer/index.html) |
@@ -170,12 +173,14 @@ For **real-time (streaming) recognition** from a microphone or audio stream, use
 
 | Model Type       | `modelType` Value | Description                                                                                          | Download Links                                                                      |
 | ---------------- | ----------------- | ---------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| **Auto Detect**   | `'auto'`              | Automatically detects the TTS model layout from files in the model folder and selects the matching supported type. | n/a |
 | **VITS**         | `'vits'`          | Fast, high-quality TTS (Piper, Coqui, MeloTTS, MMS). Folder name should contain **vits** if used with other voice models. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
 | **Matcha**       | `'matcha'`        | High-quality acoustic model + vocoder. Detected by acoustic_model + vocoder; no folder token required. | [Download](https://k2-fsa.github.io/sherpa/onnx/tts/pretrained_models/matcha.html) |
 | **Kokoro**       | `'kokoro'`        | Multi-speaker, multi-language. Folder name should contain **kokoro** (not kitten) for auto-detection. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
 | **KittenTTS**    | `'kitten'`        | Lightweight, multi-speaker. Folder name should contain **kitten** (not kokoro) for auto-detection. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models)          |
 | **Zipvoice**     | `'zipvoice'`      | Standard TTS with **`sid`**. **Voice cloning** (reference audio + `referenceText`): batch via **`generateSpeech`** only—streaming TTS does not support reference audio for Zipvoice. Default **`numSteps`** when omitted is **5** on **Android and iOS** (matches sherpa-onnx `GenerationConfig` / Kotlin helper). Cloning is **supported on Android & iOS**. Encoder + decoder + vocoder. | [Download](https://k2-fsa.github.io/sherpa/onnx/tts/pretrained_models/zipvoice.html) |
 | **Pocket**       | `'pocket'`        | Flow-matching TTS. **Voice cloning** on **Android:** batch and streaming TTS. **iOS:** cloning is experimental. Detected by lm_flow, lm_main, text_conditioner, vocab/token_scores. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models) |
+| **Supertonic**    | `'supertonic'`        | Lightning-fast, on-device text-to-speech system designed for extreme performance with minimal computational overhead. | [Download](https://github.com/k2-fsa/sherpa-onnx/releases/tag/tts-models) |
 
 For **streaming TTS** (incremental generation, low latency), use `createStreamingTTS()` with supported model types. See [Streaming Text-to-Speech](./docs/tts-streaming.md).
 

package/SherpaOnnx.podspec

@@ -140,7 +140,10 @@ Pod::Spec.new do |s|
   s.libraries = "c++", "z", "iconv", "bz2"
 
   # Per-release-model license metadata (synced from CI; same CSV as android/src/main/assets/model_licenses/).
-  s.resources = ["ios/Resources/model_licenses/*.csv"]
+  # Use resource_bundles so assets are packaged reliably across CocoaPods integration modes.
+  s.resource_bundles = {
+    "SherpaOnnxResources" => ["ios/Resources/model_licenses/*.csv"]
+  }
 
   install_modules_dependencies(s)
 end

package/android/prebuilt-download.gradle

@@ -222,14 +222,14 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             sherpaVersionFile.text = currentSherpaVersion
             sherpaResolved = true
             println "[sherpa-onnx] jniLibs (*.so per ABI) .............. MAVEN_AAR  ${aar.name}"
-            println "[sherpa-onnx]   install: jni/<abi>/*.so → ${jniLibsHuman}/<abi>/"
-            println "[sherpa-onnx] C headers (sherpa-onnx) ............. ${copiedHeaders ? 'MAVEN_AAR  c-api/** → ' + includeSherpaDir : 'unchanged (no c-api/ in AAR; existing tree kept)'}"
+            println "[sherpa-onnx]   install: jni/<abi>/*.so --> ${jniLibsHuman}/<abi>/"
+            println "[sherpa-onnx] C headers (sherpa-onnx) ............. ${copiedHeaders ? 'MAVEN_AAR  c-api/** --> ' + includeSherpaDir : 'unchanged (no c-api/ in AAR; existing tree kept)'}"
             println "[sherpa-onnx] version stamp ...................... written  ${sherpaVersionFile.name}=${currentSherpaVersion}"
           } else {
-            println "[sherpa-onnx] MAVEN_AAR: sherpaOnnxAar empty → trying GITHUB_RELEASE"
+            println "[sherpa-onnx] MAVEN_AAR: sherpaOnnxAar empty --> trying GITHUB_RELEASE"
           }
         } catch (Exception e) {
-          println "[sherpa-onnx] MAVEN_AAR failed: ${e.message} → trying GITHUB_RELEASE"
+          println "[sherpa-onnx] MAVEN_AAR failed: ${e.message} --> trying GITHUB_RELEASE"
         }
       }
     } else {
@@ -290,14 +290,14 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             ffmpegVersionFile.text = currentFfmpegVersion
             ffmpegResolved = true
             println "[FFmpeg] jniLibs .................................. MAVEN_AAR  ${aar.name}"
-            println "[FFmpeg]   install: jni/<abi>/*.so → ${jniLibsHuman}/<abi>/"
-            println "[FFmpeg] C headers ................................ ${copiedHdr ? 'MAVEN_AAR  include/** → ' + ffmpegIncludeDir : 'unchanged (no include/ in AAR)'}"
+            println "[FFmpeg]   install: jni/<abi>/*.so --> ${jniLibsHuman}/<abi>/"
+            println "[FFmpeg] C headers ................................ ${copiedHdr ? 'MAVEN_AAR  include/** --> ' + ffmpegIncludeDir : 'unchanged (no include/ in AAR)'}"
             println "[FFmpeg] version stamp ............................ written  ${ffmpegVersionFile.name}=${currentFfmpegVersion}"
           } else {
-            println "[FFmpeg] MAVEN_AAR: ffmpegAar empty → trying GITHUB_RELEASE"
+            println "[FFmpeg] MAVEN_AAR: ffmpegAar empty --> trying GITHUB_RELEASE"
           }
         } catch (Exception e) {
-          println "[FFmpeg] MAVEN_AAR failed: ${e.message} → trying GITHUB_RELEASE"
+          println "[FFmpeg] MAVEN_AAR failed: ${e.message} --> trying GITHUB_RELEASE"
         }
       }
     } else {
@@ -358,14 +358,14 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             libarchiveVersionFile.text = currentLibarchiveVersion
             libarchiveResolved = true
             println "[libarchive] jniLibs .............................. MAVEN_AAR  ${aar.name}"
-            println "[libarchive]   install: jni/<abi>/*.so → ${jniLibsHuman}/<abi>/"
-            println "[libarchive] C headers ............................ ${copiedHdr ? 'MAVEN_AAR  include/** → ' + libarchiveIncludeDir : 'unchanged (no include/ in AAR)'}"
+            println "[libarchive]   install: jni/<abi>/*.so --> ${jniLibsHuman}/<abi>/"
+            println "[libarchive] C headers ............................ ${copiedHdr ? 'MAVEN_AAR  include/** --> ' + libarchiveIncludeDir : 'unchanged (no include/ in AAR)'}"
             println "[libarchive] version stamp ........................ written  ${libarchiveVersionFile.name}=${currentLibarchiveVersion}"
           } else {
-            println "[libarchive] MAVEN_AAR: libarchiveAar empty → trying GITHUB_RELEASE"
+            println "[libarchive] MAVEN_AAR: libarchiveAar empty --> trying GITHUB_RELEASE"
           }
         } catch (Exception e) {
-          println "[libarchive] MAVEN_AAR failed: ${e.message} → trying GITHUB_RELEASE"
+          println "[libarchive] MAVEN_AAR failed: ${e.message} --> trying GITHUB_RELEASE"
         }
       }
     } else {
@@ -415,7 +415,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
             }
             ortJniResolved = true
             println "[onnxruntime] libonnxruntime4j_jni.so .......... MAVEN_AAR  ${aar.name}"
-            println "[onnxruntime]   install: per ABI → ${jniLibsHuman}/<abi>/ (only JNI bridge; libonnxruntime.so from sherpa prebuilts)"
+            println "[onnxruntime]   install: per ABI --> ${jniLibsHuman}/<abi>/ (only JNI bridge; libonnxruntime.so from sherpa prebuilts)"
           } else {
             println "[onnxruntime] MAVEN_AAR: onnxruntimeAar empty — libonnxruntime4j_jni.so still missing"
           }
@@ -436,7 +436,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       def needLibarchive = !sherpaOnnxDisableLibarchive && !libarchiveResolved
       def needSherpa = !sherpaResolved
       if (needFfmpeg || needLibarchive || needSherpa) {
-        println "[prebuilt] GITHUB_RELEASE: skipped (no repo). Set -PprebuiltGitHubRepo=owner/repo or git remote origin → github.com"
+        println "[prebuilt] GITHUB_RELEASE: skipped (no repo). Set -PprebuiltGitHubRepo=owner/repo or git remote origin --> github.com"
         println "[prebuilt]   still need: sherpa=${needSherpa}, ffmpeg=${needFfmpeg}, libarchive=${needLibarchive}"
         def diag = [
           "prebuiltGitHubRepo=${project.findProperty('prebuiltGitHubRepo') ?: '(not set)'}",
@@ -492,7 +492,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       ffmpegVersionFile.text = currentFfmpegVersion
       println "[FFmpeg] jniLibs + C headers ...................... GITHUB_RELEASE  tag=${tag}"
       println "[FFmpeg]   url: ${url}"
-      println "[FFmpeg]   install: <abi>/*.so → ${jniLibsHuman}/"
+      println "[FFmpeg]   install: <abi>/*.so --> ${jniLibsHuman}/"
       println "[FFmpeg] version stamp .......................... written  ${ffmpegVersionFile.name}=${currentFfmpegVersion}"
     }
 
@@ -522,7 +522,7 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       libarchiveVersionFile.text = currentLibarchiveVersion
       println "[libarchive] jniLibs + C headers .................. GITHUB_RELEASE  tag=${tag}"
       println "[libarchive]   url: ${url}"
-      println "[libarchive]   install: <abi>/*.so → ${jniLibsHuman}/"
+      println "[libarchive]   install: <abi>/*.so --> ${jniLibsHuman}/"
       println "[libarchive] version stamp ........................ written  ${libarchiveVersionFile.name}=${currentLibarchiveVersion}"
     }
 
@@ -560,8 +560,8 @@ project.tasks.register("downloadNativeLibsIfNeeded") {
       sherpaVersionFile.text = currentSherpaVersion
       println "[sherpa-onnx] jniLibs + C headers ................. GITHUB_RELEASE  tag=${tag}"
       println "[sherpa-onnx]   url: ${url}"
-      println "[sherpa-onnx]   install: <abi>/*.so → ${jniLibsHuman}/"
-      println "[sherpa-onnx] classes.jar ......................... ${sherpaJavaJar.exists() ? 'GITHUB_RELEASE  → ' + sherpaOnnxClassesDir : 'not in zip (use extractSherpaOnnxClasses)'}"
+      println "[sherpa-onnx]   install: <abi>/*.so --> ${jniLibsHuman}/"
+      println "[sherpa-onnx] classes.jar ......................... ${sherpaJavaJar.exists() ? 'GITHUB_RELEASE  --> ' + sherpaOnnxClassesDir : 'not in zip (use extractSherpaOnnxClasses)'}"
       println "[sherpa-onnx] version stamp ...................... written  ${sherpaVersionFile.name}=${currentSherpaVersion}"
     }
     println ""
@@ -612,7 +612,7 @@ project.afterEvaluate {
   project.tasks.findByName('preBuild')?.dependsOn(project.tasks.findByName('checkJniLibs'))
 }
 
-// sherpa-onnx classes.jar: resolution order THIRD_PARTY → MAVEN_AAR → GITHUB_EXTRACT
+// sherpa-onnx classes.jar: resolution order THIRD_PARTY --> MAVEN_AAR --> GITHUB_EXTRACT
 def sherpaLocalJar = file("${project.projectDir.parent}/third_party/sherpa-onnx-prebuilt/android/java/classes.jar")
 def sherpaExtractedJar = file("${project.buildDir}/prebuilt-downloads/sherpa-onnx-extract/java/classes.jar")
 
@@ -627,7 +627,7 @@ project.tasks.register("extractSherpaOnnxClasses") {
       copy { from sherpaLocalJar; into sherpaOnnxClassesDir }
       println "[prebuilt] extractSherpaOnnxClasses"
       println "[sherpa-onnx] classes.jar (Kotlin API) .......... THIRD_PARTY"
-      println "[sherpa-onnx]   ${sherpaLocalJar.absolutePath} → ${sherpaOnnxClassesDir}"
+      println "[sherpa-onnx]   ${sherpaLocalJar.absolutePath} --> ${sherpaOnnxClassesDir}"
       return
     }
     def aarFiles = project.configurations.sherpaOnnxAar.files
@@ -640,14 +640,14 @@ project.tasks.register("extractSherpaOnnxClasses") {
       }
       println "[prebuilt] extractSherpaOnnxClasses"
       println "[sherpa-onnx] classes.jar (Kotlin API) .......... MAVEN_AAR  ${aar.name}"
-      println "[sherpa-onnx]   classes.jar → ${sherpaOnnxClassesDir}"
+      println "[sherpa-onnx]   classes.jar --> ${sherpaOnnxClassesDir}"
       return
     }
     if (sherpaExtractedJar.exists()) {
       copy { from sherpaExtractedJar; into sherpaOnnxClassesDir }
       println "[prebuilt] extractSherpaOnnxClasses"
       println "[sherpa-onnx] classes.jar (Kotlin API) .......... GITHUB_EXTRACT"
-      println "[sherpa-onnx]   ${sherpaExtractedJar.absolutePath} → ${sherpaOnnxClassesDir}"
+      println "[sherpa-onnx]   ${sherpaExtractedJar.absolutePath} --> ${sherpaOnnxClassesDir}"
       return
     }
     throw new RuntimeException(
@@ -678,7 +678,7 @@ project.tasks.register("extractOnnxruntimeClasses") {
       }
       println "[prebuilt] extractOnnxruntimeClasses"
       println "[onnxruntime] classes.jar (Java API) ........... MAVEN_AAR  ${aar.name}"
-      println "[onnxruntime]   renamed to onnxruntime-classes.jar → ${onnxruntimeClassesDir}"
+      println "[onnxruntime]   renamed to onnxruntime-classes.jar --> ${onnxruntimeClassesDir}"
       return
     }
     throw new RuntimeException(

package/android/src/main/assets/model_licenses/asr-models-license-status.csv

@@ -397,6 +397,7 @@ sherpa-onnx-rk3576-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high
 sherpa-onnx-rk3568-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-06-26
 sherpa-onnx-rk3566-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-06-26
 sherpa-onnx-rk3562-streaming-zipformer-en-2023-06-26.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/sherpa-onnx-streaming-zipformer-en-2023-06-26
+sherpa-onnx-qwen3-asr-0.6B-int8-2026-03-25.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/Qwen/Qwen3-ASR-0.6B
 sherpa-onnx-rk3588-streaming-zipformer-small-bilingual-zh-en-2023-02-16.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/k2fsa-zipformer-bilingual-zh-en-t
 sherpa-onnx-rk3588-streaming-zipformer-bilingual-zh-en-2023-02-20.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/k2fsa-zipformer-bilingual-zh-en-t
 sherpa-onnx-rk3576-streaming-zipformer-small-bilingual-zh-en-2023-02-16.tar.bz2,apache-2.0,yes,high,manual,https://huggingface.co/csukuangfj/k2fsa-zipformer-bilingual-zh-en-t

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-helper.cpp

@@ -389,5 +389,28 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     return candidates;
 }
 
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dirRaw
+) {
+    std::string dir = dirRaw;
+    while (!dir.empty() && (dir.back() == '/' || dir.back() == '\\'))
+        dir.pop_back();
+    if (dir.empty()) return false;
+    bool hasVocab = false;
+    bool hasMerges = false;
+    const std::string prefix = dir + "/";
+    for (const auto& e : files) {
+        if (e.path.size() <= prefix.size()) continue;
+        if (e.path.compare(0, prefix.size(), prefix) != 0) continue;
+        std::string rest = e.path.substr(prefix.size());
+        if (rest.find('/') != std::string::npos || rest.find('\\') != std::string::npos) continue;
+        if (e.nameLower == "vocab.json") hasVocab = true;
+        if (e.nameLower == "merges.txt") hasMerges = true;
+    }
+    if (hasVocab && hasMerges) return true;
+    return FileExists(dir + "/vocab.json") && FileExists(dir + "/merges.txt");
+}
+
 } // namespace model_detect
 } // namespace sherpaonnx

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-helper.h

@@ -88,6 +88,15 @@ std::vector<LexiconCandidate> FindLexiconCandidates(
     const std::string& rootDir
 );
 
+/**
+ * True if `dir` contains vocab.json and merges.txt: listed in `files` (fixture / synthetic trees)
+ * or present on disk. Used for Qwen3-ASR tokenizer directory detection.
+ */
+bool Qwen3TokenizerDirHasVocabAndMerges(
+    const std::vector<FileEntry>& files,
+    const std::string& dir
+);
+
 } // namespace model_detect
 } // namespace sherpaonnx
 

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-stt.cpp

@@ -61,6 +61,7 @@ static const char* KindToName(SttModelKind k) {
         case SttModelKind::kZipformerCtc: return "zipformer_ctc";
         case SttModelKind::kWhisper: return "whisper";
         case SttModelKind::kFunAsrNano: return "funasr_nano";
+        case SttModelKind::kQwen3Asr: return "qwen3_asr";
         case SttModelKind::kFireRedAsr: return "fire_red_asr";
         case SttModelKind::kMoonshine: return "moonshine";
         case SttModelKind::kMoonshineV2: return "moonshine_v2";
@@ -88,6 +89,7 @@ SttModelKind ParseSttModelType(const std::string& modelType) {
     if (modelType == "zipformer_ctc" || modelType == "ctc") return SttModelKind::kZipformerCtc;
     if (modelType == "whisper") return SttModelKind::kWhisper;
     if (modelType == "funasr_nano") return SttModelKind::kFunAsrNano;
+    if (modelType == "qwen3_asr") return SttModelKind::kQwen3Asr;
     if (modelType == "fire_red_asr") return SttModelKind::kFireRedAsr;
     if (modelType == "moonshine") return SttModelKind::kMoonshine;
     if (modelType == "moonshine_v2") return SttModelKind::kMoonshineV2;
@@ -126,6 +128,8 @@ static bool CapabilitySupportsKind(
             return cap.hasWhisper;
         case SttModelKind::kFunAsrNano:
             return cap.hasFunAsrNano;
+        case SttModelKind::kQwen3Asr:
+            return cap.hasQwen3Asr;
         case SttModelKind::kFireRedAsr:
             return cap.hasFireRedAsr;
         case SttModelKind::kMoonshine:
@@ -189,6 +193,8 @@ static std::vector<SttModelKind> GetKindsFromDirName(const std::string& modelDir
         add(SttModelKind::kTransducer);
         add(SttModelKind::kZipformerCtc);
     }
+    if (lower.find("qwen3-asr") != std::string::npos || lower.find("qwen3_asr") != std::string::npos)
+        add(SttModelKind::kQwen3Asr);
     if (lower.find("funasr") != std::string::npos)
         add(SttModelKind::kFunAsrNano);
     if (lower.find("canary") != std::string::npos)
@@ -249,6 +255,19 @@ static SttCandidatePaths GatherSttCandidatePaths(
                 p.funasrTokenizerDir = vocabInSubdir.substr(0, lastSlash);
         }
     }
+    p.qwen3ConvFrontend = FindOnnxByAnyToken(files, {"conv_frontend"}, preferInt8);
+    {
+        for (const auto& entry : files) {
+            if (entry.nameLower != "tokenizer_config.json") continue;
+            size_t slash = entry.path.find_last_of("/\\");
+            if (slash == std::string::npos) continue;
+            std::string dir = entry.path.substr(0, slash);
+            if (Qwen3TokenizerDirHasVocabAndMerges(files, dir)) {
+                p.qwen3TokenizerDir = dir;
+                break;
+            }
+        }
+    }
     p.moonshinePreprocessor = FindOnnxByAnyToken(files, {"preprocess", "preprocessor"}, preferInt8);
     p.moonshineEncoder = FindOnnxByAnyToken(files, {"encode", "encoder_model"}, preferInt8);
     p.moonshineUncachedDecoder = FindOnnxByAnyToken(files, {"uncached_decode", "uncached"}, preferInt8);
@@ -258,7 +277,8 @@ static SttCandidatePaths GatherSttCandidatePaths(
     static const std::vector<std::string> modelExcludes = {
         "encoder", "decoder", "joiner", "vocoder", "acoustic", "embedding", "llm",
         "encoder_adaptor", "encoder-adaptor", "encoder_model", "decoder_model",
-        "merged_decoder", "decoder_model_merged", "preprocess", "encode", "uncached", "cached"
+        "merged_decoder", "decoder_model_merged", "preprocess", "encode", "uncached", "cached",
+        "conv_frontend"
     };
     p.paraformerModel = FindOnnxByAnyToken(files, {"model"}, preferInt8);
     if (!p.paraformerModel.empty()) {
@@ -302,6 +322,7 @@ static SttPathHints GetSttPathHints(const std::string& modelDir) {
     h.isLikelyWenetCtc = lower.find("wenet") != std::string::npos;
     h.isLikelySenseVoice = lower.find("sense") != std::string::npos || lower.find("sensevoice") != std::string::npos;
     h.isLikelyFunAsrNano = lower.find("funasr") != std::string::npos || lower.find("funasr-nano") != std::string::npos;
+    h.isLikelyQwen3Asr = lower.find("qwen3-asr") != std::string::npos || lower.find("qwen3_asr") != std::string::npos;
     h.isLikelyZipformer = lower.find("zipformer") != std::string::npos;
     h.isLikelyMoonshine = lower.find("moonshine") != std::string::npos;
     h.isLikelyDolphin = lower.find("dolphin") != std::string::npos;
@@ -404,7 +425,9 @@ static SttCapabilities ComputeSttCapabilities(const SttCandidatePaths& paths, co
     c.hasTransducer = !paths.encoder.empty() && !paths.decoder.empty() && !paths.joiner.empty();
     bool hasWhisperEnc = !paths.encoder.empty();
     bool hasWhisperDec = !paths.decoder.empty();
-    c.hasWhisper = hasWhisperEnc && hasWhisperDec && paths.joiner.empty();
+    bool hasQwen3Tok = !paths.qwen3TokenizerDir.empty();
+    c.hasQwen3Asr = !paths.qwen3ConvFrontend.empty() && hasWhisperEnc && hasWhisperDec && hasQwen3Tok;
+    c.hasWhisper = hasWhisperEnc && hasWhisperDec && paths.joiner.empty() && !c.hasQwen3Asr;
     bool hasFunAsrTok = !paths.funasrTokenizerDir.empty();
     c.hasFunAsrNano = !paths.funasrEncoderAdaptor.empty() && !paths.funasrLLM.empty() &&
                       !paths.funasrEmbedding.empty() && hasFunAsrTok;
@@ -446,6 +469,7 @@ static void CollectDetectedModels(
         out.push_back({"paraformer", modelDir});
     }
     if (cap.hasWhisper) out.push_back({"whisper", modelDir});
+    if (cap.hasQwen3Asr) out.push_back({"qwen3_asr", modelDir});
     if (cap.hasFunAsrNano) out.push_back({"funasr_nano", modelDir});
     if (cap.hasMoonshine) out.push_back({"moonshine", modelDir});
     if (cap.hasMoonshineV2) out.push_back({"moonshine_v2", modelDir});
@@ -507,6 +531,10 @@ static SttModelKind ResolveSttKind(
             outError = "FunASR Nano model requested but required files not found in " + modelDir;
             return SttModelKind::kUnknown;
         }
+        if (selected == SttModelKind::kQwen3Asr && !cap.hasQwen3Asr) {
+            outError = "Qwen3-ASR model requested but conv_frontend/encoder/decoder/tokenizer not found in " + modelDir;
+            return SttModelKind::kUnknown;
+        }
         if (selected == SttModelKind::kMoonshine && !cap.hasMoonshine) {
             outError = "Moonshine v1 model requested but preprocess/encode/uncached_decode/cached_decode not found in " + modelDir;
             return SttModelKind::kUnknown;
@@ -573,7 +601,9 @@ static SttModelKind ResolveSttKind(
     if (!paths.paraformerModel.empty()) return SttModelKind::kParaformer;
     if (cap.hasCanary) return SttModelKind::kCanary;
     if (cap.hasFireRedAsr) return SttModelKind::kFireRedAsr;
+    if (cap.hasQwen3Asr && hints.isLikelyQwen3Asr) return SttModelKind::kQwen3Asr;
     if (cap.hasWhisper) return SttModelKind::kWhisper;
+    if (cap.hasQwen3Asr) return SttModelKind::kQwen3Asr;
     if (cap.hasFunAsrNano) return SttModelKind::kFunAsrNano;
     if (cap.hasMoonshineV2) return SttModelKind::kMoonshineV2;
     if (cap.hasDolphin) return SttModelKind::kDolphin;
@@ -618,6 +648,12 @@ static void ApplyPathsForSttKind(SttModelKind kind, const SttCandidatePaths& can
             resultPaths.funasrEmbedding = candidate.funasrEmbedding;
             resultPaths.funasrTokenizer = candidate.funasrTokenizerDir;
             break;
+        case SttModelKind::kQwen3Asr:
+            resultPaths.qwen3ConvFrontend = candidate.qwen3ConvFrontend;
+            resultPaths.qwen3Encoder = candidate.encoder;
+            resultPaths.qwen3Decoder = candidate.decoder;
+            resultPaths.qwen3Tokenizer = candidate.qwen3TokenizerDir;
+            break;
         case SttModelKind::kMoonshine:
             resultPaths.moonshinePreprocessor = candidate.moonshinePreprocessor;
             resultPaths.moonshineEncoder = candidate.moonshineEncoder;
@@ -711,13 +747,13 @@ SttDetectResult DetectSttModel(
             EmptyOrPath(candidate.encoder), EmptyOrPath(candidate.decoder));
         LOGI("DetectSttModel: funasr encoderAdaptor=%s llm=%s embedding=%s tokenizerDir=%s",
             EmptyOrPath(candidate.funasrEncoderAdaptor), EmptyOrPath(candidate.funasrLLM), EmptyOrPath(candidate.funasrEmbedding), EmptyOrPath(candidate.funasrTokenizerDir));
-        LOGI("DetectSttModel: hasTransducer=%d hasWhisper=%d hasMoonshine=%d hasMoonshineV2=%d hasParaformer=%d hasFunAsrNano=%d hasDolphin=%d hasFireRedAsr=%d hasFireRedCtc=%d hasCanary=%d hasOmnilingual=%d hasMedAsr=%d hasTeleSpeechCtc=%d hasToneCtc=%d",
+        LOGI("DetectSttModel: hasTransducer=%d hasWhisper=%d hasMoonshine=%d hasMoonshineV2=%d hasParaformer=%d hasFunAsrNano=%d hasQwen3Asr=%d hasDolphin=%d hasFireRedAsr=%d hasFireRedCtc=%d hasCanary=%d hasOmnilingual=%d hasMedAsr=%d hasTeleSpeechCtc=%d hasToneCtc=%d",
             (int)cap.hasTransducer, (int)cap.hasWhisper, (int)cap.hasMoonshine, (int)cap.hasMoonshineV2,
-            (int)cap.hasParaformer, (int)cap.hasFunAsrNano, (int)cap.hasDolphin, (int)cap.hasFireRedAsr, (int)cap.hasFireRedCtc,
+            (int)cap.hasParaformer, (int)cap.hasFunAsrNano, (int)cap.hasQwen3Asr, (int)cap.hasDolphin, (int)cap.hasFireRedAsr, (int)cap.hasFireRedCtc,
             (int)cap.hasCanary, (int)cap.hasOmnilingual, (int)cap.hasMedAsr, (int)cap.hasTeleSpeechCtc, (int)cap.hasToneCtc);
-        LOGI("DetectSttModel: hints isLikelyNemo=%d isLikelyTdt=%d isLikelyWenetCtc=%d isLikelySenseVoice=%d isLikelyFunAsrNano=%d isLikelyZipformer=%d isLikelyMoonshine=%d isLikelyDolphin=%d isLikelyFireRedAsr=%d isLikelyCanary=%d isLikelyOmnilingual=%d isLikelyMedAsr=%d isLikelyTeleSpeech=%d isLikelyToneCtc=%d isLikelyParaformer=%d isLikelyVad=%d isLikelyTdnn=%d",
+        LOGI("DetectSttModel: hints isLikelyNemo=%d isLikelyTdt=%d isLikelyWenetCtc=%d isLikelySenseVoice=%d isLikelyFunAsrNano=%d isLikelyQwen3Asr=%d isLikelyZipformer=%d isLikelyMoonshine=%d isLikelyDolphin=%d isLikelyFireRedAsr=%d isLikelyCanary=%d isLikelyOmnilingual=%d isLikelyMedAsr=%d isLikelyTeleSpeech=%d isLikelyToneCtc=%d isLikelyParaformer=%d isLikelyVad=%d isLikelyTdnn=%d",
              (int)hints.isLikelyNemo, (int)hints.isLikelyTdt, (int)hints.isLikelyWenetCtc, (int)hints.isLikelySenseVoice,
-             (int)hints.isLikelyFunAsrNano, (int)hints.isLikelyZipformer, (int)hints.isLikelyMoonshine, (int)hints.isLikelyDolphin,
+             (int)hints.isLikelyFunAsrNano, (int)hints.isLikelyQwen3Asr, (int)hints.isLikelyZipformer, (int)hints.isLikelyMoonshine, (int)hints.isLikelyDolphin,
              (int)hints.isLikelyFireRedAsr, (int)hints.isLikelyCanary, (int)hints.isLikelyOmnilingual, (int)hints.isLikelyMedAsr,
              (int)hints.isLikelyTeleSpeech, (int)hints.isLikelyToneCtc, (int)hints.isLikelyParaformer, (int)hints.isLikelyVad, (int)hints.isLikelyTdnn);
     }
@@ -747,7 +783,8 @@ SttDetectResult DetectSttModel(
     }
 
     LOGI("DetectSttModel: selected kind=%d (%s)", static_cast<int>(result.selectedKind), KindToName(result.selectedKind));
-    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano);
+    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano &&
+                             result.selectedKind != SttModelKind::kQwen3Asr);
     ApplyPathsForSttKind(result.selectedKind, candidate, result.paths);
 
     if (!candidate.tokens.empty() && FileExists(candidate.tokens)) {
@@ -808,6 +845,11 @@ SttDetectResult DetectSttModel(
                  EmptyOrPath(result.paths.funasrEncoderAdaptor), EmptyOrPath(result.paths.funasrLLM),
                  EmptyOrPath(result.paths.funasrEmbedding), EmptyOrPath(result.paths.funasrTokenizer));
             break;
+        case SttModelKind::kQwen3Asr:
+            LOGI("DetectSttModel: paths set qwen3_asr conv=%s encoder=%s decoder=%s tokenizer=%s",
+                 EmptyOrPath(result.paths.qwen3ConvFrontend), EmptyOrPath(result.paths.qwen3Encoder),
+                 EmptyOrPath(result.paths.qwen3Decoder), EmptyOrPath(result.paths.qwen3Tokenizer));
+            break;
         default:
             break;
     }
@@ -854,7 +896,8 @@ SttDetectResult DetectSttModelFromFileList(
         return result;
     }
 
-    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano);
+    result.tokensRequired = (result.selectedKind != SttModelKind::kFunAsrNano &&
+                             result.selectedKind != SttModelKind::kQwen3Asr);
     ApplyPathsForSttKind(result.selectedKind, candidate, result.paths);
 
     result.paths.tokens = candidate.tokens;

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect-tts.cpp

@@ -2,7 +2,7 @@
  * sherpa-onnx-model-detect-tts.cpp
  *
  * Purpose: Detects TTS model type and fills TtsModelPaths from a model directory. Used by
- * nativeDetectTtsModel (module-jni). Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice.
+ * nativeDetectTtsModel (module-jni). Supports Vits, Matcha, Kokoro, Kitten, Pocket, Zipvoice, Supertonic.
  *
  * --- Detection pipeline (overview) ---
  *
@@ -56,6 +56,7 @@ TtsModelKind ParseTtsModelType(const std::string& modelType) {
     if (modelType == "kitten") return TtsModelKind::kKitten;
     if (modelType == "pocket") return TtsModelKind::kPocket;
     if (modelType == "zipvoice") return TtsModelKind::kZipvoice;
+    if (modelType == "supertonic") return TtsModelKind::kSupertonic;
     return TtsModelKind::kUnknown;
 }
 
@@ -68,6 +69,7 @@ static bool CapabilitySupportsTtsKind(
     bool hasMatcha,
     bool hasPocket,
     bool hasZipvoice,
+    bool hasSupertonic,
     bool hasVoicesFile,
     bool hasDataDir
 ) {
@@ -83,6 +85,8 @@ static bool CapabilitySupportsTtsKind(
             return hasPocket;
         case TtsModelKind::kZipvoice:
             return hasZipvoice;
+        case TtsModelKind::kSupertonic:
+            return hasSupertonic;
         default:
             return false;
     }
@@ -108,6 +112,7 @@ static std::vector<TtsModelKind> GetKindsFromDirNameTts(const std::string& model
     if (lower.find("matcha") != std::string::npos) add(TtsModelKind::kMatcha);
     if (lower.find("pocket") != std::string::npos) add(TtsModelKind::kPocket);
     if (lower.find("zipvoice") != std::string::npos) add(TtsModelKind::kZipvoice);
+    if (lower.find("supertonic") != std::string::npos) add(TtsModelKind::kSupertonic);
     if (lower.find("kokoro") != std::string::npos) add(TtsModelKind::kKokoro);
     if (lower.find("kitten") != std::string::npos) add(TtsModelKind::kKitten);
     if (lower.find("vits") != std::string::npos) add(TtsModelKind::kVits);
@@ -143,16 +148,27 @@ static TtsDetectResult DetectTtsModelFromFiles(
     std::string textConditioner = FindOnnxByAnyToken(files, {"text_conditioner", "text-conditioner"}, std::nullopt);
     std::string vocabJsonFile = FindFileByName(files, "vocab.json");
     std::string tokenScoresJsonFile = FindFileByName(files, "token_scores.json");
+    std::string durationPredictor = FindOnnxByAnyToken(files, {"duration_predictor", "duration-predictor"}, std::nullopt);
+    std::string textEncoderSupertonic = FindOnnxByAnyToken(files, {"text_encoder", "text-encoder"}, std::nullopt);
+    std::string vectorEstimator = FindOnnxByAnyToken(files, {"vector_estimator", "vector-estimator"}, std::nullopt);
+    std::string ttsJsonFile = FindFileByName(files, "tts.json");
+    std::string unicodeIndexerFile = FindFileByName(files, "unicode_indexer.bin");
+    std::string voiceStyleFile = FindFileByName(files, "voice.bin");
 
     std::vector<std::string> modelExcludes = {
-        "acoustic", "vocoder", "encoder", "decoder", "joiner"
+        "acoustic", "vocoder", "encoder", "decoder", "joiner",
+        // Supertonic component models are not VITS monolithic model.onnx files.
+        "duration_predictor", "duration-predictor",
+        "text_encoder", "text-encoder",
+        "vector_estimator", "vector-estimator"
     };
     std::string ttsModel = FindOnnxByAnyToken(files, {"model"}, std::nullopt);
     if (ttsModel.empty()) {
         ttsModel = FindLargestOnnxExcludingTokens(files, modelExcludes);
     }
 
-    bool hasVits = !ttsModel.empty();
+    // VITS requires both model.onnx-like file and tokens.txt
+    bool hasVits = !ttsModel.empty() && !tokensFile.empty();
     std::string modelDirLower = ToLower(modelDir);
     bool isLikelyMatcha = modelDirLower.find("matcha") != std::string::npos;
     bool hasMatcha = (!acousticModel.empty() && !vocoder.empty())
@@ -169,6 +185,9 @@ static TtsDetectResult DetectTtsModelFromFiles(
     }
     bool hasPocket = !lmFlow.empty() && !lmMain.empty() && !encoder.empty() && !decoder.empty() &&
                      !textConditioner.empty() && !vocabJsonFile.empty() && !tokenScoresJsonFile.empty();
+    bool hasSupertonic = !durationPredictor.empty() && !textEncoderSupertonic.empty() &&
+                         !vectorEstimator.empty() && !vocoder.empty() && !ttsJsonFile.empty() &&
+                         !unicodeIndexerFile.empty() && !voiceStyleFile.empty();
     bool hasDataDir = !dataDirPath.empty();
 
     bool isLikelyKitten = modelDirLower.find("kitten") != std::string::npos;
@@ -177,6 +196,7 @@ static TtsDetectResult DetectTtsModelFromFiles(
     if (hasMatcha) result.detectedModels.push_back({"matcha", modelDir});
     if (hasPocket) result.detectedModels.push_back({"pocket", modelDir});
     if (hasZipvoice && !hasMatcha) result.detectedModels.push_back({"zipvoice", modelDir});
+    if (hasSupertonic) result.detectedModels.push_back({"supertonic", modelDir});
     if (hasVoicesFile) {
         if (isLikelyKitten && !isLikelyKokoro) {
             result.detectedModels.push_back({"kitten", modelDir});
@@ -205,7 +225,7 @@ static TtsDetectResult DetectTtsModelFromFiles(
         std::vector<TtsModelKind> nameCandidates = GetKindsFromDirNameTts(modelDir);
         if (!nameCandidates.empty()) {
             for (TtsModelKind k : nameCandidates) {
-                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice,
+                if (CapabilitySupportsTtsKind(k, hasVits, hasMatcha, hasPocket, hasZipvoice, hasSupertonic,
                                               hasVoicesFile, hasDataDir)) {
                     selected = k;
                     break;
@@ -216,6 +236,7 @@ static TtsDetectResult DetectTtsModelFromFiles(
             if (hasMatcha) selected = TtsModelKind::kMatcha;
             else if (hasPocket) selected = TtsModelKind::kPocket;
             else if (hasZipvoice) selected = TtsModelKind::kZipvoice;
+            else if (hasSupertonic) selected = TtsModelKind::kSupertonic;
             else if (hasVoicesFile) {
                 if (isLikelyKitten && !isLikelyKokoro) selected = TtsModelKind::kKitten;
                 else if (isLikelyKokoro && !isLikelyKitten) selected = TtsModelKind::kKokoro;
@@ -256,6 +277,12 @@ static TtsDetectResult DetectTtsModelFromFiles(
     result.paths.textConditioner = textConditioner;
     result.paths.vocabJson = vocabJsonFile;
     result.paths.tokenScoresJson = tokenScoresJsonFile;
+    result.paths.durationPredictor = durationPredictor;
+    result.paths.textEncoder = textEncoderSupertonic;
+    result.paths.vectorEstimator = vectorEstimator;
+    result.paths.ttsJson = ttsJsonFile;
+    result.paths.unicodeIndexer = unicodeIndexerFile;
+    result.paths.voiceStyle = voiceStyleFile;
 
     auto validation = ValidateTtsPaths(selected, result.paths, modelDir);
     if (!validation.ok) {

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-model-detect.h

@@ -20,6 +20,7 @@ enum class SttModelKind {
     kZipformerCtc,
     kWhisper,
     kFunAsrNano,
+    kQwen3Asr,
     kFireRedAsr,
     kMoonshine,
     kMoonshineV2,
@@ -38,7 +39,8 @@ enum class TtsModelKind {
     kKokoro,
     kKitten,
     kPocket,
-    kZipvoice
+    kZipvoice,
+    kSupertonic
 };
 
 struct SttModelPaths {
@@ -56,6 +58,11 @@ struct SttModelPaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizer;
+    /** Qwen3-ASR: conv_frontend + encoder + decoder + tokenizer directory. */
+    std::string qwen3ConvFrontend;
+    std::string qwen3Encoder;
+    std::string qwen3Decoder;
+    std::string qwen3Tokenizer;
     // Moonshine
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
@@ -88,6 +95,8 @@ struct SttCandidatePaths {
     std::string funasrLLM;
     std::string funasrEmbedding;
     std::string funasrTokenizerDir;
+    std::string qwen3ConvFrontend;
+    std::string qwen3TokenizerDir;
     std::string moonshinePreprocessor;
     std::string moonshineEncoder;
     std::string moonshineUncachedDecoder;
@@ -103,6 +112,7 @@ struct SttPathHints {
     bool isLikelyWenetCtc = false;
     bool isLikelySenseVoice = false;
     bool isLikelyFunAsrNano = false;
+    bool isLikelyQwen3Asr = false;
     bool isLikelyZipformer = false;
     bool isLikelyMoonshine = false;
     bool isLikelyDolphin = false;
@@ -127,6 +137,7 @@ struct SttCapabilities {
     bool hasMoonshineV2 = false;
     bool hasParaformer = false;
     bool hasFunAsrNano = false;
+    bool hasQwen3Asr = false;
     bool hasDolphin = false;
     bool hasFireRedAsr = false;
     /** True when dir name suggests Fire Red but only a single CTC/paraformer model (no encoder/decoder). Use zipformer_ctc. */
@@ -154,6 +165,13 @@ struct TtsModelPaths {
     std::string textConditioner;
     std::string vocabJson;
     std::string tokenScoresJson;
+    // Supertonic TTS
+    std::string durationPredictor;
+    std::string textEncoder;
+    std::string vectorEstimator;
+    std::string ttsJson;
+    std::string unicodeIndexer;
+    std::string voiceStyle;
 };
 
 struct SttDetectResult {

package/android/src/main/cpp/jni/model_detect/sherpa-onnx-stt-wrapper.cpp

@@ -23,6 +23,7 @@ const char* SttModelKindToString(SttModelKind k) {
     case SttModelKind::kZipformerCtc: return "zipformer_ctc";
     case SttModelKind::kWhisper: return "whisper";
     case SttModelKind::kFunAsrNano: return "funasr_nano";
+    case SttModelKind::kQwen3Asr: return "qwen3_asr";
     case SttModelKind::kFireRedAsr: return "fire_red_asr";
     case SttModelKind::kMoonshine: return "moonshine";
     case SttModelKind::kMoonshineV2: return "moonshine_v2";
@@ -79,6 +80,10 @@ jobject SttDetectResultToJava(JNIEnv* env, const SttDetectResult& result) {
       PutString(env, pathsMap, mapPut, "funasrLLM", result.paths.funasrLLM);
       PutString(env, pathsMap, mapPut, "funasrEmbedding", result.paths.funasrEmbedding);
       PutString(env, pathsMap, mapPut, "funasrTokenizer", result.paths.funasrTokenizer);
+      PutString(env, pathsMap, mapPut, "qwen3ConvFrontend", result.paths.qwen3ConvFrontend);
+      PutString(env, pathsMap, mapPut, "qwen3Encoder", result.paths.qwen3Encoder);
+      PutString(env, pathsMap, mapPut, "qwen3Decoder", result.paths.qwen3Decoder);
+      PutString(env, pathsMap, mapPut, "qwen3Tokenizer", result.paths.qwen3Tokenizer);
       PutString(env, pathsMap, mapPut, "moonshinePreprocessor", result.paths.moonshinePreprocessor);
       PutString(env, pathsMap, mapPut, "moonshineEncoder", result.paths.moonshineEncoder);
       PutString(env, pathsMap, mapPut, "moonshineUncachedDecoder", result.paths.moonshineUncachedDecoder);