react-native-sherpa-onnx 0.1.0

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

@@ -0,0 +1,56 @@
+#ifndef SHERPA_ONNX_WRAPPER_H
+#define SHERPA_ONNX_WRAPPER_H
+
+#include <string>
+#include <memory>
+
+namespace sherpaonnx {
+
+/**
+ * Wrapper class for sherpa-onnx OfflineRecognizer.
+ * This provides a C++ interface that can be easily called from JNI.
+ */
+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/android/src/main/java/com/sherpaonnx/SherpaOnnxModule.kt

@@ -0,0 +1,316 @@
+package com.sherpaonnx
+
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+
+@ReactModule(name = SherpaOnnxModule.NAME)
+class SherpaOnnxModule(reactContext: ReactApplicationContext) :
+  NativeSherpaOnnxSpec(reactContext) {
+
+  init {
+    System.loadLibrary("sherpaonnx")
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  /**
+   * Test method to verify sherpa-onnx native library is loaded.
+   * This is a minimal "Hello World" test for Phase 1.
+   */
+  override fun testSherpaInit(promise: Promise) {
+    try {
+      val result = nativeTestSherpaInit()
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("INIT_ERROR", "Failed to test sherpa-onnx initialization", e)
+    }
+  }
+
+  /**
+   * Resolve model path based on configuration.
+   * Handles asset paths, file system paths, and auto-detection.
+   */
+  override fun resolveModelPath(config: ReadableMap, promise: Promise) {
+    try {
+      val type = config.getString("type") ?: "auto"
+      val path = config.getString("path")
+        ?: throw IllegalArgumentException("Path is required")
+
+      val resolvedPath = when (type) {
+        "asset" -> resolveAssetPath(path)
+        "file" -> resolveFilePath(path)
+        "auto" -> resolveAutoPath(path)
+        else -> throw IllegalArgumentException("Unknown path type: $type")
+      }
+
+      promise.resolve(resolvedPath)
+    } catch (e: Exception) {
+      val errorMessage = "Failed to resolve model path: ${e.message ?: e.javaClass.simpleName}"
+      Log.e(NAME, errorMessage, e)
+      promise.reject("PATH_RESOLVE_ERROR", errorMessage, e)
+    }
+  }
+
+  /**
+   * Resolve asset path - copy from assets to internal storage if needed
+   * Preserves the directory structure from assets (e.g., test_wavs/ stays as test_wavs/)
+   */
+  private fun resolveAssetPath(assetPath: String): String {
+    val assetManager = reactApplicationContext.assets
+    
+    // Extract base directory from path (e.g., "test_wavs/en-1.wav" -> "test_wavs", "models/sherpa-onnx-model" -> "models")
+    val pathParts = assetPath.split("/")
+    val baseDir = if (pathParts.size > 1) pathParts[0] else "models"
+    
+    val targetBaseDir = File(reactApplicationContext.filesDir, baseDir)
+    targetBaseDir.mkdirs()
+
+    // Check if it's a file path (contains a file extension) or directory path
+    val isFilePath = pathParts.any { it.contains(".") && !it.startsWith(".") }
+    
+    val targetPath = if (isFilePath) {
+      // It's a file path (e.g., test_wavs/en-1.wav)
+      // Return the full file path
+      File(targetBaseDir, pathParts.drop(1).joinToString("/"))
+    } else {
+      // It's a directory path (e.g., models/sherpa-onnx-model)
+      // Return the directory path
+      File(targetBaseDir, File(assetPath).name)
+    }
+    
+    // Check if already extracted
+    if (isFilePath) {
+      // For files, check if file exists
+      if (targetPath.exists() && targetPath.isFile) {
+        return targetPath.absolutePath
+      }
+      // Extract the parent directory (e.g., test_wavs/)
+      val parentDir = targetPath.parentFile ?: targetBaseDir
+      parentDir.mkdirs()
+      
+      // Try to copy the file directly first
+      try {
+        assetManager.open(assetPath).use { input ->
+          FileOutputStream(targetPath).use { output ->
+            input.copyTo(output)
+          }
+        }
+        return targetPath.absolutePath
+      } catch (e: java.io.FileNotFoundException) {
+        // If direct file open fails, try to copy the parent directory recursively
+        // This handles cases where the file is in a subdirectory
+        val parentAssetPath = pathParts.dropLast(1).joinToString("/")
+        if (parentAssetPath.isNotEmpty()) {
+          try {
+            // Copy the entire parent directory
+            copyAssetRecursively(assetManager, parentAssetPath, parentDir)
+            // Check if file now exists
+            if (targetPath.exists() && targetPath.isFile) {
+              return targetPath.absolutePath
+            }
+            throw IllegalArgumentException("File not found after copying parent directory: $assetPath")
+          } catch (dirException: Exception) {
+            throw IllegalArgumentException("Failed to extract asset file: $assetPath. Tried direct copy and directory copy.", dirException)
+          }
+        } else {
+          throw IllegalArgumentException("Failed to extract asset file: $assetPath", e)
+        }
+      } catch (e: Exception) {
+        throw IllegalArgumentException("Failed to extract asset file: $assetPath", e)
+      }
+    } else {
+      // For directories, check if directory exists
+      if (targetPath.exists() && targetPath.isDirectory) {
+        return targetPath.absolutePath
+      }
+      // Extract from assets recursively
+      try {
+        targetPath.mkdirs()
+        copyAssetRecursively(assetManager, assetPath, targetPath)
+        return targetPath.absolutePath
+      } catch (e: Exception) {
+        throw IllegalArgumentException("Failed to extract asset directory: $assetPath", e)
+      }
+    }
+  }
+
+  /**
+   * Recursively copy assets from asset manager to target directory
+   */
+  private fun copyAssetRecursively(
+    assetManager: android.content.res.AssetManager,
+    assetPath: String,
+    targetDir: File
+  ) {
+    val assetFiles = assetManager.list(assetPath)
+      ?: throw IllegalArgumentException("Asset path not found: $assetPath")
+
+    for (fileName in assetFiles) {
+      val assetFilePath = "$assetPath/$fileName"
+      val targetFile = File(targetDir, fileName)
+
+      try {
+        // Try to list as directory first
+        val subFiles = assetManager.list(assetFilePath)
+        if (subFiles != null && subFiles.isNotEmpty()) {
+          // It's a directory, recurse
+          targetFile.mkdirs()
+          copyAssetRecursively(assetManager, assetFilePath, targetFile)
+        } else {
+          // It's a file, copy it
+          assetManager.open(assetFilePath).use { input ->
+            FileOutputStream(targetFile).use { output ->
+              input.copyTo(output)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        // If listing fails, try to open as file
+        try {
+          assetManager.open(assetFilePath).use { input ->
+            FileOutputStream(targetFile).use { output ->
+              input.copyTo(output)
+            }
+          }
+        } catch (fileException: Exception) {
+          throw IllegalArgumentException("Failed to copy asset: $assetFilePath", fileException)
+        }
+      }
+    }
+  }
+
+  /**
+   * Resolve file system path - verify it exists
+   */
+  private fun resolveFilePath(filePath: String): String {
+    val file = File(filePath)
+    if (!file.exists()) {
+      throw IllegalArgumentException("File path does not exist: $filePath")
+    }
+    if (!file.isDirectory) {
+      throw IllegalArgumentException("Path is not a directory: $filePath")
+    }
+    return file.absolutePath
+  }
+
+  /**
+   * Auto-detect path - try asset first, then file system
+   */
+  private fun resolveAutoPath(path: String): String {
+    return try {
+      resolveAssetPath(path)
+    } catch (e: Exception) {
+      // If asset fails, try file system
+      try {
+        resolveFilePath(path)
+      } catch (fileException: Exception) {
+        throw IllegalArgumentException(
+          "Path not found as asset or file: $path. Asset error: ${e.message}, File error: ${fileException.message}",
+          e
+        )
+      }
+    }
+  }
+
+  /**
+   * Initialize sherpa-onnx with model directory.
+   * Phase 1: Stub implementation
+   */
+  override fun initializeSherpaOnnx(
+    modelDir: String,
+    preferInt8: Boolean?,
+    modelType: String?,
+    promise: Promise
+  ) {
+    try {
+      // Verify model directory exists
+      val modelDirFile = File(modelDir)
+      if (!modelDirFile.exists()) {
+        val errorMsg = "Model directory does not exist: $modelDir"
+        Log.e(NAME, errorMsg)
+        promise.reject("INIT_ERROR", errorMsg)
+        return
+      }
+      
+      if (!modelDirFile.isDirectory) {
+        val errorMsg = "Model path is not a directory: $modelDir"
+        Log.e(NAME, errorMsg)
+        promise.reject("INIT_ERROR", errorMsg)
+        return
+      }
+      
+      val success = nativeInitialize(
+        modelDir,
+        preferInt8 ?: false,
+        preferInt8 != null,
+        modelType ?: "auto"
+      )
+      if (success) {
+        promise.resolve(null)
+      } else {
+        val errorMsg = "Failed to initialize sherpa-onnx. Check native logs for details."
+        Log.e(NAME, "Native initialization returned false for modelDir: $modelDir")
+        promise.reject("INIT_ERROR", errorMsg)
+      }
+    } catch (e: Exception) {
+      val errorMsg = "Exception during initialization: ${e.message ?: e.javaClass.simpleName}"
+      Log.e(NAME, errorMsg, e)
+      promise.reject("INIT_ERROR", errorMsg, e)
+    }
+  }
+
+  /**
+   * Transcribe an audio file.
+   * Phase 1: Stub implementation
+   */
+  override fun transcribeFile(filePath: String, promise: Promise) {
+    try {
+      val result = nativeTranscribeFile(filePath)
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("TRANSCRIBE_ERROR", "Failed to transcribe file", e)
+    }
+  }
+
+  /**
+   * Release sherpa-onnx resources.
+   */
+  override fun unloadSherpaOnnx(promise: Promise) {
+    try {
+      nativeRelease()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("RELEASE_ERROR", "Failed to release resources", e)
+    }
+  }
+
+  companion object {
+    const val NAME = "SherpaOnnx"
+
+    // Native JNI methods
+    @JvmStatic
+    private external fun nativeTestSherpaInit(): String
+
+    @JvmStatic
+    private external fun nativeInitialize(
+      modelDir: String,
+      preferInt8: Boolean,
+      hasPreferInt8: Boolean,
+      modelType: String
+    ): Boolean
+
+    @JvmStatic
+    private external fun nativeTranscribeFile(filePath: String): String
+
+    @JvmStatic
+    private external fun nativeRelease()
+  }
+}

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

@@ -0,0 +1,33 @@
+package com.sherpaonnx
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class SherpaOnnxPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == SherpaOnnxModule.NAME) {
+      SherpaOnnxModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[SherpaOnnxModule.NAME] = ReactModuleInfo(
+        SherpaOnnxModule.NAME,
+        SherpaOnnxModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/SherpaOnnx.h

@@ -0,0 +1,5 @@
+#import <SherpaOnnxSpec/SherpaOnnxSpec.h>
+
+@interface SherpaOnnx : NSObject <NativeSherpaOnnxSpec>
+
+@end

package/ios/SherpaOnnx.mm

@@ -0,0 +1,293 @@
+#import "SherpaOnnx.h"
+#import <React/RCTUtils.h>
+#import <React/RCTLog.h>
+#import "sherpa-onnx-wrapper.h"
+#import <memory>
+#import <optional>
+#import <string>
+
+@implementation SherpaOnnx
+- (void)resolveModelPath:(NSDictionary *)config
+                withResolver:(RCTPromiseResolveBlock)resolve
+                withRejecter:(RCTPromiseRejectBlock)reject
+{
+    NSString *type = config[@"type"] ?: @"auto";
+    NSString *path = config[@"path"];
+    
+    if (!path) {
+        reject(@"PATH_REQUIRED", @"Path is required", nil);
+        return;
+    }
+    
+    NSError *error = nil;
+    NSString *resolvedPath = nil;
+    
+    if ([type isEqualToString:@"asset"]) {
+        resolvedPath = [self resolveAssetPath:path error:&error];
+    } else if ([type isEqualToString:@"file"]) {
+        resolvedPath = [self resolveFilePath:path error:&error];
+    } else if ([type isEqualToString:@"auto"]) {
+        resolvedPath = [self resolveAutoPath:path error:&error];
+    } else {
+        NSString *errorMsg = [NSString stringWithFormat:@"Unknown path type: %@", type];
+        reject(@"INVALID_TYPE", errorMsg, nil);
+        return;
+    }
+    
+    if (error) {
+        reject(@"PATH_RESOLVE_ERROR", error.localizedDescription, error);
+        return;
+    }
+    
+    resolve(resolvedPath);
+}
+
+- (NSString *)resolveAssetPath:(NSString *)assetPath error:(NSError **)error
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    
+    // First, try to find directly in bundle (for folder references)
+    NSString *bundlePath = [[NSBundle mainBundle] pathForResource:assetPath ofType:nil];
+    
+    if (bundlePath && [fileManager fileExistsAtPath:bundlePath]) {
+        return bundlePath;
+    }
+    
+    // Try with directory structure (for resources in subdirectories)
+    NSArray *pathComponents = [assetPath componentsSeparatedByString:@"/"];
+    if (pathComponents.count > 1) {
+        NSString *directory = pathComponents[0];
+        for (NSInteger i = 1; i < pathComponents.count - 1; i++) {
+            directory = [directory stringByAppendingPathComponent:pathComponents[i]];
+        }
+        NSString *resourceName = pathComponents.lastObject;
+        bundlePath = [[NSBundle mainBundle] pathForResource:resourceName ofType:nil inDirectory:directory];
+        
+        if (bundlePath && [fileManager fileExistsAtPath:bundlePath]) {
+            return bundlePath;
+        }
+    }
+    
+    // If not found in bundle, try to copy from bundle to Documents
+    NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+    NSString *targetDir = [documentsPath stringByAppendingPathComponent:@"models"];
+    NSString *modelDir = [targetDir stringByAppendingPathComponent:[assetPath lastPathComponent]];
+    
+    // Check if already copied
+    if ([fileManager fileExistsAtPath:modelDir]) {
+        return modelDir;
+    }
+    
+    // Try to find and copy from bundle resource path
+    NSString *bundleResourcePath = [[NSBundle mainBundle] resourcePath];
+    NSString *sourcePath = [bundleResourcePath stringByAppendingPathComponent:assetPath];
+    
+    if ([fileManager fileExistsAtPath:sourcePath]) {
+        NSError *copyError = nil;
+        [fileManager createDirectoryAtPath:targetDir withIntermediateDirectories:YES attributes:nil error:&copyError];
+        if (copyError) {
+            if (error) *error = copyError;
+            return nil;
+        }
+        
+        // Copy recursively if it's a directory
+        BOOL isDirectory = NO;
+        [fileManager fileExistsAtPath:sourcePath isDirectory:&isDirectory];
+        
+        if (isDirectory) {
+            [fileManager copyItemAtPath:sourcePath toPath:modelDir error:&copyError];
+        } else {
+            [fileManager copyItemAtPath:sourcePath toPath:modelDir error:&copyError];
+        }
+        
+        if (copyError) {
+            if (error) *error = copyError;
+            return nil;
+        }
+        
+        return modelDir;
+    }
+    
+    if (error) {
+        *error = [NSError errorWithDomain:@"SherpaOnnx"
+                                      code:1
+                                  userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Asset path not found: %@", assetPath]}];
+    }
+    return nil;
+}
+
+- (NSString *)resolveFilePath:(NSString *)filePath error:(NSError **)error
+{
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    BOOL isDirectory = NO;
+    BOOL exists = [fileManager fileExistsAtPath:filePath isDirectory:&isDirectory];
+    
+    if (!exists) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"SherpaOnnx"
+                                          code:2
+                                      userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"File path does not exist: %@", filePath]}];
+        }
+        return nil;
+    }
+    
+    if (!isDirectory) {
+        if (error) {
+            *error = [NSError errorWithDomain:@"SherpaOnnx"
+                                          code:3
+                                      userInfo:@{NSLocalizedDescriptionKey: [NSString stringWithFormat:@"Path is not a directory: %@", filePath]}];
+        }
+        return nil;
+    }
+    
+    return [filePath stringByStandardizingPath];
+}
+
+- (NSString *)resolveAutoPath:(NSString *)path error:(NSError **)error
+{
+    // Try asset first
+    NSError *assetError = nil;
+    NSString *resolvedPath = [self resolveAssetPath:path error:&assetError];
+    
+    if (resolvedPath) {
+        return resolvedPath;
+    }
+    
+    // If asset fails, try file system
+    NSError *fileError = nil;
+    resolvedPath = [self resolveFilePath:path error:&fileError];
+    
+    if (resolvedPath) {
+        return resolvedPath;
+    }
+    
+    // Both failed
+    if (error) {
+        NSString *errorMessage = [NSString stringWithFormat:@"Path not found as asset or file: %@. Asset error: %@, File error: %@",
+                                   path,
+                                   assetError.localizedDescription ?: @"Unknown",
+                                   fileError.localizedDescription ?: @"Unknown"];
+        *error = [NSError errorWithDomain:@"SherpaOnnx"
+                                      code:4
+                                  userInfo:@{NSLocalizedDescriptionKey: errorMessage}];
+    }
+    return nil;
+}
+
+// Global wrapper instance
+static std::unique_ptr<sherpaonnx::SherpaOnnxWrapper> g_wrapper = nullptr;
+
+- (void)initializeSherpaOnnx:(NSString *)modelDir
+                preferInt8:(NSNumber *)preferInt8
+                 modelType:(NSString *)modelType
+                withResolver:(RCTPromiseResolveBlock)resolve
+                withRejecter:(RCTPromiseRejectBlock)reject
+{
+    RCTLogInfo(@"Initializing sherpa-onnx with modelDir: %@", modelDir);
+    
+    @try {
+        if (g_wrapper == nullptr) {
+            g_wrapper = std::make_unique<sherpaonnx::SherpaOnnxWrapper>();
+        }
+        
+        std::string modelDirStr = [modelDir UTF8String];
+        
+        // Convert NSNumber to std::optional<bool>
+        std::optional<bool> preferInt8Opt = std::nullopt;
+        if (preferInt8 != nil) {
+            preferInt8Opt = [preferInt8 boolValue];
+        }
+        
+        // Convert NSString to std::optional<std::string>
+        std::optional<std::string> modelTypeOpt = std::nullopt;
+        if (modelType != nil && [modelType length] > 0) {
+            modelTypeOpt = [modelType UTF8String];
+        }
+        
+        bool result = g_wrapper->initialize(modelDirStr, preferInt8Opt, modelTypeOpt);
+        
+        if (result) {
+            RCTLogInfo(@"Sherpa-onnx initialized successfully");
+            resolve(nil);
+        } else {
+            NSString *errorMsg = [NSString stringWithFormat:@"Failed to initialize sherpa-onnx with model directory: %@", modelDir];
+            RCTLogError(@"%@", errorMsg);
+            reject(@"INIT_ERROR", errorMsg, nil);
+        }
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Exception during initialization: %@", exception.reason];
+        RCTLogError(@"%@", errorMsg);
+        reject(@"INIT_ERROR", errorMsg, nil);
+    }
+}
+
+- (void)testSherpaInitWithResolver:(RCTPromiseResolveBlock)resolve
+                    withRejecter:(RCTPromiseRejectBlock)reject
+{
+    @try {
+        // Test that sherpa-onnx headers are available
+        resolve(@"Sherpa ONNX loaded!");
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Exception during test: %@", exception.reason];
+        reject(@"TEST_ERROR", errorMsg, nil);
+    }
+}
+
+- (void)transcribeFile:(NSString *)filePath
+          withResolver:(RCTPromiseResolveBlock)resolve
+          withRejecter:(RCTPromiseRejectBlock)reject
+{
+    @try {
+        if (g_wrapper == nullptr || !g_wrapper->isInitialized()) {
+            reject(@"TRANSCRIBE_ERROR", @"Sherpa-onnx not initialized. Call initializeSherpaOnnx first.", nil);
+            return;
+        }
+        
+        std::string filePathStr = [filePath UTF8String];
+        std::string result = g_wrapper->transcribeFile(filePathStr);
+        
+        // Convert result to NSString - empty strings are valid (e.g., silence)
+        NSString *transcribedText = [NSString stringWithUTF8String:result.c_str()];
+        if (transcribedText == nil) {
+            // If conversion fails, treat as empty string
+            transcribedText = @"";
+        }
+        
+        resolve(transcribedText);
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Exception during transcription: %@", exception.reason];
+        RCTLogError(@"%@", errorMsg);
+        reject(@"TRANSCRIBE_ERROR", errorMsg, nil);
+    }
+}
+
+- (void)unloadSherpaOnnxWithResolver:(RCTPromiseResolveBlock)resolve
+                      withRejecter:(RCTPromiseRejectBlock)reject
+{
+    @try {
+        if (g_wrapper != nullptr) {
+            g_wrapper->release();
+            g_wrapper.reset();
+            g_wrapper = nullptr;
+        }
+        RCTLogInfo(@"Sherpa-onnx resources released");
+        resolve(nil);
+    } @catch (NSException *exception) {
+        NSString *errorMsg = [NSString stringWithFormat:@"Exception during cleanup: %@", exception.reason];
+        RCTLogError(@"%@", errorMsg);
+        reject(@"CLEANUP_ERROR", errorMsg, nil);
+    }
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeSherpaOnnxSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"SherpaOnnx";
+}
+
+@end