react-native-audio-api 0.10.0-nightly-034f768-20251020 → 0.10.0-nightly-2d11b56-20251021

package/android/build.gradle

@@ -165,6 +165,7 @@ android {
       "**/libfolly_runtime.so",
       "**/libglog.so",
       "**/libhermes.so",
+      "**/libhermesvm.so",
       "**/libhermes-executor-debug.so",
       "**/libhermes_executor.so",
       "**/libhermestooling.so",

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -77,14 +77,15 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
           runtime, args[0]);
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
+  auto shouldLockRuntime = shouldUseUiRuntime;
   if (shouldUseUiRuntime) {
     workletRuntime = context_->runtimeRegistry_.uiRuntime;
   } else {
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletSourceNode =
-      context_->createWorkletSourceNode(shareableWorklet, workletRuntime);
+  auto workletSourceNode = context_->createWorkletSourceNode(
+      shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletSourceNodeHostObject =
       std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
   return jsi::Object::createFromHostObject(
@@ -101,6 +102,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
+  auto shouldLockRuntime = shouldUseUiRuntime;
   if (shouldUseUiRuntime) {
     workletRuntime = context_->runtimeRegistry_.uiRuntime;
   } else {
@@ -110,7 +112,11 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
   auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
 
   auto workletNode = context_->createWorkletNode(
-      shareableWorklet, workletRuntime, bufferLength, inputChannelCount);
+      shareableWorklet,
+      workletRuntime,
+      bufferLength,
+      inputChannelCount,
+      shouldLockRuntime);
   auto workletNodeHostObject =
       std::make_shared<WorkletNodeHostObject>(workletNode);
   return jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
@@ -128,14 +134,15 @@ JSI_HOST_FUNCTION_IMPL(
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
+  auto shouldLockRuntime = shouldUseUiRuntime;
   if (shouldUseUiRuntime) {
     workletRuntime = context_->runtimeRegistry_.uiRuntime;
   } else {
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletProcessingNode =
-      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime);
+  auto workletProcessingNode = context_->createWorkletProcessingNode(
+      shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletProcessingNodeHostObject =
       std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
   return jsi::Object::createFromHostObject(

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -67,9 +67,11 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
 
 std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime) {
+  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletSourceNode =
-      std::make_shared<WorkletSourceNode>(this, shareableWorklet, runtime);
+      std::make_shared<WorkletSourceNode>(this, std::move(workletRunner));
   nodeManager_->addSourceNode(workletSourceNode);
   return workletSourceNode;
 }
@@ -78,9 +80,11 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
     std::weak_ptr<worklets::WorkletRuntime> runtime,
     size_t bufferLength,
-    size_t inputChannelCount) {
+    size_t inputChannelCount,
+    bool shouldLockRuntime) {
+  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletNode = std::make_shared<WorkletNode>(
-      this, shareableWorklet, runtime, bufferLength, inputChannelCount);
+      this, bufferLength, inputChannelCount, std::move(workletRunner));
   nodeManager_->addProcessingNode(workletNode);
   return workletNode;
 }
@@ -88,9 +92,11 @@ std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
 std::shared_ptr<WorkletProcessingNode>
 BaseAudioContext::createWorkletProcessingNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime) {
+  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
   auto workletProcessingNode =
-      std::make_shared<WorkletProcessingNode>(this, shareableWorklet, runtime);
+      std::make_shared<WorkletProcessingNode>(this, std::move(workletRunner));
   nodeManager_->addProcessingNode(workletProcessingNode);
   return workletProcessingNode;
 }

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -47,9 +47,20 @@ class BaseAudioContext {
   std::shared_ptr<AudioDestinationNode> getDestination();
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
-  std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime);
-  std::shared_ptr<WorkletNode> createWorkletNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime, size_t bufferLength, size_t inputChannelCount);
-  std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, std::weak_ptr<worklets::WorkletRuntime> runtime);
+  std::shared_ptr<WorkletSourceNode> createWorkletSourceNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime = true);
+  std::shared_ptr<WorkletNode> createWorkletNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    size_t bufferLength,
+    size_t inputChannelCount,
+    bool shouldLockRuntime = true);
+  std::shared_ptr<WorkletProcessingNode> createWorkletProcessingNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
+    bool shouldLockRuntime = true);
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();

package/common/cpp/audioapi/core/effects/WorkletNode.cpp

@@ -4,13 +4,11 @@ namespace audioapi {
 
 WorkletNode::WorkletNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
     size_t bufferLength,
-    size_t inputChannelCount)
+    size_t inputChannelCount,
+    WorkletsRunner &&runtime)
     : AudioNode(context),
-      workletRunner_(runtime),
-      shareableWorklet_(worklet),
+      workletRunner_(std::move(runtime)),
       bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
@@ -40,35 +38,36 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     curBuffIndex_ += shouldProcess;
 
     /// If we filled the entire buffer, we need to execute the worklet
-    if (curBuffIndex_ == bufferLength_) {
-      // Reset buffer index, channel buffers and execute worklet
-      curBuffIndex_ = 0;
-      workletRunner_.executeOnRuntimeGuardedSync(
-          [this, channelCount_](jsi::Runtime &uiRuntimeRaw) {
-            /// Arguments preparation
-            auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
-            for (size_t ch = 0; ch < channelCount_; ch++) {
-              auto audioArray = std::make_shared<AudioArray>(bufferLength_);
-              audioArray->copy(bus_->getChannel(ch));
-              auto sharedAudioArray =
-                  std::make_shared<AudioArrayBuffer>(audioArray);
-              auto sharedAudioArraySize = sharedAudioArray->size();
-              auto arrayBuffer =
-                  jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
-              arrayBuffer.setExternalMemoryPressure(
-                  uiRuntimeRaw, sharedAudioArraySize);
-              jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
-            }
+    if (curBuffIndex_ != bufferLength_) {
+      continue;
+    }
+    // Reset buffer index, channel buffers and execute worklet
+    curBuffIndex_ = 0;
+    workletRunner_.executeOnRuntimeSync([this, channelCount_](
+                                            jsi::Runtime &uiRuntimeRaw) {
+      /// Arguments preparation
+      auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
+      for (size_t ch = 0; ch < channelCount_; ch++) {
+        auto audioArray = std::make_shared<AudioArray>(bufferLength_);
+        audioArray->copy(bus_->getChannel(ch));
+        auto sharedAudioArray = std::make_shared<AudioArrayBuffer>(audioArray);
+        auto sharedAudioArraySize = sharedAudioArray->size();
+        auto arrayBuffer =
+            jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+        arrayBuffer.setExternalMemoryPressure(
+            uiRuntimeRaw, sharedAudioArraySize);
+        jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
+      }
 
-            bus_->zero();
+      bus_->zero();
 
-            workletRunner_.executeWorklet(
-                shareableWorklet_,
-                std::move(jsArray),
-                jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
-            return jsi::Value::undefined();
-          });
-    }
+      /// Call the worklet
+      workletRunner_.callUnsafe(
+          std::move(jsArray),
+          jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
+
+      return jsi::Value::undefined();
+    });
   }
 
   return processingBus;

package/common/cpp/audioapi/core/effects/WorkletNode.h

@@ -19,10 +19,9 @@ class WorkletNode : public AudioNode {
  public:
   explicit WorkletNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime,
       size_t bufferLength,
-      size_t inputChannelCount
+      size_t inputChannelCount,
+      WorkletsRunner &&workletRunner
   ) : AudioNode(context) {}
 
  protected:
@@ -36,10 +35,9 @@ class WorkletNode : public AudioNode {
  public:
   explicit WorkletNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime,
       size_t bufferLength,
-      size_t inputChannelCount
+      size_t inputChannelCount,
+      WorkletsRunner &&workletRunner
   );
 
   ~WorkletNode() override = default;
@@ -50,7 +48,6 @@ class WorkletNode : public AudioNode {
 
  private:
   WorkletsRunner workletRunner_;
-  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
   std::shared_ptr<AudioBus> bus_;
 
   /// @brief Length of the byte buffer that will be passed to the AudioArrayBuffer

package/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp

@@ -5,9 +5,8 @@ namespace audioapi {
 
 WorkletProcessingNode::WorkletProcessingNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime)
-    : AudioNode(context), workletRunner_(runtime), shareableWorklet_(worklet) {
+    WorkletsRunner &&workletRunner)
+    : AudioNode(context), workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
   // Pre-allocate buffers for max 128 frames and 2 channels (stereo)
@@ -42,8 +41,8 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
   }
 
   // Execute the worklet
-  auto result = workletRunner_.executeOnRuntimeGuardedSync(
-      [this, channelCount, framesToProcess](jsi::Runtime &rt) {
+  auto result = workletRunner_.executeOnRuntimeSync(
+      [this, channelCount, framesToProcess](jsi::Runtime &rt) -> jsi::Value {
         auto inputJsArray = jsi::Array(rt, channelCount);
         auto outputJsArray = jsi::Array(rt, channelCount);
 
@@ -58,14 +57,14 @@ std::shared_ptr<AudioBus> WorkletProcessingNode::processNode(
           outputJsArray.setValueAtIndex(rt, ch, outputArrayBuffer);
         }
 
-        return workletRunner_
-            .executeWorklet(
-                shareableWorklet_,
-                inputJsArray,
-                outputJsArray,
-                jsi::Value(rt, static_cast<int>(framesToProcess)),
-                jsi::Value(rt, this->context_->getCurrentTime()))
-            .value_or(jsi::Value::undefined());
+        // We call unsafely here because we are already on the runtime thread
+        // and the runtime is locked by executeOnRuntimeSync (if
+        // shouldLockRuntime is true)
+        return workletRunner_.callUnsafe(
+            inputJsArray,
+            outputJsArray,
+            jsi::Value(rt, static_cast<int>(framesToProcess)),
+            jsi::Value(rt, this->context_->getCurrentTime()));
       });
 
   // Copy processed output data back to the processing bus or zero on failure

package/common/cpp/audioapi/core/effects/WorkletProcessingNode.h

@@ -18,8 +18,7 @@ class WorkletProcessingNode : public AudioNode {
  public:
   explicit WorkletProcessingNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime
+      WorkletsRunner &&workletRunner
   ) : AudioNode(context) {}
 
  protected:
@@ -33,8 +32,7 @@ class WorkletProcessingNode : public AudioNode {
  public:
   explicit WorkletProcessingNode(
       BaseAudioContext *context,
-      std::shared_ptr<worklets::SerializableWorklet> &worklet,
-      std::weak_ptr<worklets::WorkletRuntime> runtime
+      WorkletsRunner &&workletRunner
   );
 
  protected:
@@ -42,7 +40,6 @@ class WorkletProcessingNode : public AudioNode {
 
  private:
   WorkletsRunner workletRunner_;
-  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> inputBuffsHandles_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> outputBuffsHandles_;
 };

package/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp

@@ -5,11 +5,9 @@ namespace audioapi {
 
 WorkletSourceNode::WorkletSourceNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime)
+    WorkletsRunner &&workletRunner)
     : AudioScheduledSourceNode(context),
-      workletRunner_(runtime),
-      shareableWorklet_(worklet) {
+      workletRunner_(std::move(workletRunner)) {
   isInitialized_ = true;
 
   // Prepare buffers for audio processing
@@ -42,21 +40,22 @@ std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
 
   size_t outputChannelCount = processingBus->getNumberOfChannels();
 
-  auto result = workletRunner_.executeOnRuntimeGuardedSync(
+  auto result = workletRunner_.executeOnRuntimeSync(
       [this, nonSilentFramesToProcess, startOffset](jsi::Runtime &rt) {
         auto jsiArray = jsi::Array(rt, this->outputBuffsHandles_.size());
         for (size_t i = 0; i < this->outputBuffsHandles_.size(); ++i) {
           auto arrayBuffer = jsi::ArrayBuffer(rt, this->outputBuffsHandles_[i]);
           jsiArray.setValueAtIndex(rt, i, arrayBuffer);
         }
-        return workletRunner_
-            .executeWorklet(
-                shareableWorklet_,
-                jsiArray,
-                jsi::Value(rt, static_cast<int>(nonSilentFramesToProcess)),
-                jsi::Value(rt, this->context_->getCurrentTime()),
-                jsi::Value(rt, static_cast<int>(startOffset)))
-            .value_or(jsi::Value::undefined());
+
+        // We call unsafely here because we are already on the runtime thread
+        // and the runtime is locked by executeOnRuntimeSync (if
+        // shouldLockRuntime is true)
+        return workletRunner_.callUnsafe(
+            jsiArray,
+            jsi::Value(rt, static_cast<int>(nonSilentFramesToProcess)),
+            jsi::Value(rt, this->context_->getCurrentTime()),
+            jsi::Value(rt, static_cast<int>(startOffset)));
       });
 
   // If the worklet execution failed, zero the output

package/common/cpp/audioapi/core/sources/WorkletSourceNode.h

@@ -18,8 +18,7 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
   explicit WorkletSourceNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime
+    WorkletsRunner &&workletRunner
   ) : AudioScheduledSourceNode(context) {}
 
  protected:
@@ -31,15 +30,13 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
  public:
   explicit WorkletSourceNode(
     BaseAudioContext *context,
-    std::shared_ptr<worklets::SerializableWorklet> &worklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime
+    WorkletsRunner &&workletRunner
   );
 
  protected:
   std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
  private:
   WorkletsRunner workletRunner_;
-  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
   std::vector<std::shared_ptr<AudioArrayBuffer>> outputBuffsHandles_;
 };
 #endif // RN_AUDIO_API_TEST

package/common/cpp/audioapi/core/utils/worklets/SafeIncludes.h

@@ -27,6 +27,11 @@
     #include <worklets/android/WorkletsModule.h>
   #endif
 #else
+
+#define RN_AUDIO_API_WORKLETS_DISABLED_ERROR \
+  std::runtime_error(               \
+      "Worklets are disabled. Please install react-native-worklets or check if you have supported version to enable these features.");
+
 /// @brief Dummy implementation of worklets for non-worklet builds they should do nothing and mock necessary methods
 /// @note It helps to reduce compile time branching across codebase
 /// @note If you need to base some c++ implementation on if the worklets are enabled use `#if RN_AUDIO_API_ENABLE_WORKLETS`
@@ -36,17 +41,41 @@ using namespace facebook;
 class MessageQueueThread {};
 class WorkletsModuleProxy {};
 class WorkletRuntime {
-  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool);
+ public:
+  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool) {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Runtime &getJSIRuntime() const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value executeSync(jsi::Runtime &rt, const jsi::Value &worklet) const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value executeSync(const std::function<jsi::Value(jsi::Runtime &)> &job) const {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
 };
 class SerializableWorklet {
-  SerializableWorklet(jsi::Runtime*, const jsi::Object &);
+ public:
+  SerializableWorklet(jsi::Runtime*, const jsi::Object &) {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
+  jsi::Value toJSValue(jsi::Runtime &rt) {
+    throw RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+  }
 };
 } // namespace worklets
+
+#undef RN_AUDIO_API_WORKLETS_DISABLED_ERROR
+
 #endif
 
 /// @brief Struct to hold references to different runtimes used in the AudioAPI
 /// @note it is used to pass them around and avoid creating multiple instances of the same runtime
 struct RuntimeRegistry {
   std::weak_ptr<worklets::WorkletRuntime> uiRuntime;
-  std::weak_ptr<worklets::WorkletRuntime> audioRuntime;
+  std::shared_ptr<worklets::WorkletRuntime> audioRuntime;
 };

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.cpp

@@ -3,7 +3,80 @@
 namespace audioapi {
 
 WorkletsRunner::WorkletsRunner(
-    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept
-    : weakUiRuntime_(std::move(weakUiRuntime)) {}
+    std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
+    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    bool shouldLockRuntime)
+    : weakRuntime_(std::move(weakRuntime)),
+      shouldLockRuntime(shouldLockRuntime) {
+  auto strongRuntime = weakRuntime_.lock();
+  if (strongRuntime == nullptr) {
+    return;
+  }
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  unsafeRuntimePtr = &strongRuntime->getJSIRuntime();
+  strongRuntime->executeSync(
+      [this, shareableWorklet](jsi::Runtime &rt) -> jsi::Value {
+        /// Placement new to avoid dynamic memory allocation
+        new (reinterpret_cast<jsi::Function *>(&unsafeWorklet))
+            jsi::Function(shareableWorklet->toJSValue(*unsafeRuntimePtr)
+                              .asObject(*unsafeRuntimePtr)
+                              .asFunction(*unsafeRuntimePtr));
+        return jsi::Value::undefined();
+      });
+  workletInitialized = true;
+#else
+  unsafeRuntimePtr = nullptr;
+  workletInitialized = false;
+#endif
+}
+
+WorkletsRunner::WorkletsRunner(WorkletsRunner &&other)
+    : weakRuntime_(std::move(other.weakRuntime_)),
+      unsafeRuntimePtr(other.unsafeRuntimePtr),
+      shouldLockRuntime(other.shouldLockRuntime),
+      workletInitialized(other.workletInitialized) {
+  if (workletInitialized) {
+    std::memcpy(&unsafeWorklet, &other.unsafeWorklet, sizeof(unsafeWorklet));
+    other.workletInitialized = false;
+    other.unsafeRuntimePtr = nullptr;
+  }
+}
+
+WorkletsRunner::~WorkletsRunner() {
+  if (!workletInitialized) {
+    return;
+  }
+  auto strongRuntime = weakRuntime_.lock();
+  if (strongRuntime == nullptr) {
+    // We cannot safely destroy the worklet without a valid runtime
+    return;
+  }
+  reinterpret_cast<jsi::Function *>(&unsafeWorklet)->~Function();
+  workletInitialized = false;
+}
+
+std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeGuarded(
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
+    noexcept(noexcept(job)) {
+  auto strongRuntime = weakRuntime_.lock();
+  if (strongRuntime == nullptr) {
+    return std::nullopt;
+  }
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  return strongRuntime->executeSync(std::move(job));
+#else
+  return std::nullopt;
+#endif
+}
+
+std::optional<jsi::Value> WorkletsRunner::executeOnRuntimeUnsafe(
+    const std::function<jsi::Value(jsi::Runtime &)> &&job) const
+    noexcept(noexcept(job)) {
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  return job(*unsafeRuntimePtr);
+#else
+  return std::nullopt;
+#endif
+};
 
 }; // namespace audioapi

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.h

@@ -26,48 +26,62 @@ using namespace facebook;
 
 class WorkletsRunner {
  public:
-    explicit WorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
+  explicit WorkletsRunner(
+    std::weak_ptr<worklets::WorkletRuntime> weakRuntime,
+    std::shared_ptr<worklets::SerializableWorklet> shareableWorklet,
+    bool shouldLockRuntime = true);
+  WorkletsRunner(WorkletsRunner&&);
+  ~WorkletsRunner();
 
-    /// @brief Execute a job on the UI runtime safely.
-    /// @param job
-    /// @return nullopt if the runtime is not available or the result of the job execution
-    /// @note Execution is synchronous
-    std::optional<jsi::Value> executeOnRuntimeGuardedSync(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job)) {
-      auto strongRuntime = weakUiRuntime_.lock();
-      if (strongRuntime == nullptr) {
-         return std::nullopt;
-      }
-      #if RN_AUDIO_API_ENABLE_WORKLETS
-      return strongRuntime->executeSync(std::move(job));
-      #else
-      return std::nullopt;
-      #endif
-    }
+  /// @brief Call the worklet function with the given arguments.
+  /// @tparam ...Args
+  /// @param ...args
+  /// @return The result of the worklet function call.
+  /// @note This method is unsafe and should be used with caution. It assumes that the runtime and worklet are valid and runtime is locked.
+  template<typename... Args>
+  inline jsi::Value callUnsafe(Args&&... args) {
+    return getUnsafeWorklet().call(*unsafeRuntimePtr, std::forward<Args>(args)...);
+  }
 
-    /// @brief Execute a worklet with the given arguments.
-    /// @tparam ...Args
-    /// @param shareableWorklet
-    /// @param ...args
-    /// @note Execution is synchronous, this method can be used in `executeOnRuntimeGuardedSync` and `...Async` methods arguments
-    /// @return nullopt if the runtime is not available or the result of the worklet execution
-    template<typename... Args>
-    std::optional<jsi::Value> executeWorklet(const std::shared_ptr<worklets::SerializableWorklet>& shareableWorklet, Args&&... args) {
-      auto strongRuntime = weakUiRuntime_.lock();
-      if (strongRuntime == nullptr) {
-         return std::nullopt;
-      }
 
-      #if RN_AUDIO_API_ENABLE_WORKLETS
+  /// @brief Call the worklet function with the given arguments.
+  /// @tparam ...Args
+  /// @param ...args
+  /// @return The result of the worklet function call.
+  /// @note This method is safe and will check if the runtime is available before calling the worklet. If the runtime is not available, it will return nullopt.
+  template<typename... Args>
+  inline std::optional<jsi::Value> call(Args&&... args) {
+    return executeOnRuntimeGuarded([this, args...](jsi::Runtime &rt) -> jsi::Value {
+      return callUnsafe(std::forward<Args>(args)...);
+    });
+  }
 
-      return strongRuntime->runGuarded(shareableWorklet, std::forward<Args>(args)...);
-
-      #else
-      return std::nullopt;
-      #endif
-    }
+  /// @brief Execute a job on the UI runtime safely.
+  /// @param job
+  /// @return nullopt if the runtime is not available or the result of the job execution
+  /// @note Execution is synchronous and will be guarded if shouldLockRuntime is true.
+  inline std::optional<jsi::Value> executeOnRuntimeSync(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job)) {
+    if (shouldLockRuntime) return executeOnRuntimeGuarded(std::move(job));
+    else return executeOnRuntimeUnsafe(std::move(job));
+  }
 
  private:
-    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime_;
+  std::weak_ptr<worklets::WorkletRuntime> weakRuntime_;
+  jsi::Runtime* unsafeRuntimePtr = nullptr;
+
+  /// @note We want to avoid automatic destruction as
+  /// when runtime is destroyed, underlying pointer will be invalid
+  char unsafeWorklet[sizeof(jsi::Function)];
+  bool workletInitialized = false;
+  bool shouldLockRuntime = true;
+
+  inline jsi::Function &getUnsafeWorklet() {
+    return *reinterpret_cast<jsi::Function*>(&unsafeWorklet);
+  }
+
+  std::optional<jsi::Value> executeOnRuntimeGuarded(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job));
+
+  std::optional<jsi::Value> executeOnRuntimeUnsafe(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job));
 };
 
 } // namespace audioapi

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -18,7 +18,8 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(
       float sampleRate,
       int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+      const std::shared_ptr<AudioEventHandlerRegistry>
+          &audioEventHandlerRegistry);
 
   ~IOSAudioRecorder() override;