react-native-audio-api 0.8.3-nightly-d178688-20250925 → 0.8.3-nightly-cae1f96-20250927

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.cpp

@@ -0,0 +1,22 @@
+#include <audioapi/HostObjects/sources/StreamerNodeHostObject.h>
+
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
+#include <audioapi/core/sources/StreamerNode.h>
+
+namespace audioapi {
+
+StreamerNodeHostObject::StreamerNodeHostObject(
+    const std::shared_ptr<StreamerNode> &node)
+    : AudioScheduledSourceNodeHostObject(node) {
+  addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
+}
+
+JSI_HOST_FUNCTION_IMPL(StreamerNodeHostObject, initialize) {
+  auto streamerNode = std::static_pointer_cast<StreamerNode>(node_);
+  auto path = args[0].getString(runtime).utf8(runtime);
+  auto result = streamerNode->initialize(path);
+  return {result};
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class StreamerNode;
+
+class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit StreamerNodeHostObject(
+          const std::shared_ptr<StreamerNode> &node);
+
+    [[nodiscard]] static inline size_t getSizeInBytes() {
+        return SIZE;
+    }
+
+  JSI_HOST_FUNCTION_DECL(initialize);
+
+ private:
+    static constexpr size_t SIZE = 4'000'000; // 4MB
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -14,8 +14,9 @@ AudioContext::AudioContext(
     float sampleRate,
     bool initSuspended,
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry) {
+        &audioEventHandlerRegistry,
+    const std::shared_ptr<UiWorkletsRunner> &workletRunner)
+    : BaseAudioContext(audioEventHandlerRegistry, workletRunner) {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(
       this->renderAudio(), sampleRate, destination_->getChannelCount());

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
 
 #include <memory>
 #include <functional>
@@ -14,7 +15,7 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  explicit AudioContext(float sampleRate, bool initSuspended, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit AudioContext(float sampleRate, bool initSuspended, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const std::shared_ptr<UiWorkletsRunner> &workletRunner);
   ~AudioContext() override;
 
   void close();

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

@@ -2,7 +2,7 @@
 
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 
 #include <memory>
 #include <string>

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

@@ -4,7 +4,7 @@
 #include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/core/AudioNode.h>
-#include <audioapi/core/AudioParamEventQueue.h>
+#include <audioapi/core/utils/AudioParamEventQueue.h>
 
 #include <cstddef>
 #include <utility>

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

@@ -4,6 +4,7 @@
 #include <audioapi/core/effects/BiquadFilterNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
+#include <audioapi/core/effects/WorkletNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
@@ -12,6 +13,7 @@
 #include <audioapi/core/sources/StreamerNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -21,11 +23,13 @@ namespace audioapi {
 
 BaseAudioContext::BaseAudioContext(
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry) {
+        &audioEventHandlerRegistry,
+    const std::shared_ptr<UiWorkletsRunner> &workletRunner) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
 
   audioEventHandlerRegistry_ = audioEventHandlerRegistry;
+  workletRunner_ = workletRunner;
 }
 
 std::string BaseAudioContext::getState() {
@@ -58,6 +62,16 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
   return destination_;
 }
 
+std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    size_t bufferLength,
+    size_t inputChannelCount) {
+  auto workletNode = std::make_shared<WorkletNode>(
+      this, shareableWorklet, bufferLength, inputChannelCount);
+  nodeManager_->addProcessingNode(workletNode);
+  return workletNode;
+}
+
 std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
   auto recorderAdapter = std::make_shared<RecorderAdapterNode>(this);
   nodeManager_->addProcessingNode(recorderAdapter);

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

@@ -2,7 +2,8 @@
 
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
-
+#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <functional>
 #include <memory>
@@ -31,11 +32,12 @@ class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
+class WorkletNode;
 class StreamerNode;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const std::shared_ptr<UiWorkletsRunner> &workletRunner);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -45,6 +47,7 @@ class BaseAudioContext {
   std::shared_ptr<AudioDestinationNode> getDestination();
 
   std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
+  std::shared_ptr<WorkletNode> createWorkletNode(std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet, size_t bufferLength, size_t inputChannelCount);
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<StreamerNode> createStreamer();
   std::shared_ptr<GainNode> createGain();
@@ -89,10 +92,11 @@ class BaseAudioContext {
   std::shared_ptr<PeriodicWave> cachedSawtoothWave_ = nullptr;
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
-  virtual bool isDriverRunning() const = 0;
+  [[nodiscard]] virtual bool isDriverRunning() const = 0;
 
  public:
     std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
+    std::shared_ptr<UiWorkletsRunner> workletRunner_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -1,11 +1,11 @@
 #include "OfflineAudioContext.h"
 
 #include <audioapi/core/AudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -23,8 +23,9 @@ OfflineAudioContext::OfflineAudioContext(
     size_t length,
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry>
-        &audioEventHandlerRegistry)
-    : BaseAudioContext(audioEventHandlerRegistry),
+        &audioEventHandlerRegistry,
+    const std::shared_ptr<UiWorkletsRunner> &workletRunner)
+    : BaseAudioContext(audioEventHandlerRegistry, workletRunner),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "BaseAudioContext.h"
+#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
 
 #include <mutex>
 #include <map>
@@ -14,7 +15,7 @@ using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<Aud
 
 class OfflineAudioContext : public BaseAudioContext {
  public:
-  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const std::shared_ptr<UiWorkletsRunner> &workletRunner);
   ~OfflineAudioContext() override;
 
   void resume();

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

@@ -26,8 +26,8 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/PeriodicWave.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/VectorMath.h>
 
 constexpr unsigned NumberOfOctaveBands = 3;

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

@@ -1,6 +1,6 @@
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 

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

@@ -0,0 +1,86 @@
+#include <audioapi/core/effects/WorkletNode.h>
+
+namespace audioapi {
+
+WorkletNode::WorkletNode(
+    BaseAudioContext *context,
+    std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    size_t bufferLength,
+    size_t inputChannelCount)
+    : AudioNode(context),
+      buffRealLength_(bufferLength * sizeof(float)),
+      bufferLength_(bufferLength),
+      workletRunner_(context->workletRunner_),
+      shareableWorklet_(worklet),
+      inputChannelCount_(inputChannelCount),
+      curBuffIndex_(0) {
+  buffs_.reserve(inputChannelCount_);
+  for (size_t i = 0; i < inputChannelCount_; ++i) {
+    buffs_.emplace_back(new uint8_t[buffRealLength_]);
+  }
+  isInitialized_ = true;
+}
+
+WorkletNode::~WorkletNode() {
+  for (auto &buff : buffs_) {
+    delete[] buff;
+  }
+}
+
+void WorkletNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  size_t processed = 0;
+  size_t channelCount_ = std::min(
+      inputChannelCount_,
+      static_cast<size_t>(processingBus->getNumberOfChannels()));
+  while (processed < framesToProcess) {
+    size_t framesToWorkletInvoke = bufferLength_ - curBuffIndex_;
+    size_t needsToProcess = framesToProcess - processed;
+    size_t shouldProcess = std::min(framesToWorkletInvoke, needsToProcess);
+
+    for (size_t ch = 0; ch < channelCount_; ch++) {
+      /// here we copy
+      /// to   uint8_t* [curBuffIndex_, curBuffIndex_ + shouldProcess]
+      /// from float* [processed, processed + shouldProcess]
+      /// so as the we need to copy shouldProcess * sizeof(float) bytes
+      auto channelData = processingBus->getChannel(ch)->getData();
+      std::memcpy(
+          /* dest */ buffs_[ch] + curBuffIndex_ * sizeof(float),
+          /* src */ reinterpret_cast<const uint8_t *>(channelData + processed),
+          /* size */ shouldProcess * sizeof(float));
+    }
+    processed += shouldProcess;
+    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++) {
+              uint8_t *buffPtr = buffs_[ch];
+              buffs_[ch] = new uint8_t[buffRealLength_];
+              auto sharedAudioArray =
+                  std::make_shared<AudioArrayBuffer>(buffPtr, buffRealLength_);
+              auto arrayBuffer =
+                  jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+              jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
+            }
+            jsArray.setExternalMemoryPressure(
+                uiRuntimeRaw, channelCount_ * buffRealLength_);
+
+            workletRunner_->executeWorklet(
+                shareableWorklet_,
+                std::move(jsArray),
+                jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));
+            return jsi::Value::undefined();
+          });
+    }
+  }
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,64 @@
+#pragma once
+
+
+#include <jsi/jsi.h>
+#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/jsi/AudioArrayBuffer.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+#if RN_AUDIO_API_TEST
+class WorkletNode : public AudioNode {
+ public:
+  explicit WorkletNode(
+      BaseAudioContext *context,
+      std::shared_ptr<worklets::SerializableWorklet> &worklet,
+      size_t bufferLength,
+      size_t inputChannelCount
+  ) : AudioNode(context) {}
+  ~WorkletNode() override = default;
+
+ protected:
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override {}
+};
+#else
+
+using namespace facebook;
+
+class WorkletNode : public AudioNode {
+ public:
+  explicit WorkletNode(
+      BaseAudioContext *context,
+      std::shared_ptr<worklets::SerializableWorklet> &worklet,
+      size_t bufferLength,
+      size_t inputChannelCount
+  );
+
+  ~WorkletNode() override;
+
+ protected:
+  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+
+
+ private:
+  std::shared_ptr<UiWorkletsRunner> workletRunner_;
+  std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
+  std::vector<uint8_t*> buffs_;
+
+  /// @brief Length of the byte buffer that will be passed to the AudioArrayBuffer
+  size_t buffRealLength_;
+  size_t bufferLength_;
+  size_t inputChannelCount_;
+  size_t curBuffIndex_;
+};
+
+#endif // RN_AUDIO_API_TEST
+
+} // namespace audioapi

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,11 +1,11 @@
 #pragma once
 
-
 #include <memory>
-#include <mutex>
 #include <atomic>
+#include <mutex>
 
 namespace audioapi {
+
 class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;

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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>

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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>

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

@@ -1,7 +1,7 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>

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

@@ -43,14 +43,6 @@ class StreamerNode : public AudioScheduledSourceNode {
   bool initialize(const std::string& inputUrl);
   void stop(double when) override;
 
- private:
-  static constexpr int SIZE = 4'000'000; // 4MB
-
- public:
-  static constexpr int getEstimatedSize() {
-    return StreamerNode::SIZE;
-  } // in bytes
-
  protected:
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 

package/common/cpp/audioapi/core/{AudioParamEventQueue.cpp → utils/AudioParamEventQueue.cpp}

@@ -1,4 +1,4 @@
-#include <audioapi/core/AudioParamEventQueue.h>
+#include <audioapi/core/utils/AudioParamEventQueue.h>
 
 namespace audioapi {
 

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

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <string>
+#include <memory>
+
+#ifdef __APPLE__
+  /// We cannot make any conditional logic inside podspec but it should automatically compile those files
+  /// they should be accessible if someone has react-native-worklets in node_modules
+  #if __has_include(<worklets/WorkletRuntime/WorkletRuntime.h>)
+    #define RN_AUDIO_API_ENABLE_WORKLETS 1
+  #else
+    #define RN_AUDIO_API_ENABLE_WORKLETS 0
+  #endif
+#endif
+
+#ifndef RN_AUDIO_API_TEST
+  #define RN_AUDIO_API_TEST 0
+#endif
+
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  #include <worklets/WorkletRuntime/WorkletRuntime.h>
+  #include <worklets/SharedItems/Serializable.h>
+  #include <worklets/NativeModules/WorkletsModuleProxy.h>
+  #if ANDROID
+    #include <worklets/android/WorkletsModule.h>
+  #endif
+#else
+/// @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`
+namespace worklets {
+
+using namespace facebook;
+class MessageQueueThread {};
+class WorkletsModuleProxy {};
+class WorkletRuntime {
+  explicit WorkletRuntime(uint64_t, const std::shared_ptr<MessageQueueThread> &, const std::string &, const bool);
+};
+class SerializableWorklet {
+  SerializableWorklet(jsi::Runtime*, const jsi::Object &);
+};
+} // namespace worklets
+#endif

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

@@ -0,0 +1,9 @@
+#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
+
+namespace audioapi {
+
+UiWorkletsRunner::UiWorkletsRunner(
+    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept
+    : weakUiRuntime_(std::move(weakUiRuntime)) {}
+
+}; // namespace audioapi

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

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+
+#include <functional>
+#include <atomic>
+#include <memory>
+#include <utility>
+#include <optional>
+
+namespace audioapi {
+using namespace facebook;
+
+/*
+* # How to extract worklet from JavaScript argument
+*
+* To extract a shareable worklet from a JavaScript argument, use the following code:
+*
+* ```cpp
+* auto worklet = worklets::extractSerializableWorkletFromArg(runtime, args[0]);
+* ```
+*
+* This will return a shared pointer to the extracted worklet, or throw an error if the argument is invalid.
+*/
+
+class UiWorkletsRunner {
+ public:
+    explicit UiWorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
+
+    /// @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 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
+
+      return strongRuntime->runGuarded(shareableWorklet, std::forward<Args>(args)...);
+
+      #else
+      return std::nullopt;
+      #endif
+    }
+
+ private:
+    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/Windows.h>
 
 namespace audioapi::dsp {

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 
 namespace audioapi {

package/common/cpp/audioapi/jsi/AudioArrayBuffer.h

@@ -9,7 +9,20 @@ using namespace facebook;
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
   AudioArrayBuffer(uint8_t *data, size_t size): data_(data), size_(size) {}
-  ~AudioArrayBuffer() override = default;
+  ~AudioArrayBuffer() override {
+    if (data_ == nullptr) {
+      return;
+    }
+    delete[] data_;
+  }
+  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
+      : data_(other.data_), size_(other.size_) {
+    other.data_ = nullptr;
+  }
+
+  AudioArrayBuffer(const AudioArrayBuffer &) = delete;
+  AudioArrayBuffer &operator=(const AudioArrayBuffer &) = delete;
+  AudioArrayBuffer &operator=(AudioArrayBuffer &&other) = delete;
 
   [[nodiscard]] size_t size() const override;
   uint8_t *data() override;