react-native-sherpa-onnx 0.1.0

package/ios/sherpa-onnx-wrapper.h

@@ -0,0 +1,57 @@
+#ifndef SHERPA_ONNX_WRAPPER_H
+#define SHERPA_ONNX_WRAPPER_H
+
+#include <string>
+#include <memory>
+#include <optional>
+
+namespace sherpaonnx {
+
+/**
+ * Wrapper class for sherpa-onnx OfflineRecognizer.
+ * This provides a C++ interface that can be easily called from iOS Objective-C++.
+ */
+class SherpaOnnxWrapper {
+public:
+    SherpaOnnxWrapper();
+    ~SherpaOnnxWrapper();
+
+    /**
+     * Initialize sherpa-onnx with model directory.
+     * @param modelDir Path to the model directory
+     * @param preferInt8 Optional: true = prefer int8 models, false = prefer regular models, nullopt = try int8 first (default)
+     * @param modelType Optional: explicit model type ("transducer", "paraformer", "nemo_ctc"), nullopt = auto-detect (default)
+     * @return true if successful, false otherwise
+     */
+    bool initialize(
+        const std::string& modelDir,
+        const std::optional<bool>& preferInt8 = std::nullopt,
+        const std::optional<std::string>& modelType = std::nullopt
+    );
+
+    /**
+     * Transcribe an audio file.
+     * @param filePath Path to the audio file (WAV 16kHz mono 16-bit PCM)
+     * @return Transcribed text
+     */
+    std::string transcribeFile(const std::string& filePath);
+
+    /**
+     * Check if the recognizer is initialized.
+     * @return true if initialized, false otherwise
+     */
+    bool isInitialized() const;
+
+    /**
+     * Release resources.
+     */
+    void release();
+
+private:
+    class Impl;
+    std::unique_ptr<Impl> pImpl;
+};
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_WRAPPER_H

package/ios/sherpa-onnx-wrapper.mm

@@ -0,0 +1,432 @@
+#include "sherpa-onnx-wrapper.h"
+#include <fstream>
+#include <sstream>
+#include <optional>
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+
+// iOS logging
+#ifdef __APPLE__
+#include <Foundation/Foundation.h>
+#include <cstdio>
+#define LOGI(fmt, ...) NSLog(@"SherpaOnnxWrapper: " fmt, ##__VA_ARGS__)
+#define LOGE(fmt, ...) NSLog(@"SherpaOnnxWrapper ERROR: " fmt, ##__VA_ARGS__)
+#else
+#define LOGI(...)
+#define LOGE(...)
+#endif
+
+// Use C++17 filesystem (podspec enforces C++17)
+#include <filesystem>
+namespace fs = std::filesystem;
+
+// sherpa-onnx headers - use C++ API (RAII wrapper around C API)
+#include "sherpa-onnx/c-api/cxx-api.h"
+
+namespace sherpaonnx {
+
+// PIMPL pattern implementation
+class SherpaOnnxWrapper::Impl {
+public:
+    bool initialized = false;
+    std::string modelDir;
+    std::optional<sherpa_onnx::cxx::OfflineRecognizer> recognizer;
+};
+
+SherpaOnnxWrapper::SherpaOnnxWrapper() : pImpl(std::make_unique<Impl>()) {
+    LOGI("SherpaOnnxWrapper created");
+}
+
+SherpaOnnxWrapper::~SherpaOnnxWrapper() {
+    release();
+    LOGI("SherpaOnnxWrapper destroyed");
+}
+
+bool SherpaOnnxWrapper::initialize(
+    const std::string& modelDir,
+    const std::optional<bool>& preferInt8,
+    const std::optional<std::string>& modelType
+) {
+    if (pImpl->initialized) {
+        release();
+    }
+
+    if (modelDir.empty()) {
+        LOGE("Model directory is empty");
+        return false;
+    }
+
+    try {
+        // Helper function to check if file exists
+        auto fileExists = [](const std::string& path) -> bool {
+            return fs::exists(path);
+        };
+
+        auto isDirectory = [](const std::string& path) -> bool {
+            return fs::is_directory(path);
+        };
+
+        // Check if model directory exists
+        if (!fileExists(modelDir) || !isDirectory(modelDir)) {
+            LOGE("Model directory does not exist or is not a directory: %s", modelDir.c_str());
+            return false;
+        }
+
+        // Setup configuration using C++ API
+        sherpa_onnx::cxx::OfflineRecognizerConfig config;
+        
+        // Set default feature config (16kHz, 80-dim for most models)
+        config.feat_config.sample_rate = 16000;
+        config.feat_config.feature_dim = 80;
+        
+        // Build paths for model files
+        std::string encoderPath = modelDir + "/encoder.onnx";
+        std::string decoderPath = modelDir + "/decoder.onnx";
+        std::string joinerPath = modelDir + "/joiner.onnx";
+        std::string encoderPathInt8 = modelDir + "/encoder.int8.onnx";
+        std::string decoderPathInt8 = modelDir + "/decoder.int8.onnx";
+        std::string paraformerPathInt8 = modelDir + "/model.int8.onnx";
+        std::string paraformerPath = modelDir + "/model.onnx";
+        std::string ctcPathInt8 = modelDir + "/model.int8.onnx";
+        std::string ctcPath = modelDir + "/model.onnx";
+        std::string tokensPath = modelDir + "/tokens.txt";
+        
+        // FunASR Nano paths
+        std::string funasrEncoderAdaptor = modelDir + "/encoder_adaptor.onnx";
+        std::string funasrEncoderAdaptorInt8 = modelDir + "/encoder_adaptor.int8.onnx";
+        std::string funasrLLM = modelDir + "/llm.onnx";
+        std::string funasrLLMInt8 = modelDir + "/llm.int8.onnx";
+        std::string funasrEmbedding = modelDir + "/embedding.onnx";
+        std::string funasrEmbeddingInt8 = modelDir + "/embedding.int8.onnx";
+        
+        // Helper function to find FunASR Nano tokenizer directory
+        auto findFunAsrTokenizer = [&fileExists, &modelDir]() -> std::string {
+            std::string vocabInMain = modelDir + "/vocab.json";
+            if (fileExists(vocabInMain)) {
+                return modelDir;
+            }
+            
+            try {
+                for (const auto& entry : fs::directory_iterator(modelDir)) {
+                    if (entry.is_directory()) {
+                        std::string dirName = entry.path().filename().string();
+                        std::string dirNameLower = dirName;
+                        std::transform(dirNameLower.begin(), dirNameLower.end(), dirNameLower.begin(),
+                                       [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                        if (dirNameLower.find("qwen3") != std::string::npos) {
+                            std::string vocabPath = entry.path().string() + "/vocab.json";
+                            if (fileExists(vocabPath)) {
+                                return entry.path().string();
+                            }
+                        }
+                    }
+                }
+            } catch (const std::exception& e) {
+                // Error accessing directory
+            }
+            
+            std::string commonPath = modelDir + "/Qwen3-0.6B";
+            if (fileExists(commonPath + "/vocab.json")) {
+                return commonPath;
+            }
+            
+            return "";
+        };
+        
+        std::string funasrTokenizer = findFunAsrTokenizer();
+
+        bool tokensRequired = true;
+
+        // Configure based on model type - same logic as Android version
+        std::string paraformerModelPath;
+        if (preferInt8.has_value()) {
+            if (preferInt8.value()) {
+                if (fileExists(paraformerPathInt8)) {
+                    paraformerModelPath = paraformerPathInt8;
+                } else if (fileExists(paraformerPath)) {
+                    paraformerModelPath = paraformerPath;
+                }
+            } else {
+                if (fileExists(paraformerPath)) {
+                    paraformerModelPath = paraformerPath;
+                } else if (fileExists(paraformerPathInt8)) {
+                    paraformerModelPath = paraformerPathInt8;
+                }
+            }
+        } else {
+            if (fileExists(paraformerPathInt8)) {
+                paraformerModelPath = paraformerPathInt8;
+            } else if (fileExists(paraformerPath)) {
+                paraformerModelPath = paraformerPath;
+            }
+        }
+        
+        std::string ctcModelPath;
+        if (preferInt8.has_value()) {
+            if (preferInt8.value()) {
+                if (fileExists(ctcPathInt8)) {
+                    ctcModelPath = ctcPathInt8;
+                } else if (fileExists(ctcPath)) {
+                    ctcModelPath = ctcPath;
+                }
+            } else {
+                if (fileExists(ctcPath)) {
+                    ctcModelPath = ctcPath;
+                } else if (fileExists(ctcPathInt8)) {
+                    ctcModelPath = ctcPathInt8;
+                }
+            }
+        } else {
+            if (fileExists(ctcPathInt8)) {
+                ctcModelPath = ctcPathInt8;
+            } else if (fileExists(ctcPath)) {
+                ctcModelPath = ctcPath;
+            }
+        }
+        
+        bool hasTransducer = fileExists(encoderPath) && 
+                             fileExists(decoderPath) && 
+                             fileExists(joinerPath);
+        
+        bool hasWhisperEncoder = fileExists(encoderPath) || fileExists(encoderPathInt8);
+        bool hasWhisperDecoder = fileExists(decoderPath) || fileExists(decoderPathInt8);
+        bool hasWhisper = hasWhisperEncoder && hasWhisperDecoder && !fileExists(joinerPath);
+        
+        bool hasFunAsrEncoderAdaptor = fileExists(funasrEncoderAdaptor) || fileExists(funasrEncoderAdaptorInt8);
+        bool hasFunAsrLLM = fileExists(funasrLLM) || fileExists(funasrLLMInt8);
+        bool hasFunAsrEmbedding = fileExists(funasrEmbedding) || fileExists(funasrEmbeddingInt8);
+        bool hasFunAsrTokenizer = !funasrTokenizer.empty() && fileExists(funasrTokenizer + "/vocab.json");
+        bool hasFunAsrNano = hasFunAsrEncoderAdaptor && hasFunAsrLLM && hasFunAsrEmbedding && hasFunAsrTokenizer;
+        
+        bool isLikelyNemoCtc = modelDir.find("nemo") != std::string::npos ||
+                                modelDir.find("parakeet") != std::string::npos;
+        bool isLikelyWenetCtc = modelDir.find("wenet") != std::string::npos;
+        bool isLikelySenseVoice = modelDir.find("sense") != std::string::npos ||
+                                  modelDir.find("sensevoice") != std::string::npos;
+        bool isLikelyFunAsrNano = modelDir.find("funasr") != std::string::npos ||
+                                  modelDir.find("funasr-nano") != std::string::npos;
+        bool isLikelyWhisper = modelDir.find("whisper") != std::string::npos;
+        
+        bool modelConfigured = false;
+        
+        // Use explicit model type if provided
+        if (modelType.has_value()) {
+            std::string type = modelType.value();
+            if (type == "transducer" && hasTransducer) {
+                LOGI("Using explicit Transducer model type");
+                config.model_config.transducer.encoder = encoderPath;
+                config.model_config.transducer.decoder = decoderPath;
+                config.model_config.transducer.joiner = joinerPath;
+                modelConfigured = true;
+            } else if (type == "paraformer" && !paraformerModelPath.empty()) {
+                LOGI("Using explicit Paraformer model type: %s", paraformerModelPath.c_str());
+                config.model_config.paraformer.model = paraformerModelPath;
+                modelConfigured = true;
+            } else if (type == "nemo_ctc" && !ctcModelPath.empty()) {
+                LOGI("Using explicit NeMo CTC model type: %s", ctcModelPath.c_str());
+                config.model_config.nemo_ctc.model = ctcModelPath;
+                modelConfigured = true;
+            } else if (type == "wenet_ctc" && !ctcModelPath.empty()) {
+                LOGI("Using explicit WeNet CTC model type: %s", ctcModelPath.c_str());
+                config.model_config.wenet_ctc.model = ctcModelPath;
+                modelConfigured = true;
+            } else if (type == "sense_voice" && !ctcModelPath.empty()) {
+                LOGI("Using explicit SenseVoice model type: %s", ctcModelPath.c_str());
+                config.model_config.sense_voice.model = ctcModelPath;
+                config.model_config.sense_voice.language = "auto";
+                config.model_config.sense_voice.use_itn = false;
+                modelConfigured = true;
+            } else if (type == "funasr_nano" && hasFunAsrNano) {
+                LOGI("Using explicit FunASR Nano model type");
+                config.model_config.funasr_nano.encoder_adaptor = fileExists(funasrEncoderAdaptorInt8) ? funasrEncoderAdaptorInt8 : funasrEncoderAdaptor;
+                config.model_config.funasr_nano.llm = fileExists(funasrLLMInt8) ? funasrLLMInt8 : funasrLLM;
+                config.model_config.funasr_nano.embedding = fileExists(funasrEmbeddingInt8) ? funasrEmbeddingInt8 : funasrEmbedding;
+                config.model_config.funasr_nano.tokenizer = funasrTokenizer;
+                tokensRequired = false;
+                modelConfigured = true;
+            } else if (type == "whisper" && hasWhisper) {
+                LOGI("Using explicit Whisper model type");
+                config.model_config.whisper.encoder = fileExists(encoderPathInt8) ? encoderPathInt8 : encoderPath;
+                config.model_config.whisper.decoder = fileExists(decoderPathInt8) ? decoderPathInt8 : decoderPath;
+                config.model_config.whisper.language = "en";
+                config.model_config.whisper.task = "transcribe";
+                tokensRequired = true;
+                if (fileExists(tokensPath)) {
+                    config.model_config.tokens = tokensPath;
+                    LOGI("Using tokens file for Whisper: %s", tokensPath.c_str());
+                } else {
+                    LOGE("Tokens file not found for Whisper model: %s", tokensPath.c_str());
+                    return false;
+                }
+                modelConfigured = true;
+            } else {
+                LOGE("Explicit model type '%s' specified but required files not found", type.c_str());
+                return false;
+            }
+        }
+        
+        // Auto-detect if no explicit type
+        if (!modelConfigured) {
+            if (hasTransducer) {
+                LOGI("Auto-detected Transducer model");
+                config.model_config.transducer.encoder = encoderPath;
+                config.model_config.transducer.decoder = decoderPath;
+                config.model_config.transducer.joiner = joinerPath;
+                modelConfigured = true;
+            } else if (hasFunAsrNano && isLikelyFunAsrNano) {
+                LOGI("Auto-detected FunASR Nano model");
+                config.model_config.funasr_nano.encoder_adaptor = fileExists(funasrEncoderAdaptorInt8) ? funasrEncoderAdaptorInt8 : funasrEncoderAdaptor;
+                config.model_config.funasr_nano.llm = fileExists(funasrLLMInt8) ? funasrLLMInt8 : funasrLLM;
+                config.model_config.funasr_nano.embedding = fileExists(funasrEmbeddingInt8) ? funasrEmbeddingInt8 : funasrEmbedding;
+                config.model_config.funasr_nano.tokenizer = funasrTokenizer;
+                tokensRequired = false;
+                modelConfigured = true;
+            } else if (hasWhisper && isLikelyWhisper) {
+                LOGI("Auto-detected Whisper model");
+                config.model_config.whisper.encoder = fileExists(encoderPathInt8) ? encoderPathInt8 : encoderPath;
+                config.model_config.whisper.decoder = fileExists(decoderPathInt8) ? decoderPathInt8 : decoderPath;
+                config.model_config.whisper.language = "en";
+                config.model_config.whisper.task = "transcribe";
+                tokensRequired = true;
+                if (fileExists(tokensPath)) {
+                    config.model_config.tokens = tokensPath;
+                    LOGI("Using tokens file for Whisper: %s", tokensPath.c_str());
+                } else {
+                    LOGE("Tokens file not found for Whisper model: %s", tokensPath.c_str());
+                    return false;
+                }
+                modelConfigured = true;
+            } else if (!ctcModelPath.empty() && isLikelySenseVoice) {
+                LOGI("Auto-detected SenseVoice model: %s", ctcModelPath.c_str());
+                config.model_config.sense_voice.model = ctcModelPath;
+                config.model_config.sense_voice.language = "auto";
+                config.model_config.sense_voice.use_itn = false;
+                modelConfigured = true;
+            } else if (!ctcModelPath.empty() && isLikelyWenetCtc) {
+                LOGI("Auto-detected WeNet CTC model: %s", ctcModelPath.c_str());
+                config.model_config.wenet_ctc.model = ctcModelPath;
+                modelConfigured = true;
+            } else if (!ctcModelPath.empty() && isLikelyNemoCtc) {
+                LOGI("Auto-detected NeMo CTC model: %s", ctcModelPath.c_str());
+                config.model_config.nemo_ctc.model = ctcModelPath;
+                modelConfigured = true;
+            } else if (!paraformerModelPath.empty()) {
+                LOGI("Auto-detected Paraformer model: %s", paraformerModelPath.c_str());
+                config.model_config.paraformer.model = paraformerModelPath;
+                modelConfigured = true;
+            } else if (!ctcModelPath.empty()) {
+                // Fallback: try as CTC model
+                LOGI("Auto-detected CTC model (fallback): %s", ctcModelPath.c_str());
+                config.model_config.nemo_ctc.model = ctcModelPath;
+                modelConfigured = true;
+            }
+        }
+        
+        if (tokensRequired) {
+            if (!fileExists(tokensPath)) {
+                LOGE("Tokens file not found: %s", tokensPath.c_str());
+                return false;
+            }
+            config.model_config.tokens = tokensPath;
+            LOGI("Using tokens file: %s", tokensPath.c_str());
+        } else if (modelConfigured && fileExists(tokensPath)) {
+            config.model_config.tokens = tokensPath;
+            LOGI("Using tokens file (optional): %s", tokensPath.c_str());
+        }
+        
+        if (!modelConfigured) {
+            LOGE("No valid model files found in directory: %s", modelDir.c_str());
+            return false;
+        }
+
+        // Set remaining config
+        config.decoding_method = "greedy_search";
+        config.model_config.num_threads = 4;
+        config.model_config.provider = "cpu";
+        config.model_config.debug = false;
+
+        // Create the recognizer using C++ API
+        try {
+            auto recognizer = sherpa_onnx::cxx::OfflineRecognizer::Create(config);
+            if (recognizer.Get() == nullptr) {
+                LOGE("Failed to create OfflineRecognizer: Create returned invalid object (nullptr)");
+                return false;
+            }
+            pImpl->recognizer = std::move(recognizer);
+            LOGI("OfflineRecognizer created successfully using C++ API");
+        } catch (const std::exception& e) {
+            LOGE("Failed to create OfflineRecognizer: %s", e.what());
+            return false;
+        }
+        
+        pImpl->modelDir = modelDir;
+        pImpl->initialized = true;
+        return true;
+        
+    } catch (const std::exception& e) {
+        LOGE("Exception during initialization: %s", e.what());
+        return false;
+    } catch (...) {
+        LOGE("Unknown exception during initialization");
+        return false;
+    }
+}
+
+std::string SherpaOnnxWrapper::transcribeFile(const std::string& filePath) {
+    if (!pImpl->initialized || !pImpl->recognizer.has_value()) {
+        LOGE("Not initialized. Call initialize() first.");
+        return "";
+    }
+
+    try {
+        if (!fs::exists(filePath)) {
+            LOGE("Audio file does not exist: %s", filePath.c_str());
+            return "";
+        }
+
+        // Read the wave file using C++ API
+        sherpa_onnx::cxx::Wave wave = sherpa_onnx::cxx::ReadWave(filePath);
+        
+        if (wave.samples.empty()) {
+            LOGE("Failed to read wave file or file is empty: %s", filePath.c_str());
+            return "";
+        }
+
+        // Create a stream
+        auto stream = pImpl->recognizer.value().CreateStream();
+        
+        // Feed audio data to the stream (all samples at once for offline recognition)
+        stream.AcceptWaveform(wave.sample_rate, wave.samples.data(), wave.samples.size());
+        
+        // Decode the stream
+        pImpl->recognizer.value().Decode(&stream);
+        
+        // Get result
+        auto result = pImpl->recognizer.value().GetResult(&stream);
+        
+        return result.text;
+    } catch (const std::exception& e) {
+        LOGE("Exception during transcription: %s", e.what());
+        return "";
+    } catch (...) {
+        LOGE("Unknown exception during transcription");
+        return "";
+    }
+}
+
+bool SherpaOnnxWrapper::isInitialized() const {
+    return pImpl->initialized;
+}
+
+void SherpaOnnxWrapper::release() {
+    if (pImpl->initialized) {
+        // OfflineRecognizer uses RAII - destruction happens automatically when optional is reset
+        pImpl->recognizer.reset();
+        pImpl->initialized = false;
+        pImpl->modelDir.clear();
+        LOGI("Resources released");
+    }
+}
+
+} // namespace sherpaonnx

package/lib/module/NativeSherpaOnnx.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('SherpaOnnx');
+//# sourceMappingURL=NativeSherpaOnnx.js.map

package/lib/module/NativeSherpaOnnx.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"..\\..\\src","sources":["NativeSherpaOnnx.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AA2CpE,eAAeA,mBAAmB,CAACC,YAAY,CAAO,YAAY,CAAC","ignoreList":[]}

package/lib/module/diarization/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+/**
+ * Speaker Diarization feature module
+ *
+ * @remarks
+ * This feature is not yet implemented. This module serves as a placeholder
+ * for future speaker diarization functionality.
+ *
+ * @example
+ * ```typescript
+ * // Future usage:
+ * import { initializeDiarization, diarizeAudio } from 'react-native-sherpa-onnx/diarization';
+ *
+ * await initializeDiarization({ modelPath: 'models/diarization-model' });
+ * const segments = await diarizeAudio('path/to/audio.wav');
+ * ```
+ */
+
+/**
+ * Diarization initialization options (placeholder)
+ */
+
+/**
+ * Speaker segment with speaker ID
+ */
+
+/**
+ * Initialize Speaker Diarization with model directory.
+ *
+ * @throws {Error} Not yet implemented
+ */
+export async function initializeDiarization(_options) {
+  throw new Error('Speaker Diarization feature is not yet implemented. This is a placeholder module.');
+}
+
+/**
+ * Perform speaker diarization on an audio file.
+ *
+ * @throws {Error} Not yet implemented
+ */
+export function diarizeAudio(_filePath) {
+  throw new Error('Speaker Diarization feature is not yet implemented. This is a placeholder module.');
+}
+
+/**
+ * Release diarization resources.
+ *
+ * @throws {Error} Not yet implemented
+ */
+export function unloadDiarization() {
+  throw new Error('Speaker Diarization feature is not yet implemented. This is a placeholder module.');
+}
+//# sourceMappingURL=index.js.map

package/lib/module/diarization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["initializeDiarization","_options","Error","diarizeAudio","_filePath","unloadDiarization"],"sourceRoot":"..\\..\\..\\src","sources":["diarization/index.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAMA;AACA;AACA;;AAQA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeA,qBAAqBA,CACzCC,QAAsC,EACvB;EACf,MAAM,IAAIC,KAAK,CACb,mFACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,YAAYA,CAACC,SAAiB,EAA6B;EACzE,MAAM,IAAIF,KAAK,CACb,mFACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,iBAAiBA,CAAA,EAAkB;EACjD,MAAM,IAAIH,KAAK,CACb,mFACF,CAAC;AACH","ignoreList":[]}

package/lib/module/enhancement/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+/**
+ * Speech Enhancement feature module
+ *
+ * @remarks
+ * This feature is not yet implemented. This module serves as a placeholder
+ * for future speech enhancement functionality.
+ *
+ * @example
+ * ```typescript
+ * // Future usage:
+ * import { initializeEnhancement, enhanceAudio } from 'react-native-sherpa-onnx/enhancement';
+ *
+ * await initializeEnhancement({ modelPath: 'models/enhancement-model' });
+ * const enhancedPath = await enhanceAudio('path/to/noisy-audio.wav');
+ * ```
+ */
+
+/**
+ * Enhancement initialization options (placeholder)
+ */
+
+/**
+ * Enhancement result
+ */
+
+/**
+ * Initialize Speech Enhancement with model directory.
+ *
+ * @throws {Error} Not yet implemented
+ */
+export async function initializeEnhancement(_options) {
+  throw new Error('Speech Enhancement feature is not yet implemented. This is a placeholder module.');
+}
+
+/**
+ * Enhance speech quality in an audio file.
+ *
+ * @throws {Error} Not yet implemented
+ */
+export function enhanceAudio(_filePath) {
+  throw new Error('Speech Enhancement feature is not yet implemented. This is a placeholder module.');
+}
+
+/**
+ * Release enhancement resources.
+ *
+ * @throws {Error} Not yet implemented
+ */
+export function unloadEnhancement() {
+  throw new Error('Speech Enhancement feature is not yet implemented. This is a placeholder module.');
+}
+//# sourceMappingURL=index.js.map

package/lib/module/enhancement/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["initializeEnhancement","_options","Error","enhanceAudio","_filePath","unloadEnhancement"],"sourceRoot":"..\\..\\..\\src","sources":["enhancement/index.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAMA;AACA;AACA;;AAMA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeA,qBAAqBA,CACzCC,QAAsC,EACvB;EACf,MAAM,IAAIC,KAAK,CACb,kFACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,YAAYA,CAACC,SAAiB,EAA8B;EAC1E,MAAM,IAAIF,KAAK,CACb,kFACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,iBAAiBA,CAAA,EAAkB;EACjD,MAAM,IAAIH,KAAK,CACb,kFACF,CAAC;AACH","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import SherpaOnnx from "./NativeSherpaOnnx.js";
+
+// Export types and utilities
+
+export { assetModelPath, autoModelPath, fileModelPath, getDefaultModelPath, resolveModelPath } from "./utils.js";
+
+// Re-export STT functionality
+export { initializeSTT, transcribeFile, unloadSTT } from "./stt/index.js";
+// TODO: Uncomment these exports once the features are implemented
+// Re-export other features (when implemented)
+// export * from './tts';
+// export * from './vad';
+// export * from './diarization';
+// export * from './enhancement';
+// export * from './separation';
+
+/**
+ * Test method to verify sherpa-onnx native library is loaded.
+ */
+export function testSherpaInit() {
+  return SherpaOnnx.testSherpaInit();
+}
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SherpaOnnx","assetModelPath","autoModelPath","fileModelPath","getDefaultModelPath","resolveModelPath","initializeSTT","transcribeFile","unloadSTT","testSherpaInit"],"sourceRoot":"..\\..\\src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,UAAU,MAAM,uBAAoB;;AAE3C;;AAEA,SACEC,cAAc,EACdC,aAAa,EACbC,aAAa,EACbC,mBAAmB,EACnBC,gBAAgB,QACX,YAAS;;AAEhB;AACA,SAASC,aAAa,EAAEC,cAAc,EAAEC,SAAS,QAAQ,gBAAO;AAGhE;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAAA,EAAoB;EAChD,OAAOT,UAAU,CAACS,cAAc,CAAC,CAAC;AACpC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}