react-native-sherpa-onnx 0.3.5 → 0.3.7

package/android/src/main/cpp/CMakeLists.txt

@@ -29,7 +29,7 @@ get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../../.." ABSOL
 set(USE_FFMPEG ON)
 if(SHERPA_ONNX_DISABLE_FFMPEG)
     set(USE_FFMPEG OFF)
-    message(STATUS "FFmpeg disabled (SHERPA_ONNX_DISABLE_FFMPEG=ON). convertAudioToWav16k/convertAudioToFormat will return an error at runtime.")
+    message(STATUS "FFmpeg disabled (SHERPA_ONNX_DISABLE_FFMPEG=ON). convertAudioToWav16k/convertAudioToFormat and decode (non-WAV) will return an error at runtime.")
 endif()
 
 if(USE_FFMPEG)
@@ -39,25 +39,32 @@ set(FFMPEG_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/ffmpeg_prebuilt/android
 set(FFMPEG_PREBUILT_LIB "${FFMPEG_PREBUILT_BASE}/${ANDROID_ABI}/lib")
 set(FFMPEG_JNILIBS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
 set(FFMPEG_INCLUDE_CPP "${PROJECT_ROOT}/src/main/cpp/include/ffmpeg")
-if(EXISTS "${FFMPEG_PREBUILT_BASE}/include")
+# Require a real header — an empty third_party/.../include/ dir must not win over Gradle-populated cpp/include/ffmpeg.
+if(EXISTS "${FFMPEG_PREBUILT_BASE}/include/libavcodec/avcodec.h")
     set(FFMPEG_INCLUDE_DIR "${FFMPEG_PREBUILT_BASE}/include")
     message(STATUS "FFmpeg headers: prebuilts ${FFMPEG_INCLUDE_DIR}")
-elseif(EXISTS "${FFMPEG_INCLUDE_CPP}")
+elseif(EXISTS "${FFMPEG_INCLUDE_CPP}/libavcodec/avcodec.h")
     set(FFMPEG_INCLUDE_DIR "${FFMPEG_INCLUDE_CPP}")
-    message(STATUS "FFmpeg headers: jniLibs/release ${FFMPEG_INCLUDE_DIR}")
+    message(STATUS "FFmpeg headers: module tree ${FFMPEG_INCLUDE_DIR}")
 else()
     message(FATAL_ERROR "FFmpeg headers missing. Either:\n"
                         "  - Build: cd third_party/ffmpeg_prebuilt && ./build_ffmpeg.sh (creates android/include)\n"
                         "  - Or use a release that includes include/ (Gradle extracts to ${FFMPEG_INCLUDE_CPP})")
 endif()
+# Prebuilts may be either legacy layout android/<abi>/lib/ (build_ffmpeg.sh) or
+# android/jni/<abi>/ (same as Gradle THIRD_PARTY in docs/PREBUILT_RESOLUTION.md).
+set(FFMPEG_PREBUILT_JNI_ABI "${FFMPEG_PREBUILT_BASE}/jni/${ANDROID_ABI}")
 if(EXISTS "${FFMPEG_PREBUILT_LIB}/libavcodec.so")
     set(FFMPEG_LIB_DIR "${FFMPEG_PREBUILT_LIB}")
     message(STATUS "FFmpeg libs: prebuilts ${FFMPEG_LIB_DIR}")
+elseif(EXISTS "${FFMPEG_PREBUILT_JNI_ABI}/libavcodec.so")
+    set(FFMPEG_LIB_DIR "${FFMPEG_PREBUILT_JNI_ABI}")
+    message(STATUS "FFmpeg libs: prebuilts (jni/<abi>) ${FFMPEG_LIB_DIR}")
 elseif(EXISTS "${FFMPEG_JNILIBS}/libavcodec.so")
     set(FFMPEG_LIB_DIR "${FFMPEG_JNILIBS}")
     message(STATUS "FFmpeg libs: jniLibs ${FFMPEG_LIB_DIR}")
 else()
-    message(FATAL_ERROR "FFmpeg libs missing for ABI ${ANDROID_ABI}. Run third_party/ffmpeg_prebuilt/copy_prebuilts_to_sdk.js or ensure ANDROID_RELEASE_TAG release is downloaded.")
+    message(FATAL_ERROR "FFmpeg libs missing for ABI ${ANDROID_ABI}. Run a Gradle Android build so prebuilts populate jniLibs, or add local .so under jniLibs / ffmpeg prebuilts paths.")
 endif()
 endif(USE_FFMPEG)
 
@@ -82,7 +89,6 @@ set(SOURCES
     jni/model_detect/sherpa-onnx-stt-wrapper.cpp
     jni/model_detect/sherpa-onnx-tts-wrapper.cpp
     jni/audio/sherpa-onnx-audio-convert-jni.cpp
-    jni/tts/sherpa-onnx-tts-zipvoice-jni.cpp
     crypto/sha256.cpp
 )
 
@@ -93,10 +99,19 @@ set(LIBARCHIVE_PREBUILT_LIB "${LIBARCHIVE_PREBUILT_BASE}/${ANDROID_ABI}/lib")
 set(LIBARCHIVE_JNILIBS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
 set(LIBARCHIVE_INCLUDE_CPP "${PROJECT_ROOT}/src/main/cpp/include/libarchive")
 set(USE_LIBARCHIVE_PREBUILT OFF)
+set(LIBARCHIVE_PREBUILT_JNI_ABI "${LIBARCHIVE_PREBUILT_BASE}/jni/${ANDROID_ABI}")
 if(EXISTS "${LIBARCHIVE_PREBUILT_LIB}/libarchive.so")
     set(USE_LIBARCHIVE_PREBUILT ON)
     set(LIBARCHIVE_LIB_DIR "${LIBARCHIVE_PREBUILT_LIB}")
-    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include")
+    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include/archive.h")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_PREBUILT_BASE}/include")
+    elseif(EXISTS "${LIBARCHIVE_INCLUDE_CPP}/archive.h")
+        set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_INCLUDE_CPP}")
+    endif()
+elseif(EXISTS "${LIBARCHIVE_PREBUILT_JNI_ABI}/libarchive.so")
+    set(USE_LIBARCHIVE_PREBUILT ON)
+    set(LIBARCHIVE_LIB_DIR "${LIBARCHIVE_PREBUILT_JNI_ABI}")
+    if(EXISTS "${LIBARCHIVE_PREBUILT_BASE}/include/archive.h")
         set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_PREBUILT_BASE}/include")
     elseif(EXISTS "${LIBARCHIVE_INCLUDE_CPP}/archive.h")
         set(LIBARCHIVE_INCLUDE_DIR "${LIBARCHIVE_INCLUDE_CPP}")
@@ -128,15 +143,19 @@ add_library(sherpaonnx SHARED
 # If we used IMPORTED here, AGP would also copy .so from CMake --> duplicate in mergeNativeLibs.
 set(SHERPA_ONNX_PREBUILT_BASE "${PROJECT_ROOT}/../third_party/sherpa-onnx-prebuilt/android")
 set(SHERPA_ONNX_ABI_LIB "${SHERPA_ONNX_PREBUILT_BASE}/${ANDROID_ABI}/lib")
+set(SHERPA_ONNX_JNI_ABI "${SHERPA_ONNX_PREBUILT_BASE}/jni/${ANDROID_ABI}")
 set(SHERPA_C_API_LIB_DIR "")
 if(EXISTS "${SHERPA_ONNX_ABI_LIB}/libsherpa-onnx-c-api.so")
     set(SHERPA_C_API_LIB_DIR "${SHERPA_ONNX_ABI_LIB}")
     message(STATUS "sherpa-onnx C-API (link only): ${SHERPA_C_API_LIB_DIR}")
+elseif(EXISTS "${SHERPA_ONNX_JNI_ABI}/libsherpa-onnx-c-api.so")
+    set(SHERPA_C_API_LIB_DIR "${SHERPA_ONNX_JNI_ABI}")
+    message(STATUS "sherpa-onnx C-API (link only, third_party jni/<abi>): ${SHERPA_C_API_LIB_DIR}")
 elseif(EXISTS "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}/libsherpa-onnx-c-api.so")
     set(SHERPA_C_API_LIB_DIR "${PROJECT_ROOT}/src/main/jniLibs/${ANDROID_ABI}")
     message(STATUS "sherpa-onnx C-API (link only, jniLibs): ${SHERPA_C_API_LIB_DIR}")
 else()
-    message(WARNING "sherpa-onnx C-API not found. Zipvoice TTS will not be available. "
+    message(WARNING "sherpa-onnx C-API not found. Prebuilt sherpa native libs may be incomplete. "
                     "Build prebuilts: cd third_party/sherpa-onnx-prebuilt && ./build_sherpa_onnx.sh")
 endif()
 
@@ -148,7 +167,6 @@ target_include_directories(sherpaonnx PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/jni/archive
     ${CMAKE_CURRENT_SOURCE_DIR}/jni/model_detect
     ${CMAKE_CURRENT_SOURCE_DIR}/jni/audio
-    ${CMAKE_CURRENT_SOURCE_DIR}/jni/tts
     ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
 if(USE_FFMPEG)
@@ -167,7 +185,7 @@ if(USE_LIBARCHIVE)
     target_compile_definitions(sherpaonnx PRIVATE HAVE_LIBARCHIVE=1)
 endif()
 
-# Link libraries (Kotlin API from AAR handles STT/TTS; C-API only for Zipvoice)
+# Link libraries (Kotlin API from AAR handles STT/TTS incl. Zipvoice)
 if(USE_FFMPEG)
     target_link_directories(sherpaonnx PRIVATE ${FFMPEG_LIB_DIR})
 endif()

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

@@ -75,6 +75,38 @@ static void DrainRemainingAndClose(ArchiveReadContext* ctx) {
   fclose(ctx->file);
   ctx->file = nullptr;
 }
+
+struct StreamReadContext {
+  std::array<unsigned char, 64 * 1024> buffer{};
+  Sha256Context sha_ctx{};
+  long long bytes_read = 0;
+  ArchiveHelper::StreamReadCallback read_cb = nullptr;
+  void* user_data = nullptr;
+};
+
+static la_ssize_t ArchiveStreamReadCallback(struct archive* archive, void* client_data, const void** buff) {
+  auto* ctx = static_cast<StreamReadContext*>(client_data);
+  if (!ctx || !ctx->read_cb) {
+    archive_set_error(archive, EINVAL, "Invalid stream read context");
+    return -1;
+  }
+  std::ptrdiff_t n = ctx->read_cb(ctx->buffer.data(), ctx->buffer.size(), ctx->user_data);
+  if (n > 0) {
+    sha256_update(&ctx->sha_ctx, ctx->buffer.data(), static_cast<size_t>(n));
+    ctx->bytes_read += static_cast<long long>(n);
+    *buff = ctx->buffer.data();
+    return static_cast<la_ssize_t>(n);
+  }
+  if (n == 0) return 0;
+  archive_set_error(archive, EINVAL, "Stream read error");
+  return -1;
+}
+
+// No-op close callback for stream mode: the stream lifetime is managed by the
+// caller (e.g. a JNI InputStream), so libarchive must not close it.
+static int ArchiveStreamCloseCallback(struct archive* /* archive */, void* /* client_data */) {
+  return ARCHIVE_OK;
+}
 #endif  // HAVE_LIBARCHIVE
 
 static std::string ToHex(const unsigned char* data, size_t size) {
@@ -122,13 +154,15 @@ bool ArchiveHelper::ExtractTarBz2(
     return false;
   }
 
-  // Check target directory
+  // If target exists and is a directory, extract into it (merge). Otherwise require empty or force-remove.
   if (std::filesystem::exists(target_path)) {
-    if (force) {
+    if (std::filesystem::is_directory(target_path)) {
+      // Merge: extract into existing directory (e.g. multiple archives --> same base path)
+    } else if (force) {
       std::error_code ec;
       std::filesystem::remove_all(target_path, ec);
       if (ec) {
-        if (out_error) *out_error = "Failed to remove target directory: " + ec.message();
+        if (out_error) *out_error = "Failed to remove target path: " + ec.message();
         return false;
       }
     } else {
@@ -137,7 +171,6 @@ bool ArchiveHelper::ExtractTarBz2(
     }
   }
 
-  // Create target directory
   std::error_code ec;
   std::filesystem::create_directories(target_path, ec);
   if (ec) {
@@ -167,11 +200,12 @@ bool ArchiveHelper::ExtractTarBz2(
     return false;
   }
 
-  // Configure archive to support tar and bzip2
+  // Configure archive to support tar and common compression (bzip2, gzip, xz, zstd)
   archive_read_support_format_tar(archive);
   archive_read_support_filter_bzip2(archive);
   archive_read_support_filter_gzip(archive);  // Also support gzip for compatibility
-  archive_read_support_filter_xz(archive);    // And xz
+  archive_read_support_filter_xz(archive);   // And xz
+  archive_read_support_filter_zstd(archive); // And zstd (.tar.zst)
 
   ArchiveReadContext read_ctx;
   read_ctx.file = fopen(source_path.c_str(), "rb");
@@ -354,6 +388,18 @@ bool ArchiveHelper::ExtractTarBz2(
       close_reader();
       return false;
     }
+
+    result = archive_write_finish_entry(disk);
+    if (result != ARCHIVE_OK && result != ARCHIVE_WARN) {
+      const char* err = archive_error_string(disk);
+      if (out_error) {
+        *out_error = err ? std::string("Failed to finish entry: ") + err : "Failed to finish entry";
+      }
+      archive_read_free(archive);
+      archive_write_free(disk);
+      close_reader();
+      return false;
+    }
   }
 
   archive_read_free(archive);
@@ -376,6 +422,260 @@ bool ArchiveHelper::ExtractTarBz2(
 #endif  // HAVE_LIBARCHIVE
 }
 
+bool ArchiveHelper::ExtractTarZst(
+    const std::string& source_path,
+    const std::string& target_path,
+    bool force,
+    std::function<void(long long, long long, double)> on_progress,
+    std::string* out_error,
+    std::string* out_sha256) {
+  return ExtractTarBz2(source_path, target_path, force, on_progress, out_error, out_sha256);
+}
+
+bool ArchiveHelper::ExtractFromStream(
+    StreamReadCallback read_cb,
+    void* read_user_data,
+    const std::string& target_path,
+    bool force,
+    std::function<void(long long, long long, double)> on_progress,
+    std::string* out_error,
+    std::string* out_sha256) {
+  cancel_requested_.store(false);
+
+#ifndef HAVE_LIBARCHIVE
+  (void)read_cb;
+  (void)read_user_data;
+  (void)target_path;
+  (void)force;
+  (void)on_progress;
+  (void)out_sha256;
+  if (out_error) *out_error = "libarchive not available. Build with libarchive or set sherpaOnnxDisableLibarchive=false in gradle.properties. See docs/disable-libarchive.md.";
+  return false;
+#else
+  if (!read_cb) {
+    if (out_error) *out_error = "Stream read callback is null";
+    return false;
+  }
+
+  if (std::filesystem::exists(target_path)) {
+    if (std::filesystem::is_directory(target_path)) {
+      // Merge: extract into existing directory (e.g. multiple archives --> same base path)
+    } else if (force) {
+      std::error_code ec;
+      std::filesystem::remove_all(target_path, ec);
+      if (ec) {
+        if (out_error) *out_error = "Failed to remove target path: " + ec.message();
+        return false;
+      }
+    } else {
+      if (out_error) *out_error = "Target path already exists";
+      return false;
+    }
+  }
+
+  std::error_code ec;
+  std::filesystem::create_directories(target_path, ec);
+  if (ec) {
+    if (out_error) *out_error = "Failed to create target directory: " + ec.message();
+    return false;
+  }
+
+#ifndef NDEBUG
+  __android_log_print(ANDROID_LOG_INFO, "SherpaOnnx",
+                      "ExtractFromStream target_path=%s", target_path.c_str());
+#endif
+
+  std::string canonical_target = std::filesystem::canonical(target_path).string();
+  if (canonical_target.back() != '/') canonical_target += '/';
+
+  const long long total_bytes = 0;
+
+  struct archive* archive = archive_read_new();
+  if (!archive) {
+    if (out_error) *out_error = "Failed to create archive reader";
+    return false;
+  }
+
+  archive_read_support_format_tar(archive);
+  archive_read_support_filter_bzip2(archive);
+  archive_read_support_filter_gzip(archive);
+  archive_read_support_filter_xz(archive);
+  archive_read_support_filter_zstd(archive);
+
+  StreamReadContext stream_ctx;
+  stream_ctx.read_cb = read_cb;
+  stream_ctx.user_data = read_user_data;
+  sha256_init(&stream_ctx.sha_ctx);
+
+  if (archive_read_open(archive, &stream_ctx, nullptr, ArchiveStreamReadCallback, ArchiveStreamCloseCallback) != ARCHIVE_OK) {
+    const char* err = archive_error_string(archive);
+    if (out_error) *out_error = err ? std::string("Failed to open archive: ") + err : "Failed to open archive";
+    archive_read_free(archive);
+    return false;
+  }
+
+  struct archive* disk = archive_write_disk_new();
+  if (!disk) {
+    if (out_error) *out_error = "Failed to create disk writer";
+    archive_read_free(archive);
+    return false;
+  }
+
+  archive_write_disk_set_options(disk,
+                                  ARCHIVE_EXTRACT_TIME |
+                                  ARCHIVE_EXTRACT_PERM |
+                                  ARCHIVE_EXTRACT_ACL |
+                                  ARCHIVE_EXTRACT_FFLAGS);
+  archive_write_disk_set_standard_lookup(disk);
+
+  struct archive_entry* entry = nullptr;
+  int result = ARCHIVE_OK;
+  long long extracted_bytes = 0;
+  int last_percent = -1;
+  long long last_emit_bytes = 0;
+  int entry_index = 0;
+
+  while ((result = archive_read_next_header(archive, &entry)) == ARCHIVE_OK) {
+    if (cancel_requested_.load()) {
+      if (out_error) *out_error = "Extraction cancelled";
+      archive_read_free(archive);
+      archive_write_free(disk);
+      return false;
+    }
+
+    const char* current_path = archive_entry_pathname(entry);
+    if (!current_path) {
+      archive_read_free(archive);
+      archive_write_free(disk);
+      if (out_error) *out_error = "Invalid entry path";
+      return false;
+    }
+
+    std::string entry_path(current_path);
+    std::string full_path = target_path;
+    if (full_path.back() != '/') full_path += '/';
+    full_path += entry_path;
+
+    std::string canonical_entry;
+    try {
+      std::filesystem::path p(full_path);
+      std::filesystem::path parent = p.parent_path();
+      if (std::filesystem::exists(parent)) {
+        canonical_entry = std::filesystem::canonical(parent).string();
+      } else {
+        while (!std::filesystem::exists(parent) && parent != parent.parent_path()) {
+          parent = parent.parent_path();
+        }
+        if (std::filesystem::exists(parent)) {
+          canonical_entry = std::filesystem::canonical(parent).string();
+        } else {
+          canonical_entry = canonical_target;
+        }
+      }
+      canonical_entry += '/';
+      canonical_entry += p.filename().string();
+    } catch (const std::exception&) {
+      canonical_entry = full_path;
+    }
+
+    if (canonical_entry.find(canonical_target) != 0) {
+      archive_read_free(archive);
+      archive_write_free(disk);
+      if (out_error) *out_error = "Blocked path traversal: " + entry_path;
+      return false;
+    }
+
+    archive_entry_set_pathname(entry, full_path.c_str());
+
+    result = archive_write_header(disk, entry);
+    if (result != ARCHIVE_OK) {
+      const char* err = archive_error_string(disk);
+      if (out_error) *out_error = err ? std::string("Failed to write entry: ") + err : "Failed to write entry";
+      archive_read_free(archive);
+      archive_write_free(disk);
+      return false;
+    }
+
+    const void* buff = nullptr;
+    size_t size = 0;
+    la_int64_t offset = 0;
+
+    while ((result = archive_read_data_block(archive, &buff, &size, &offset)) == ARCHIVE_OK) {
+      if (cancel_requested_.load()) {
+        if (out_error) *out_error = "Extraction cancelled";
+        archive_read_free(archive);
+        archive_write_free(disk);
+        return false;
+      }
+
+      result = archive_write_data_block(disk, buff, size, offset);
+      if (result != ARCHIVE_OK) {
+        const char* err = archive_error_string(disk);
+        if (out_error) *out_error = err ? std::string("Failed to write data: ") + err : "Failed to write data";
+        archive_read_free(archive);
+        archive_write_free(disk);
+        return false;
+      }
+
+      extracted_bytes += static_cast<long long>(size);
+
+      if (on_progress) {
+        if (total_bytes > 0) {
+          long long compressed_bytes = archive_filter_bytes(archive, -1);
+          int percent = static_cast<int>(total_bytes > 0 ? (compressed_bytes * 100) / total_bytes : 0);
+          percent = (percent > 100) ? 100 : ((percent < 0) ? 0 : percent);
+          if (percent != last_percent) {
+            last_percent = percent;
+            on_progress(compressed_bytes, total_bytes, static_cast<double>(percent));
+          }
+        } else if (stream_ctx.bytes_read - last_emit_bytes >= 1024 * 1024) {
+          last_emit_bytes = stream_ctx.bytes_read;
+          on_progress(stream_ctx.bytes_read, 0, 0.0);
+        }
+      }
+    }
+
+    if (result != ARCHIVE_EOF && result != ARCHIVE_OK) {
+      const char* err = archive_error_string(archive);
+      if (out_error) *out_error = err ? std::string("Failed to read data: ") + err : "Failed to read data";
+      archive_read_free(archive);
+      archive_write_free(disk);
+      return false;
+    }
+
+    result = archive_write_finish_entry(disk);
+    if (result != ARCHIVE_OK && result != ARCHIVE_WARN) {
+      const char* err = archive_error_string(disk);
+      if (out_error) *out_error = err ? std::string("Failed to finish entry: ") + err : "Failed to finish entry";
+      archive_read_free(archive);
+      archive_write_free(disk);
+      return false;
+    }
+    entry_index++;
+  }
+
+#ifndef NDEBUG
+  __android_log_print(ANDROID_LOG_INFO, "SherpaOnnx",
+                      "ExtractFromStream done entries=%d", entry_index);
+#endif
+
+  archive_read_free(archive);
+  archive_write_free(disk);
+
+  if (out_sha256) {
+    unsigned char digest[32];
+    sha256_final(&stream_ctx.sha_ctx, digest);
+    *out_sha256 = ToHex(digest, sizeof(digest));
+  }
+
+  if (on_progress) {
+    on_progress(stream_ctx.bytes_read, stream_ctx.bytes_read, 100.0);
+  }
+
+  return true;
+#endif
+}
+
 bool ArchiveHelper::ComputeFileSha256(
     const std::string& file_path,
     std::string* out_error,

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cstddef>
 #include <string>
 #include <functional>
 #include <atomic>
@@ -10,14 +11,17 @@
  */
 class ArchiveHelper {
  public:
+  /** Callback to read bytes from a stream (e.g. Java InputStream via JNI). Returns bytes read, 0 on EOF, -1 on error. */
+  using StreamReadCallback = std::ptrdiff_t (*)(void* buf, size_t len, void* user_data);
+
   /**
-   * Extract tar.bz2 file to target directory
+   * Extract tar.bz2 (or .tar.zst, .tar.gz, .tar.xz) file to target directory.
    *
-   * @param sourcePath Path to the .tar.bz2 file
+   * @param sourcePath Path to the archive file
    * @param targetPath Destination directory path
    * @param force Whether to overwrite existing target directory
    * @param onProgress Callback for progress updates (bytesExtracted, totalBytes, percent)
-    * @param outSha256 Optional output SHA-256 hex of the archive file
+   * @param outSha256 Optional output SHA-256 hex of the archive file
    * @return true if extraction succeeded, false otherwise
    */
   static bool ExtractTarBz2(
@@ -28,7 +32,32 @@ class ArchiveHelper {
       std::string* out_error = nullptr,
       std::string* out_sha256 = nullptr);
 
-    /**
+  /**
+   * Extract .tar.zst (or other supported tar compression) file to target directory.
+   * Uses the same implementation as ExtractTarBz2 (libarchive supports zstd when built with ENABLE_ZSTD).
+   */
+  static bool ExtractTarZst(
+      const std::string& source_path,
+      const std::string& target_path,
+      bool force,
+      std::function<void(long long, long long, double)> on_progress = nullptr,
+      std::string* out_error = nullptr,
+      std::string* out_sha256 = nullptr);
+
+  /**
+   * Extract a tar archive (tar.zst or tar.bz2) from a stream via read_cb.
+   * Used for Android AssetManager streams; total_bytes can be 0 (progress then uses compressed bytes or periodic emit).
+   */
+  static bool ExtractFromStream(
+      StreamReadCallback read_cb,
+      void* read_user_data,
+      const std::string& target_path,
+      bool force,
+      std::function<void(long long, long long, double)> on_progress = nullptr,
+      std::string* out_error = nullptr,
+      std::string* out_sha256 = nullptr);
+
+  /**
      * Compute SHA-256 of a file.
      *
      * @param file_path Path to the file