react-native-executorch 0.5.2 → 0.5.4

package/common/rnexecutorch/models/style_transfer/StyleTransfer.cpp

@@ -5,7 +5,7 @@
 #include <executorch/extension/tensor/tensor.h>
 #include <opencv2/opencv.hpp>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::style_transfer {
 using namespace facebook;
 using executorch::extension::TensorPtr;
 using executorch::runtime::Error;
@@ -32,15 +32,15 @@ StyleTransfer::StyleTransfer(const std::string &modelSource,
 
 std::string StyleTransfer::postprocess(const Tensor &tensor,
                                        cv::Size originalSize) {
-  cv::Mat mat = imageprocessing::getMatrixFromTensor(modelImageSize, tensor);
+  cv::Mat mat = image_processing::getMatrixFromTensor(modelImageSize, tensor);
   cv::resize(mat, mat, originalSize);
 
-  return imageprocessing::saveToTempFile(mat);
+  return image_processing::saveToTempFile(mat);
 }
 
 std::string StyleTransfer::generate(std::string imageSource) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -52,4 +52,4 @@ std::string StyleTransfer::generate(std::string imageSource) {
   return postprocess(forwardResult->at(0).toTensor(), originalSize);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::style_transfer

package/common/rnexecutorch/models/style_transfer/StyleTransfer.h

@@ -8,9 +8,11 @@
 #include <jsi/jsi.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/BaseModel.h>
 
 namespace rnexecutorch {
+namespace models::style_transfer {
 using namespace facebook;
 using executorch::aten::Tensor;
 using executorch::extension::TensorPtr;
@@ -26,4 +28,8 @@ private:
 
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::style_transfer
+
+REGISTER_CONSTRUCTOR(models::style_transfer::StyleTransfer, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/vertical_ocr/VerticalDetector.cpp

@@ -2,11 +2,11 @@
 
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 #include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/DetectorUtils.h>
+#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
 
 #include <executorch/extension/tensor/tensor_ptr.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 VerticalDetector::VerticalDetector(
     const std::string &modelSource, bool detectSingleCharacters,
     std::shared_ptr<react::CallInvoker> callInvoker)
@@ -31,13 +31,14 @@ cv::Size VerticalDetector::getModelImageSize() const noexcept {
   return modelImageSize;
 }
 
-std::vector<ocr::DetectorBBox>
+std::vector<types::DetectorBBox>
 VerticalDetector::generate(const cv::Mat &inputImage) {
   auto inputShapes = getAllInputShapes();
   cv::Mat resizedInputImage =
-      imageprocessing::resizePadded(inputImage, getModelImageSize());
-  TensorPtr inputTensor = imageprocessing::getTensorFromMatrix(
-      inputShapes[0], resizedInputImage, ocr::MEAN, ocr::VARIANCE);
+      image_processing::resizePadded(inputImage, getModelImageSize());
+  TensorPtr inputTensor = image_processing::getTensorFromMatrix(
+      inputShapes[0], resizedInputImage, constants::kNormalizationMean,
+      constants::kNormalizationVariance);
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
     throw std::runtime_error(
@@ -47,7 +48,7 @@ VerticalDetector::generate(const cv::Mat &inputImage) {
   return postprocess(forwardResult->at(0).toTensor());
 }
 
-std::vector<ocr::DetectorBBox>
+std::vector<types::DetectorBBox>
 VerticalDetector::postprocess(const Tensor &tensor) const {
   /*
    The output of the model consists of two matrices (heat maps):
@@ -64,29 +65,29 @@ VerticalDetector::postprocess(const Tensor &tensor) const {
    The output of the model is a matrix half the size of the input image
    containing two channels representing the heatmaps.
    */
-  auto [scoreTextMat, scoreAffinityMat] = ocr::interleavedArrayToMats(
+  auto [scoreTextMat, scoreAffinityMat] = utils::interleavedArrayToMats(
       tensorData,
       cv::Size(modelImageSize.width / 2, modelImageSize.height / 2));
   float txtThreshold = this->detectSingleCharacters
-                           ? ocr::TEXT_THRESHOLD
-                           : ocr::TEXT_THRESHOLD_VERTICAL;
-  std::vector<ocr::DetectorBBox> bBoxesList =
-      ocr::getDetBoxesFromTextMapVertical(scoreTextMat, scoreAffinityMat,
-                                          txtThreshold, ocr::LINK_THRESHOLD,
-                                          this->detectSingleCharacters);
-  const float restoreRatio =
-      ocr::calculateRestoreRatio(scoreTextMat.rows, ocr::RECOGNIZER_IMAGE_SIZE);
-  ocr::restoreBboxRatio(bBoxesList, restoreRatio);
+                           ? constants::kTextThreshold
+                           : constants::kTextThresholdVertical;
+  std::vector<types::DetectorBBox> bBoxesList =
+      utils::getDetBoxesFromTextMapVertical(
+          scoreTextMat, scoreAffinityMat, txtThreshold,
+          constants::kLinkThreshold, this->detectSingleCharacters);
+  const float restoreRatio = utils::calculateRestoreRatio(
+      scoreTextMat.rows, constants::kRecognizerImageSize);
+  utils::restoreBboxRatio(bBoxesList, restoreRatio);
 
   // if this is Narrow Detector, do not group boxes.
   if (!this->detectSingleCharacters) {
-    bBoxesList = ocr::groupTextBoxes(
-        bBoxesList, ocr::CENTER_THRESHOLD, ocr::DISTANCE_THRESHOLD,
-        ocr::HEIGHT_THRESHOLD, ocr::MIN_SIDE_THRESHOLD, ocr::MAX_SIDE_THRESHOLD,
-        ocr::MAX_WIDTH);
+    bBoxesList = utils::groupTextBoxes(
+        bBoxesList, constants::kCenterThreshold, constants::kDistanceThreshold,
+        constants::kHeightThreshold, constants::kMinSideThreshold,
+        constants::kMaxSideThreshold, constants::kMaxWidth);
   }
 
   return bBoxesList;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

package/common/rnexecutorch/models/vertical_ocr/VerticalDetector.h

@@ -6,7 +6,7 @@
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/ocr/Types.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 
 /*
  Vertical Detector is an sligtly modified Detector tuned for detecting Vertical
@@ -38,12 +38,12 @@ public:
   explicit VerticalDetector(const std::string &modelSource,
                             bool detectSingleCharacters,
                             std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<ocr::DetectorBBox> generate(const cv::Mat &inputImage);
+  std::vector<types::DetectorBBox> generate(const cv::Mat &inputImage);
   cv::Size getModelImageSize() const noexcept;
 
 private:
   bool detectSingleCharacters;
-  std::vector<ocr::DetectorBBox> postprocess(const Tensor &tensor) const;
+  std::vector<types::DetectorBBox> postprocess(const Tensor &tensor) const;
   cv::Size modelImageSize;
 };
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

package/common/rnexecutorch/models/vertical_ocr/VerticalOCR.cpp

@@ -5,7 +5,7 @@
 #include <rnexecutorch/models/ocr/Types.h>
 #include <tuple>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 VerticalOCR::VerticalOCR(const std::string &detectorLargeSource,
                          const std::string &detectorNarrowSource,
                          const std::string &recognizerSource,
@@ -16,21 +16,21 @@ VerticalOCR::VerticalOCR(const std::string &detectorLargeSource,
       recognizer(recognizerSource, invoker), converter(symbols),
       independentCharacters(independentChars), callInvoker(invoker) {}
 
-std::vector<OCRDetection> VerticalOCR::generate(std::string input) {
-  cv::Mat image = imageprocessing::readImage(input);
+std::vector<types::OCRDetection> VerticalOCR::generate(std::string input) {
+  cv::Mat image = image_processing::readImage(input);
   if (image.empty()) {
     throw std::runtime_error("Failed to load image from path: " + input);
   }
   // 1. Large Detector
-  std::vector<ocr::DetectorBBox> largeBoxes = detectorLarge.generate(image);
+  std::vector<types::DetectorBBox> largeBoxes = detectorLarge.generate(image);
 
   cv::Size largeDetectorSize = detectorLarge.getModelImageSize();
   cv::Mat resizedImage =
-      imageprocessing::resizePadded(image, largeDetectorSize);
-  ocr::PaddingInfo imagePaddings =
-      ocr::calculateResizeRatioAndPaddings(image.size(), largeDetectorSize);
+      image_processing::resizePadded(image, largeDetectorSize);
+  types::PaddingInfo imagePaddings =
+      utils::calculateResizeRatioAndPaddings(image.size(), largeDetectorSize);
 
-  std::vector<OCRDetection> predictions;
+  std::vector<types::OCRDetection> predictions;
   predictions.reserve(largeBoxes.size());
 
   for (auto &box : largeBoxes) {
@@ -49,10 +49,10 @@ std::size_t VerticalOCR::getMemoryLowerBound() const noexcept {
 
 // Strategy 1: Recognize each character individually
 std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
-    const ocr::DetectorBBox &box, const cv::Mat &originalImage,
-    const std::vector<ocr::DetectorBBox> &characterBoxes,
-    const ocr::PaddingInfo &paddingsBox,
-    const ocr::PaddingInfo &imagePaddings) {
+    const types::DetectorBBox &box, const cv::Mat &originalImage,
+    const std::vector<types::DetectorBBox> &characterBoxes,
+    const types::PaddingInfo &paddingsBox,
+    const types::PaddingInfo &imagePaddings) {
   std::string text;
   float confidenceScore = 0.0f;
   float totalScore = 0.0f;
@@ -65,16 +65,16 @@ std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
      3. Resize it to [VerticalSmallRecognizerWidth x RecognizerHeight] (64 x
      64),
     */
-    auto croppedChar = ocr::prepareForRecognition(
+    auto croppedChar = utils::prepareForRecognition(
         originalImage, characterBox.bbox, box.bbox, paddingsBox, imagePaddings);
 
     /*
      To make Recognition simpler, we convert cropped character image
      to a bit mask with white character and black background.
     */
-    croppedChar = ocr::characterBitMask(croppedChar);
-    croppedChar = ocr::normalizeForRecognizer(
-        croppedChar, ocr::RECOGNIZER_HEIGHT, 0.0, true);
+    croppedChar = utils::characterBitMask(croppedChar);
+    croppedChar = utils::normalizeForRecognizer(
+        croppedChar, constants::kRecognizerHeight, 0.0, true);
 
     const auto &[predIndex, score] = recognizer.generate(croppedChar);
     if (!predIndex.empty()) {
@@ -88,10 +88,10 @@ std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
 
 // Strategy 2: Concatenate characters and recognize as a single line
 std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
-    const ocr::DetectorBBox &box, const cv::Mat &originalImage,
-    const std::vector<ocr::DetectorBBox> &characterBoxes,
-    const ocr::PaddingInfo &paddingsBox,
-    const ocr::PaddingInfo &imagePaddings) {
+    const types::DetectorBBox &box, const cv::Mat &originalImage,
+    const std::vector<types::DetectorBBox> &characterBoxes,
+    const types::PaddingInfo &paddingsBox,
+    const types::PaddingInfo &imagePaddings) {
   std::string text;
   std::vector<cv::Mat> croppedCharacters;
   croppedCharacters.reserve(characterBoxes.size());
@@ -100,22 +100,22 @@ std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
      Prepare for Recognition by following steps:
      1. Crop image to the character bounding box,
      2. Convert Image to gray.
-     3. Resize it to [SMALL_VERTICAL_RECOGNIZER_WIDTH x RECOGNIZER_HEIGHT] (64 x
+     3. Resize it to [kSmallVerticalRecognizerWidth x kRecognizerHeight] (64 x
      64). The same height is required for horizontal concatenation of single
      characters into one image.
     */
-    auto croppedChar = ocr::prepareForRecognition(
+    auto croppedChar = utils::prepareForRecognition(
         originalImage, characterBox.bbox, box.bbox, paddingsBox, imagePaddings);
     croppedCharacters.push_back(croppedChar);
   }
 
   cv::Mat mergedCharacters;
   cv::hconcat(croppedCharacters, mergedCharacters);
-  mergedCharacters = imageprocessing::resizePadded(
+  mergedCharacters = image_processing::resizePadded(
       mergedCharacters,
-      cv::Size(ocr::LARGE_RECOGNIZER_WIDTH, ocr::RECOGNIZER_HEIGHT));
-  mergedCharacters = ocr::normalizeForRecognizer(
-      mergedCharacters, ocr::RECOGNIZER_HEIGHT, 0.0, false);
+      cv::Size(constants::kLargeRecognizerWidth, constants::kRecognizerHeight));
+  mergedCharacters = utils::normalizeForRecognizer(
+      mergedCharacters, constants::kRecognizerHeight, 0.0, false);
 
   const auto &[predIndex, confidenceScore] =
       recognizer.generate(mergedCharacters);
@@ -125,10 +125,10 @@ std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
   return {text, confidenceScore};
 }
 
-OCRDetection VerticalOCR::_processSingleTextBox(
-    ocr::DetectorBBox &box, const cv::Mat &originalImage,
-    const cv::Mat &resizedLargeImage, const ocr::PaddingInfo &imagePaddings) {
-  cv::Rect boundingBox = ocr::extractBoundingBox(box.bbox);
+types::OCRDetection VerticalOCR::_processSingleTextBox(
+    types::DetectorBBox &box, const cv::Mat &originalImage,
+    const cv::Mat &resizedLargeImage, const types::PaddingInfo &imagePaddings) {
+  cv::Rect boundingBox = utils::extractBoundingBox(box.bbox);
 
   // Crop the image for detection of single characters.
   cv::Rect safeRect =
@@ -137,7 +137,7 @@ OCRDetection VerticalOCR::_processSingleTextBox(
   cv::Mat croppedLargeBox = resizedLargeImage(safeRect);
 
   // 2. Narrow Detector - detects single characters
-  std::vector<ocr::DetectorBBox> characterBoxes =
+  std::vector<types::DetectorBBox> characterBoxes =
       detectorNarrow.generate(croppedLargeBox);
 
   std::string text;
@@ -149,7 +149,7 @@ OCRDetection VerticalOCR::_processSingleTextBox(
     const int32_t boxHeight =
         static_cast<int32_t>(box.bbox[2].y - box.bbox[0].y);
     cv::Size narrowRecognizerSize = detectorNarrow.getModelImageSize();
-    ocr::PaddingInfo paddingsBox = ocr::calculateResizeRatioAndPaddings(
+    types::PaddingInfo paddingsBox = utils::calculateResizeRatioAndPaddings(
         cv::Size(boxWidth, boxHeight), narrowRecognizerSize);
 
     // 3. Recognition - decide between Strategy 1 and Strategy 2.
@@ -161,7 +161,7 @@ OCRDetection VerticalOCR::_processSingleTextBox(
                                      paddingsBox, imagePaddings);
   }
   // Modify the returned boxes to match the original image size
-  std::array<ocr::Point, 4> finalBbox;
+  std::array<types::Point, 4> finalBbox;
   for (size_t i = 0; i < box.bbox.size(); ++i) {
     finalBbox[i].x =
         (box.bbox[i].x - imagePaddings.left) * imagePaddings.resizeRatio;
@@ -177,4 +177,4 @@ void VerticalOCR::unload() noexcept {
   detectorNarrow.unload();
   recognizer.unload();
 }
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

package/common/rnexecutorch/models/vertical_ocr/VerticalOCR.h

@@ -2,18 +2,21 @@
 
 #include <executorch/extension/tensor/tensor_ptr.h>
 #include <opencv2/opencv.hpp>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/ocr/CTCLabelConverter.h>
-#include <rnexecutorch/models/ocr/DetectorUtils.h>
-#include <rnexecutorch/models/ocr/RecognitionHandlerUtils.h>
 #include <rnexecutorch/models/ocr/Recognizer.h>
-#include <rnexecutorch/models/ocr/RecognizerUtils.h>
+#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
+#include <rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h>
+#include <rnexecutorch/models/ocr/utils/RecognizerUtils.h>
 #include <rnexecutorch/models/vertical_ocr/VerticalDetector.h>
-#include <string>
-#include <utility>
-#include <vector>
 
 namespace rnexecutorch {
+namespace models::ocr {
 
 /*
   Vertical OCR is OCR designed to handle vertical texts.
@@ -47,32 +50,36 @@ public:
                        const std::string &recognizerSource, std::string symbols,
                        bool indpendentCharacters,
                        std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<OCRDetection> generate(std::string input);
+  std::vector<types::OCRDetection> generate(std::string input);
   std::size_t getMemoryLowerBound() const noexcept;
   void unload() noexcept;
 
 private:
   std::pair<std::string, float> _handleIndependentCharacters(
-      const ocr::DetectorBBox &box, const cv::Mat &originalImage,
-      const std::vector<ocr::DetectorBBox> &characterBoxes,
-      const ocr::PaddingInfo &paddingsBox,
-      const ocr::PaddingInfo &imagePaddings);
+      const types::DetectorBBox &box, const cv::Mat &originalImage,
+      const std::vector<types::DetectorBBox> &characterBoxes,
+      const types::PaddingInfo &paddingsBox,
+      const types::PaddingInfo &imagePaddings);
   std::pair<std::string, float>
-  _handleJointCharacters(const ocr::DetectorBBox &box,
+  _handleJointCharacters(const types::DetectorBBox &box,
                          const cv::Mat &originalImage,
-                         const std::vector<ocr::DetectorBBox> &characterBoxes,
-                         const ocr::PaddingInfo &paddingsBox,
-                         const ocr::PaddingInfo &imagePaddings);
-  OCRDetection _processSingleTextBox(ocr::DetectorBBox &box,
-                                     const cv::Mat &originalImage,
-                                     const cv::Mat &resizedLargeImage,
-                                     const ocr::PaddingInfo &imagePaddings);
+                         const std::vector<types::DetectorBBox> &characterBoxes,
+                         const types::PaddingInfo &paddingsBox,
+                         const types::PaddingInfo &imagePaddings);
+  types::OCRDetection
+  _processSingleTextBox(types::DetectorBBox &box, const cv::Mat &originalImage,
+                        const cv::Mat &resizedLargeImage,
+                        const types::PaddingInfo &imagePaddings);
   VerticalDetector detectorLarge;
   VerticalDetector detectorNarrow;
   Recognizer recognizer;
-  ocr::CTCLabelConverter converter;
+  CTCLabelConverter converter;
   bool independentCharacters;
   std::shared_ptr<react::CallInvoker> callInvoker;
 };
+} // namespace models::ocr
 
+REGISTER_CONSTRUCTOR(models::ocr::VerticalOCR, std::string, std::string,
+                     std::string, std::string, bool,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/{third-party/ios/ExecutorchLib/ExecutorchLib/sampler → common/runner}/sampler.cpp

@@ -184,9 +184,10 @@ template <typename T> int32_t Sampler::sample(T *logits) {
 }
 
 template int32_t Sampler::sample<float>(float *logits);
-template int32_t Sampler::sample<exec_aten::Half>(exec_aten::Half *logits);
 template int32_t
-Sampler::sample<exec_aten::BFloat16>(exec_aten::BFloat16 *logits);
+Sampler::sample<executorch::aten::Half>(executorch::aten::Half *logits);
+template int32_t
+Sampler::sample<executorch::aten::BFloat16>(executorch::aten::BFloat16 *logits);
 
 } // namespace llm
 } // namespace extension

package/{third-party/ios/ExecutorchLib/ExecutorchLib/sampler → common/runner}/sampler.h

@@ -19,18 +19,19 @@
 #endif
 
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/platform/compiler.h>
 
 namespace executorch {
 namespace extension {
 namespace llm {
 // A simple llama2 sampler.
 
-template <typename T> struct ProbIndex {
+template <typename T> struct ET_EXPERIMENTAL ProbIndex {
   T prob;
   int32_t index;
 }; // struct used when sorting probabilities during top-p sampling
 
-class Sampler {
+class ET_EXPERIMENTAL Sampler {
 public:
   Sampler(int32_t vocab_size, float temperature, float topp,
           unsigned long long rng_seed);

package/lib/Error.js

@@ -7,7 +7,7 @@ export var ETError;
     ETError[ETError["ModelGenerating"] = 104] = "ModelGenerating";
     ETError[ETError["LanguageNotSupported"] = 105] = "LanguageNotSupported";
     ETError[ETError["InvalidModelSource"] = 255] = "InvalidModelSource";
-    // SpeechToText errors
+    //SpeechToText errors
     ETError[ETError["MultilingualConfiguration"] = 160] = "MultilingualConfiguration";
     ETError[ETError["MissingDataChunk"] = 161] = "MissingDataChunk";
     ETError[ETError["StreamingNotStarted"] = 162] = "StreamingNotStarted";
@@ -38,13 +38,16 @@ export var ETError;
 })(ETError || (ETError = {}));
 export const getError = (e) => {
     if (typeof e === 'number') {
-        return ETError[e] ?? ETError[ETError.UndefinedError];
+        if (e in ETError)
+            return ETError[e];
+        return ETError[ETError.UndefinedError];
     }
     // try to extract number from message (can contain false positives)
     const error = e;
     const errorCode = parseInt(error.message, 10);
-    if (Number.isNaN(errorCode)) {
-        return error.message;
-    }
-    return ETError[errorCode] ?? ETError[ETError.UndefinedError];
+    const message = Number.isNaN(errorCode)
+        ? error.message
+        : ' ' + error.message.slice(`${errorCode}`.length).trimStart();
+    const ETErrorMessage = (errorCode in ETError ? ETError[errorCode] : ETError[ETError.UndefinedError]);
+    return ETErrorMessage + message;
 };

package/lib/ThreadPool.d.ts

@@ -0,0 +1,10 @@
+declare class NativeThreadPool {
+    constructor();
+    executeNative(functionName: any, args: any): Promise<any>;
+    runInference(prompt: any, options?: {}): Promise<any>;
+    processImage(imagePath: any, options?: {}): Promise<any>;
+    heavyComputation(data: any): Promise<any>;
+    getStats(): any;
+}
+declare const _default: NativeThreadPool;
+export default _default;

package/lib/ThreadPool.js

@@ -0,0 +1,28 @@
+// ThreadPool.js
+class NativeThreadPool {
+    constructor() {
+        if (!global.NativeThreadPool) {
+            throw new Error('NativeThreadPool not installed');
+        }
+        this.pool = global.NativeThreadPool;
+    }
+    // Execute any native function
+    async executeNative(functionName, args) {
+        return await this.pool.executeNative(functionName, JSON.stringify(args));
+    }
+    // Specific methods for common tasks
+    async runInference(prompt, options = {}) {
+        return await this.executeNative('runInference', { prompt, ...options });
+    }
+    async processImage(imagePath, options = {}) {
+        return await this.executeNative('processImage', { imagePath, ...options });
+    }
+    async heavyComputation(data) {
+        return await this.executeNative('heavyComputation', data);
+    }
+    // Get thread pool statistics
+    getStats() {
+        return this.pool.getStats();
+    }
+}
+export default new NativeThreadPool();

package/lib/constants/modelUrls.js

@@ -1,7 +1,7 @@
 import { Platform } from 'react-native';
 import { AvailableModels } from '../types/stt';
 const URL_PREFIX = 'https://huggingface.co/software-mansion/react-native-executorch';
-const VERSION_TAG = 'resolve/v0.4.0';
+const VERSION_TAG = 'resolve/v0.5.0';
 const NEXT_VERSION_TAG = 'resolve/v0.5.0';
 // LLMs
 // LLAMA 3.2