react-native-sherpa-onnx 0.3.5 → 0.3.6

package/android/src/main/cpp/jni/archive/sherpa-onnx-archive-jni.cpp

@@ -49,11 +49,9 @@ Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2(
     j_progress_callback_global = env->NewGlobalRef(j_progress_callback);
   }
 
-  // Get Promise.resolve and reject methods
+  // Get Promise.resolve method
   jclass promise_class = env->GetObjectClass(j_promise);
   jmethodID resolve_method = env->GetMethodID(promise_class, "resolve", "(Ljava/lang/Object;)V");
-  jmethodID reject_method = env->GetMethodID(promise_class, "reject", 
-                                              "(Ljava/lang/String;Ljava/lang/String;)V");
 
   // Get WritableMap from Arguments
   jclass arguments_class = env->FindClass("com/facebook/react/bridge/Arguments");
@@ -123,15 +121,12 @@ Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2(
       env->CallVoidMethod(result_map, put_string_method,
                           env->NewStringUTF("sha256"), env->NewStringUTF(sha256.c_str()));
     }
-    env->CallVoidMethod(j_promise, resolve_method, result_map);
   } else {
     __android_log_print(ANDROID_LOG_WARN, "SherpaOnnxNative", "[ARCHIVE_ERROR] %s", error_msg.c_str());
     env->CallVoidMethod(result_map, put_string_method,
                         env->NewStringUTF("reason"), env->NewStringUTF(error_msg.c_str()));
-    env->CallVoidMethod(j_promise, reject_method,
-                        env->NewStringUTF("ARCHIVE_ERROR"),
-                        env->NewStringUTF(error_msg.c_str()));
   }
+  env->CallVoidMethod(j_promise, resolve_method, result_map);
 
   // Clean up global reference
   if (j_progress_callback_global != nullptr) {
@@ -144,6 +139,270 @@ Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2(
   env->DeleteLocalRef(writeable_map_class);
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarZst(
+    JNIEnv* env,
+    jobject /* jthis */,
+    jstring j_source_path,
+    jstring j_target_path,
+    jboolean j_force,
+    jobject j_progress_callback,
+    jobject j_promise) {
+  const char* source_path = env->GetStringUTFChars(j_source_path, nullptr);
+  const char* target_path = env->GetStringUTFChars(j_target_path, nullptr);
+  std::string source_str(source_path);
+  std::string target_str(target_path);
+  env->ReleaseStringUTFChars(j_source_path, source_path);
+  env->ReleaseStringUTFChars(j_target_path, target_path);
+
+  jmethodID on_progress_method = nullptr;
+  jobject j_progress_callback_global = nullptr;
+  if (j_progress_callback != nullptr) {
+    jclass callback_class = env->GetObjectClass(j_progress_callback);
+    on_progress_method = env->GetMethodID(callback_class, "invoke", "(JJD)V");
+    env->DeleteLocalRef(callback_class);
+    j_progress_callback_global = env->NewGlobalRef(j_progress_callback);
+  }
+
+  jclass promise_class = env->GetObjectClass(j_promise);
+  jmethodID resolve_method = env->GetMethodID(promise_class, "resolve", "(Ljava/lang/Object;)V");
+
+  jclass arguments_class = env->FindClass("com/facebook/react/bridge/Arguments");
+  jmethodID create_map_method = env->GetStaticMethodID(
+      arguments_class, "createMap", "()Lcom/facebook/react/bridge/WritableMap;");
+  jobject result_map = env->CallStaticObjectMethod(arguments_class, create_map_method);
+
+  jclass writeable_map_class = env->FindClass("com/facebook/react/bridge/WritableMap");
+  jmethodID put_boolean_method = env->GetMethodID(
+      writeable_map_class, "putBoolean", "(Ljava/lang/String;Z)V");
+  jmethodID put_string_method = env->GetMethodID(
+      writeable_map_class, "putString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+  auto on_progress = [j_progress_callback_global, on_progress_method](
+      long long bytes_extracted, long long total_bytes, double percent) {
+    if (j_progress_callback_global != nullptr && on_progress_method != nullptr) {
+      JNIEnv* callback_env = nullptr;
+      bool should_detach = false;
+      if (g_vm->GetEnv(reinterpret_cast<void**>(&callback_env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+        if (g_vm->AttachCurrentThread(&callback_env, nullptr) == JNI_OK) {
+          should_detach = true;
+        } else {
+          return;
+        }
+      }
+      if (callback_env != nullptr) {
+        callback_env->CallVoidMethod(j_progress_callback_global, on_progress_method,
+                            bytes_extracted, total_bytes, percent);
+        if (callback_env->ExceptionCheck()) {
+          callback_env->ExceptionClear();
+        }
+        if (should_detach) {
+          g_vm->DetachCurrentThread();
+        }
+      }
+    }
+  };
+
+  std::string error_msg;
+  std::string sha256;
+  bool success = ArchiveHelper::ExtractTarZst(
+      source_str,
+      target_str,
+      j_force == JNI_TRUE,
+      on_progress,
+      &error_msg,
+      &sha256);
+
+  env->CallVoidMethod(result_map, put_boolean_method,
+                      env->NewStringUTF("success"), success ? JNI_TRUE : JNI_FALSE);
+
+  if (success) {
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("path"), env->NewStringUTF(target_str.c_str()));
+    if (!sha256.empty()) {
+      env->CallVoidMethod(result_map, put_string_method,
+                          env->NewStringUTF("sha256"), env->NewStringUTF(sha256.c_str()));
+    }
+  } else {
+    __android_log_print(ANDROID_LOG_WARN, "SherpaOnnxNative", "[ARCHIVE_ERROR] %s", error_msg.c_str());
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("reason"), env->NewStringUTF(error_msg.c_str()));
+  }
+  env->CallVoidMethod(j_promise, resolve_method, result_map);
+
+  if (j_progress_callback_global != nullptr) {
+    env->DeleteGlobalRef(j_progress_callback_global);
+  }
+
+  env->DeleteLocalRef(result_map);
+  env->DeleteLocalRef(promise_class);
+  env->DeleteLocalRef(arguments_class);
+  env->DeleteLocalRef(writeable_map_class);
+}
+
+namespace {
+struct InputStreamReadContext {
+  JNIEnv* env = nullptr;
+  jobject stream_global = nullptr;
+  jmethodID read_method = nullptr;
+  jbyteArray byte_array = nullptr;
+  const size_t buffer_size = 64 * 1024;
+};
+
+static std::ptrdiff_t JniStreamRead(void* buf, size_t len, void* user_data) {
+  auto* ctx = static_cast<InputStreamReadContext*>(user_data);
+  if (!ctx || !ctx->env || !ctx->stream_global || !ctx->read_method || !ctx->byte_array) {
+    return -1;
+  }
+  size_t to_read = (len < ctx->buffer_size) ? len : ctx->buffer_size;
+  jint n = ctx->env->CallIntMethod(ctx->stream_global, ctx->read_method, ctx->byte_array);
+  if (ctx->env->ExceptionCheck()) {
+    ctx->env->ExceptionClear();
+    return -1;
+  }
+  if (n <= 0) return 0;
+  ctx->env->GetByteArrayRegion(ctx->byte_array, 0, n, static_cast<jbyte*>(buf));
+  return static_cast<std::ptrdiff_t>(n);
+}
+}  // namespace
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarZstFromStream(
+    JNIEnv* env,
+    jobject /* jthis */,
+    jobject j_input_stream,
+    jstring j_target_path,
+    jboolean j_force,
+    jobject j_progress_callback,
+    jobject j_promise) {
+  const char* target_path = env->GetStringUTFChars(j_target_path, nullptr);
+  std::string target_str(target_path);
+  env->ReleaseStringUTFChars(j_target_path, target_path);
+
+  jobject stream_global = env->NewGlobalRef(j_input_stream);
+  jclass stream_class = env->GetObjectClass(j_input_stream);
+  jmethodID read_method = env->GetMethodID(stream_class, "read", "([B)I");
+  env->DeleteLocalRef(stream_class);
+  if (!read_method) {
+    env->DeleteGlobalRef(stream_global);
+    jclass promise_class = env->GetObjectClass(j_promise);
+    jmethodID reject_method = env->GetMethodID(promise_class, "reject", "(Ljava/lang/String;Ljava/lang/String;)V");
+    env->CallVoidMethod(j_promise, reject_method,
+                        env->NewStringUTF("ARCHIVE_ERROR"),
+                        env->NewStringUTF("InputStream.read([B)I not found"));
+    env->DeleteLocalRef(promise_class);
+    return;
+  }
+
+  jbyteArray byte_array = env->NewByteArray(static_cast<jsize>(64 * 1024));
+  if (!byte_array) {
+    env->DeleteGlobalRef(stream_global);
+    return;
+  }
+
+  InputStreamReadContext read_ctx;
+  read_ctx.env = env;
+  read_ctx.stream_global = stream_global;
+  read_ctx.read_method = read_method;
+  read_ctx.byte_array = byte_array;
+
+  jmethodID on_progress_method = nullptr;
+  jobject j_progress_callback_global = nullptr;
+  if (j_progress_callback != nullptr) {
+    jclass callback_class = env->GetObjectClass(j_progress_callback);
+    on_progress_method = env->GetMethodID(callback_class, "invoke", "(JJD)V");
+    env->DeleteLocalRef(callback_class);
+    j_progress_callback_global = env->NewGlobalRef(j_progress_callback);
+  }
+
+  jclass promise_class = env->GetObjectClass(j_promise);
+  jmethodID resolve_method = env->GetMethodID(promise_class, "resolve", "(Ljava/lang/Object;)V");
+
+  jclass arguments_class = env->FindClass("com/facebook/react/bridge/Arguments");
+  jmethodID create_map_method = env->GetStaticMethodID(arguments_class, "createMap", "()Lcom/facebook/react/bridge/WritableMap;");
+  jobject result_map = env->CallStaticObjectMethod(arguments_class, create_map_method);
+
+  jclass writeable_map_class = env->FindClass("com/facebook/react/bridge/WritableMap");
+  jmethodID put_boolean_method = env->GetMethodID(writeable_map_class, "putBoolean", "(Ljava/lang/String;Z)V");
+  jmethodID put_string_method = env->GetMethodID(writeable_map_class, "putString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+  auto on_progress = [j_progress_callback_global, on_progress_method](
+      long long bytes_extracted, long long total_bytes, double percent) {
+    if (j_progress_callback_global != nullptr && on_progress_method != nullptr) {
+      JNIEnv* callback_env = nullptr;
+      bool should_detach = false;
+      if (g_vm->GetEnv(reinterpret_cast<void**>(&callback_env), JNI_VERSION_1_6) == JNI_EDETACHED) {
+        if (g_vm->AttachCurrentThread(&callback_env, nullptr) == JNI_OK) {
+          should_detach = true;
+        } else {
+          return;
+        }
+      }
+      if (callback_env != nullptr) {
+        callback_env->CallVoidMethod(j_progress_callback_global, on_progress_method,
+                            bytes_extracted, total_bytes, percent);
+        if (callback_env->ExceptionCheck()) {
+          callback_env->ExceptionClear();
+        }
+        if (should_detach) {
+          g_vm->DetachCurrentThread();
+        }
+      }
+    }
+  };
+
+  std::string error_msg;
+  std::string sha256;
+  bool success = ArchiveHelper::ExtractFromStream(
+      &JniStreamRead,
+      &read_ctx,
+      target_str,
+      j_force == JNI_TRUE,
+      on_progress,
+      &error_msg,
+      &sha256);
+
+  env->CallVoidMethod(result_map, put_boolean_method,
+                      env->NewStringUTF("success"), success ? JNI_TRUE : JNI_FALSE);
+
+  if (success) {
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("path"), env->NewStringUTF(target_str.c_str()));
+    if (!sha256.empty()) {
+      env->CallVoidMethod(result_map, put_string_method,
+                          env->NewStringUTF("sha256"), env->NewStringUTF(sha256.c_str()));
+    }
+  } else {
+    __android_log_print(ANDROID_LOG_WARN, "SherpaOnnxNative", "[ARCHIVE_ERROR] %s", error_msg.c_str());
+    env->CallVoidMethod(result_map, put_string_method,
+                        env->NewStringUTF("reason"), env->NewStringUTF(error_msg.c_str()));
+  }
+  env->CallVoidMethod(j_promise, resolve_method, result_map);
+
+  env->DeleteGlobalRef(stream_global);
+  env->DeleteLocalRef(byte_array);
+  if (j_progress_callback_global != nullptr) {
+    env->DeleteGlobalRef(j_progress_callback_global);
+  }
+  env->DeleteLocalRef(result_map);
+  env->DeleteLocalRef(promise_class);
+  env->DeleteLocalRef(arguments_class);
+  env->DeleteLocalRef(writeable_map_class);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarBz2FromStream(
+    JNIEnv* env,
+    jobject jthis,
+    jobject j_input_stream,
+    jstring j_target_path,
+    jboolean j_force,
+    jobject j_progress_callback,
+    jobject j_promise) {
+  Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeExtractTarZstFromStream(
+      env, jthis, j_input_stream, j_target_path, j_force, j_progress_callback, j_promise);
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_com_sherpaonnx_SherpaOnnxArchiveHelper_nativeCancelExtract(JNIEnv* /* env */, jobject /* jthis */) {
   ArchiveHelper::Cancel();

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

@@ -1,5 +1,7 @@
 package com.sherpaonnx
 
+import android.content.Context
+import android.util.Log
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import java.util.concurrent.ExecutorService
@@ -31,6 +33,11 @@ class SherpaOnnxArchiveHelper {
     nativeCancelExtract()
   }
 
+  fun cancelExtractTarZst() {
+    cancelRequested.set(true)
+    nativeCancelExtract()
+  }
+
   fun extractTarBz2(
     sourcePath: String,
     targetPath: String,
@@ -71,6 +78,83 @@ class SherpaOnnxArchiveHelper {
     }
   }
 
+  fun extractTarZst(
+    sourcePath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+  ) {
+    val promiseSettled = AtomicBoolean(false)
+    fun resolveOnce(success: Boolean, reason: String? = null) {
+      if (!promiseSettled.compareAndSet(false, true)) return
+      val result = Arguments.createMap()
+      result.putBoolean("success", success)
+      if (reason != null) result.putString("reason", reason)
+      promise.resolve(result)
+    }
+
+    try {
+      cancelRequested.set(false)
+      val progressCallback = object : Any() {
+        fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+          onProgress(bytesExtracted, totalBytes, percent)
+        }
+      }
+      extractExecutor.execute {
+        try {
+          nativeExtractTarZst(sourcePath, targetPath, force, progressCallback, promise)
+        } catch (e: Exception) {
+          resolveOnce(false, "Archive extraction error: ${e.message}")
+        }
+      }
+    } catch (e: Exception) {
+      resolveOnce(false, "Archive extraction error: ${e.message}")
+    }
+  }
+
+  fun extractTarZstFromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+  ) {
+    if (BuildConfig.DEBUG) {
+      Log.i("SherpaOnnx", "extractTarZstFromAsset assetPath=$assetPath targetPath=$targetPath")
+    }
+    cancelRequested.set(false)
+    val progressCallback = object : Any() {
+      fun invoke(bytesExtracted: Long, totalBytes: Long, percent: Double) {
+        onProgress(bytesExtracted, totalBytes, percent)
+      }
+    }
+    extractExecutor.execute {
+      try {
+        context.assets.open(assetPath).use { stream ->
+          nativeExtractTarZstFromStream(stream, targetPath, force, progressCallback, promise)
+        }
+      } catch (e: Exception) {
+        val result = Arguments.createMap()
+        result.putBoolean("success", false)
+        result.putString("reason", e.message ?: "Failed to open asset")
+        promise.resolve(result)
+      }
+    }
+  }
+
+  fun extractTarBz2FromAsset(
+    context: Context,
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise,
+    onProgress: (bytes: Long, totalBytes: Long, percent: Double) -> Unit
+  ) {
+    extractTarZstFromAsset(context, assetPath, targetPath, force, promise, onProgress)
+  }
+
   fun computeFileSha256(filePath: String, promise: Promise) {
     nativeComputeFileSha256(filePath, promise)
   }
@@ -84,6 +168,22 @@ class SherpaOnnxArchiveHelper {
     promise: Promise
   )
 
+  private external fun nativeExtractTarZst(
+    sourcePath: String,
+    targetPath: String,
+    force: Boolean,
+    progressCallback: Any?,
+    promise: Promise
+  )
+
+  private external fun nativeExtractTarZstFromStream(
+    inputStream: java.io.InputStream,
+    targetPath: String,
+    force: Boolean,
+    progressCallback: Any?,
+    promise: Promise
+  )
+
   private external fun nativeCancelExtract()
 
   private external fun nativeComputeFileSha256(

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

@@ -82,10 +82,12 @@ internal class SherpaOnnxAssetHelper(
     try {
       val baseDir = File(path)
       if (!baseDir.exists()) {
-        throw IllegalArgumentException("Path does not exist: $path")
+        promise.resolve(Arguments.createArray())
+        return
       }
       if (!baseDir.isDirectory) {
-        throw IllegalArgumentException("Path is not a directory: $path")
+        promise.resolve(Arguments.createArray())
+        return
       }
 
       val folders = mutableListOf<String>()
@@ -134,11 +136,18 @@ internal class SherpaOnnxAssetHelper(
     try {
       Log.i(logTag, "getAssetPackPath: packName=$packName")
       val assetPackManager = AssetPackManagerFactory.getInstance(context)
-      val location: AssetPackLocation? = assetPackManager.getPackLocation(packName)
+      var location: AssetPackLocation? = assetPackManager.getPackLocation(packName)
       if (location == null) {
-        Log.i(logTag, "getAssetPackPath: location is null for pack '$packName'")
-        promise.resolve(null)
-        return
+        val allLocations = assetPackManager.getPackLocations()
+        location = allLocations?.get(packName)
+        if (allLocations != null) {
+          Log.i(logTag, "getAssetPackPath: getPackLocation was null, getPackLocations keys=${allLocations.keys}")
+        }
+        if (location == null) {
+          Log.i(logTag, "getAssetPackPath: location is null for pack '$packName'")
+          promise.resolve(null)
+          return
+        }
       }
       Log.i(logTag, "getAssetPackPath: storageMethod=${location.packStorageMethod()}, " +
         "assetsPath=${location.assetsPath()}, path=${location.path()}")
@@ -170,6 +179,42 @@ internal class SherpaOnnxAssetHelper(
     }
   }
 
+  /**
+   * Lists asset paths of .tar.zst and .tar.bz2 archives in a PAD pack when stored as APK_ASSETS.
+   * Returns empty array when pack is null or STORAGE_FILES (caller uses path + readDir in that case).
+   * APK_ASSETS: pack content is merged into the app asset root; canonical path is "models"
+   * (pack layout src/main/assets/models/). Same for Play Store and bundletool install-time delivery.
+   */
+  fun listBundledArchiveAssetPaths(packName: String, promise: Promise) {
+    try {
+      val assetPackManager = AssetPackManagerFactory.getInstance(context)
+      var location: AssetPackLocation? = assetPackManager.getPackLocation(packName)
+      if (location == null) {
+        location = assetPackManager.getPackLocations()?.get(packName)
+      }
+      if (location == null) {
+        promise.resolve(Arguments.createArray())
+        return
+      }
+      if (location.packStorageMethod() != AssetPackStorageMethod.STORAGE_FILES) {
+        val assetPrefix = "models"
+        val names = context.assets.list(assetPrefix) ?: emptyArray()
+        val archives = names.filter { it.endsWith(".tar.zst") || it.endsWith(".tar.bz2") }
+        val result = Arguments.createArray()
+        for (name in archives) {
+          result.pushString("$assetPrefix/$name")
+        }
+        Log.i(logTag, "listBundledArchiveAssetPaths: packName=$packName prefix=$assetPrefix count=${result.size()}")
+        promise.resolve(result)
+      } else {
+        promise.resolve(Arguments.createArray())
+      }
+    } catch (e: Exception) {
+      Log.w(logTag, "listBundledArchiveAssetPaths failed: ${e.message}")
+      promise.resolve(Arguments.createArray())
+    }
+  }
+
   private fun resolveAssetPath(assetPath: String): String {
     Log.i(logTag, "resolveAssetPath: assetPath=$assetPath")
     val assetManager = context.assets

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

@@ -303,6 +303,17 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     promise.resolve(null)
   }
 
+  override fun extractTarZst(sourcePath: String, targetPath: String, force: Boolean, promise: Promise) {
+    archiveHelper.extractTarZst(sourcePath, targetPath, force, promise) { bytes, total, percent ->
+      emitExtractTarZstProgress(sourcePath, bytes, total, percent)
+    }
+  }
+
+  override fun cancelExtractTarZst(promise: Promise) {
+    archiveHelper.cancelExtractTarZst()
+    promise.resolve(null)
+  }
+
   override fun computeFileSha256(filePath: String, promise: Promise) {
     archiveHelper.computeFileSha256(filePath, promise)
   }
@@ -318,6 +329,17 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     eventEmitter.emit("extractTarBz2Progress", payload)
   }
 
+  private fun emitExtractTarZstProgress(sourcePath: String, bytes: Long, totalBytes: Long, percent: Double) {
+    val eventEmitter = reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+    val payload = Arguments.createMap()
+    payload.putString("sourcePath", sourcePath)
+    payload.putDouble("bytes", bytes.toDouble())
+    payload.putDouble("totalBytes", totalBytes.toDouble())
+    payload.putDouble("percent", percent)
+    eventEmitter.emit("extractTarZstProgress", payload)
+  }
+
   /**
    * 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/)
@@ -997,6 +1019,44 @@ class SherpaOnnxModule(reactContext: ReactApplicationContext) :
     assetHelper.getAssetPackPath(packName, promise)
   }
 
+  override fun listBundledArchiveAssetPaths(packName: String, promise: Promise) {
+    assetHelper.listBundledArchiveAssetPaths(packName, promise)
+  }
+
+  override fun extractTarZstFromAsset(
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise
+  ) {
+    archiveHelper.extractTarZstFromAsset(
+      reactApplicationContext,
+      assetPath,
+      targetPath,
+      force,
+      promise
+    ) { bytes, total, percent ->
+      emitExtractTarZstProgress(assetPath, bytes, total, percent)
+    }
+  }
+
+  override fun extractTarBz2FromAsset(
+    assetPath: String,
+    targetPath: String,
+    force: Boolean,
+    promise: Promise
+  ) {
+    archiveHelper.extractTarBz2FromAsset(
+      reactApplicationContext,
+      assetPath,
+      targetPath,
+      force,
+      promise
+    ) { bytes, total, percent ->
+      emitExtractProgress(assetPath, bytes, total, percent)
+    }
+  }
+
   companion object {
     const val NAME = "SherpaOnnx"
 

package/ios/SherpaOnnx.mm

@@ -38,7 +38,7 @@
 
 - (NSArray<NSString *> *)supportedEvents
 {
-    return @[ @"ttsStreamChunk", @"ttsStreamEnd", @"ttsStreamError", @"extractTarBz2Progress", @"pcmLiveStreamData", @"pcmLiveStreamError" ];
+    return @[ @"ttsStreamChunk", @"ttsStreamEnd", @"ttsStreamError", @"extractTarBz2Progress", @"extractTarZstProgress", @"pcmLiveStreamData", @"pcmLiveStreamError" ];
 }
 
 - (void)resolveModelPath:(JS::NativeSherpaOnnx::SpecResolveModelPathConfig &)config
@@ -162,6 +162,33 @@
     resolve(nil);
 }
 
+- (void)extractTarZst:(NSString *)sourcePath
+           targetPath:(NSString *)targetPath
+                force:(BOOL)force
+             resolve:(RCTPromiseResolveBlock)resolve
+             reject:(RCTPromiseRejectBlock)reject
+{
+    SherpaOnnxArchiveHelper *helper = [SherpaOnnxArchiveHelper new];
+    NSDictionary *result = [helper extractTarZst:sourcePath
+                                    targetPath:targetPath
+                                         force:force
+                                      progress:^(long long bytes, long long totalBytes, double percent) {
+        [self sendEventWithName:@"extractTarZstProgress"
+                           body:@{ @"sourcePath": sourcePath,
+                                   @"bytes": @(bytes),
+                                   @"totalBytes": @(totalBytes),
+                                   @"percent": @(percent) }];
+    }];
+    resolve(result);
+}
+
+- (void)cancelExtractTarZst:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+    [SherpaOnnxArchiveHelper cancelExtractTarZst];
+    resolve(nil);
+}
+
 - (void)computeFileSha256:(NSString *)filePath
              resolve:(RCTPromiseResolveBlock)resolve
              reject:(RCTPromiseRejectBlock)reject
@@ -184,6 +211,32 @@
     resolve([NSNull null]);
 }
 
+- (void)listBundledArchiveAssetPaths:(NSString *)packName
+                             resolve:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject
+{
+    // PAD APK_ASSETS listing is Android-only.
+    resolve(@[]);
+}
+
+- (void)extractTarZstFromAsset:(NSString *)assetPath
+                   targetPath:(NSString *)targetPath
+                       force:(NSNumber *)force
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@{ @"success": @NO, @"reason": @"Not supported on iOS; use path-based extraction." });
+}
+
+- (void)extractTarBz2FromAsset:(NSString *)assetPath
+                   targetPath:(NSString *)targetPath
+                        force:(NSNumber *)force
+                      resolve:(RCTPromiseResolveBlock)resolve
+                       reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@{ @"success": @NO, @"reason": @"Not supported on iOS; use path-based extraction." });
+}
+
 - (void)convertAudioToFormat:(NSString *)inputPath
                  outputPath:(NSString *)outputPath
                      format:(NSString *)format

package/ios/archive/sherpa-onnx-archive-helper.h

@@ -11,11 +11,18 @@ typedef void (^SherpaOnnxArchiveProgressBlock)(long long bytes, long long totalB
                           force:(BOOL)force
                        progress:(nullable SherpaOnnxArchiveProgressBlock)progress;
 
+- (NSDictionary *)extractTarZst:(NSString *)sourcePath
+                     targetPath:(NSString *)targetPath
+                          force:(BOOL)force
+                       progress:(nullable SherpaOnnxArchiveProgressBlock)progress;
+
 - (nullable NSString *)computeFileSha256:(NSString *)filePath
                                    error:(NSError * _Nullable * _Nullable)error;
 
 + (void)cancelExtractTarBz2;
 
++ (void)cancelExtractTarZst;
+
 @end
 
 NS_ASSUME_NONNULL_END