react-native-audio-api 0.8.3-nightly-e918179-20251003 → 0.8.3-nightly-ea268f4-20251004

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -26,11 +26,10 @@ class AudioAPIModuleInstaller {
     const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
     std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
-    auto workletRunner = std::make_shared<UiWorkletsRunner>(uiRuntime);
 
-    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, workletRunner);
+    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
     auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
-    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, workletRunner);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
@@ -45,12 +44,12 @@ class AudioAPIModuleInstaller {
     jsi::Runtime *jsiRuntime,
     const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const std::shared_ptr<UiWorkletsRunner> &workletRunner) {
+    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry, workletRunner](
+        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -58,8 +57,17 @@ class AudioAPIModuleInstaller {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
           auto initSuspended = args[1].getBool();
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, workletRunner);
 
+          #if RN_AUDIO_API_ENABLE_WORKLETS
+              auto runtimeRegistry = RuntimeRegistry{
+                  .uiRuntime = uiRuntime,
+                  .audioRuntime = worklets::extractWorkletRuntime(runtime, args[2])
+              };
+          #else
+              auto runtimeRegistry = RuntimeRegistry{};
+          #endif
+
+          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, runtimeRegistry);
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);
 
@@ -72,12 +80,12 @@ class AudioAPIModuleInstaller {
     jsi::Runtime *jsiRuntime,
     const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const std::shared_ptr<UiWorkletsRunner> &workletRunner) {
+    const std::weak_ptr<worklets::WorkletRuntime> &uiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry, workletRunner](
+        [jsCallInvoker, audioEventHandlerRegistry, uiRuntime](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -86,12 +94,21 @@ class AudioAPIModuleInstaller {
             auto length = static_cast<size_t>(args[1].getNumber());
             auto sampleRate = static_cast<float>(args[2].getNumber());
 
-          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, workletRunner);
-          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
-              offlineAudioContext, &runtime, jsCallInvoker);
-
-          return jsi::Object::createFromHostObject(
-              runtime, audioContextHostObject);
+            #if RN_AUDIO_API_ENABLE_WORKLETS
+                auto runtimeRegistry = RuntimeRegistry{
+                    .uiRuntime = uiRuntime,
+                    .audioRuntime = worklets::extractWorkletRuntime(runtime, args[3])
+                };
+            #else
+            auto runtimeRegistry = RuntimeRegistry{};
+            #endif
+
+            auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry);
+            auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+                offlineAudioContext, &runtime, jsCallInvoker);
+
+            return jsi::Object::createFromHostObject(
+                runtime, audioContextHostObject);
         });
   }
 

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

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
 
 #include <audioapi/HostObjects/WorkletNodeHostObject.h>
+#include <audioapi/HostObjects/WorkletProcessingNodeHostObject.h>
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
@@ -10,11 +11,12 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
+#include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/OscillatorNodeHostObject.h>
 #include <audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h>
 #include <audioapi/HostObjects/sources/StreamerNodeHostObject.h>
+#include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
 
 namespace audioapi {
 
@@ -32,10 +34,14 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, currentTime));
 
   addFunctions(
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletSourceNode),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletNode),
+      JSI_EXPORT_FUNCTION(
+          BaseAudioContextHostObject, createWorkletProcessingNode),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStreamer),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConstantSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
@@ -68,16 +74,47 @@ JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, currentTime) {
   return {context_->getCurrentTime()};
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  auto shareableWorklet =
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
+          runtime, args[0]);
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
+  auto shouldUseUiRuntime = args[1].getBool();
+  if (shouldUseUiRuntime) {
+    workletRuntime = context_->runtimeRegistry_.uiRuntime;
+  } else {
+    workletRuntime = context_->runtimeRegistry_.audioRuntime;
+  }
+
+  auto workletSourceNode =
+      context_->createWorkletSourceNode(shareableWorklet, workletRuntime);
+  auto workletSourceNodeHostObject =
+      std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
+  return jsi::Object::createFromHostObject(
+      runtime, workletSourceNodeHostObject);
+#endif
+  return jsi::Value::undefined();
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
       worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
           runtime, args[0]);
-  auto bufferLength = static_cast<size_t>(args[1].getNumber());
-  auto inputChannelCount = static_cast<size_t>(args[2].getNumber());
+
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
+  auto shouldUseUiRuntime = args[1].getBool();
+  if (shouldUseUiRuntime) {
+    workletRuntime = context_->runtimeRegistry_.uiRuntime;
+  } else {
+    workletRuntime = context_->runtimeRegistry_.audioRuntime;
+  }
+  auto bufferLength = static_cast<size_t>(args[2].getNumber());
+  auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
 
   auto workletNode = context_->createWorkletNode(
-      shareableWorklet, bufferLength, inputChannelCount);
+      shareableWorklet, workletRuntime, bufferLength, inputChannelCount);
   auto workletNodeHostObject =
       std::make_shared<WorkletNodeHostObject>(workletNode);
   return jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
@@ -85,6 +122,32 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
   return jsi::Value::undefined();
 }
 
+JSI_HOST_FUNCTION_IMPL(
+    BaseAudioContextHostObject,
+    createWorkletProcessingNode) {
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  auto shareableWorklet =
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
+          runtime, args[0]);
+
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
+  auto shouldUseUiRuntime = args[1].getBool();
+  if (shouldUseUiRuntime) {
+    workletRuntime = context_->runtimeRegistry_.uiRuntime;
+  } else {
+    workletRuntime = context_->runtimeRegistry_.audioRuntime;
+  }
+
+  auto workletProcessingNode =
+      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime);
+  auto workletProcessingNodeHostObject =
+      std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
+  return jsi::Object::createFromHostObject(
+      runtime, workletProcessingNodeHostObject);
+#endif
+  return jsi::Value::undefined();
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
   auto recorderAdapter = context_->createRecorderAdapter();
   auto recorderAdapterHostObject =
@@ -108,6 +171,13 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
   return object;
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
+  auto constantSource = context_->createConstantSource();
+  auto constantSourceHostObject =
+      std::make_shared<ConstantSourceNodeHostObject>(constantSource);
+  return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
   auto gain = context_->createGain();
   auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);

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

@@ -26,10 +26,13 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_PROPERTY_GETTER_DECL(sampleRate);
   JSI_PROPERTY_GETTER_DECL(currentTime);
 
+  JSI_HOST_FUNCTION_DECL(createWorkletSourceNode);
   JSI_HOST_FUNCTION_DECL(createWorkletNode);
+  JSI_HOST_FUNCTION_DECL(createWorkletProcessingNode);
   JSI_HOST_FUNCTION_DECL(createRecorderAdapter);
   JSI_HOST_FUNCTION_DECL(createOscillator);
   JSI_HOST_FUNCTION_DECL(createStreamer);
+  JSI_HOST_FUNCTION_DECL(createConstantSource);
   JSI_HOST_FUNCTION_DECL(createGain);
   JSI_HOST_FUNCTION_DECL(createStereoPanner);
   JSI_HOST_FUNCTION_DECL(createBiquadFilter);

package/common/cpp/audioapi/HostObjects/WorkletProcessingNodeHostObject.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/effects/WorkletProcessingNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WorkletProcessingNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit WorkletProcessingNodeHostObject(const std::shared_ptr<WorkletProcessingNode> &node)
+      : AudioNodeHostObject(node) {
+  }
+};
+} // namespace audioapi

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

@@ -19,7 +19,8 @@ AudioBufferSourceNodeHostObject::AudioBufferSourceNodeHostObject(
       JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),
       JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopSkip),
       JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopStart),
-      JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd));
+      JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd),
+      JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, onLoopEnded));
 
   // start method is overridden in this class
   functions_->erase("start");
@@ -29,6 +30,16 @@ AudioBufferSourceNodeHostObject::AudioBufferSourceNodeHostObject(
       JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, setBuffer));
 }
 
+AudioBufferSourceNodeHostObject::~AudioBufferSourceNodeHostObject() {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+
+  // When JSI object is garbage collected (together with the eventual callback),
+  // underlying source node might still be active and try to call the
+  // non-existing callback.
+  audioBufferSourceNode->clearOnLoopEndedCallback();
+}
+
 JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, loop) {
   auto audioBufferSourceNode =
       std::static_pointer_cast<AudioBufferSourceNode>(node_);
@@ -94,6 +105,14 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopEnd) {
   audioBufferSourceNode->setLoopEnd(value.getNumber());
 }
 
+JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, onLoopEnded) {
+  auto audioBufferSourceNode =
+      std::static_pointer_cast<AudioBufferSourceNode>(node_);
+
+  audioBufferSourceNode->setOnLoopEndedCallbackId(
+      std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, start) {
   auto when = args[0].getNumber();
   auto offset = args[1].getNumber();

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

@@ -16,6 +16,8 @@ class AudioBufferSourceNodeHostObject
   explicit AudioBufferSourceNodeHostObject(
       const std::shared_ptr<AudioBufferSourceNode> &node);
 
+  ~AudioBufferSourceNodeHostObject() override;
+
   JSI_PROPERTY_GETTER_DECL(loop);
   JSI_PROPERTY_GETTER_DECL(loopSkip);
   JSI_PROPERTY_GETTER_DECL(buffer);
@@ -26,6 +28,7 @@ class AudioBufferSourceNodeHostObject
   JSI_PROPERTY_SETTER_DECL(loopSkip);
   JSI_PROPERTY_SETTER_DECL(loopStart);
   JSI_PROPERTY_SETTER_DECL(loopEnd);
+  JSI_PROPERTY_SETTER_DECL(onLoopEnded);
 
   JSI_HOST_FUNCTION_DECL(start);
   JSI_HOST_FUNCTION_DECL(setBuffer);

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

@@ -0,0 +1,19 @@
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
+
+namespace audioapi {
+
+ConstantSourceNodeHostObject::ConstantSourceNodeHostObject(
+    const std::shared_ptr<ConstantSourceNode> &node)
+    : AudioScheduledSourceNodeHostObject(node) {
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(ConstantSourceNodeHostObject, offset));
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConstantSourceNodeHostObject, offset) {
+  auto constantSourceNode = std::static_pointer_cast<ConstantSourceNode>(node_);
+  auto offsetParam_ = std::make_shared<AudioParamHostObject>(
+      constantSourceNode->getOffsetParam());
+  return jsi::Object::createFromHostObject(runtime, offsetParam_);
+}
+} // namespace audioapi

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

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class ConstantSourceNode;
+
+class ConstantSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit ConstantSourceNodeHostObject(
+        const std::shared_ptr<ConstantSourceNode> &node);
+
+  JSI_PROPERTY_GETTER_DECL(offset);
+};
+} // namespace audioapi

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/core/sources/WorkletSourceNode.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class WorkletSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit WorkletSourceNodeHostObject(const std::shared_ptr<WorkletSourceNode> &node)
+      : AudioScheduledSourceNodeHostObject(node) {
+  }
+};
+} // namespace audioapi

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

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

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

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

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

@@ -219,9 +219,9 @@ void AudioParam::setValueCurveAtTime(
             (time - startTime)));
         // Calculate interpolation factor between adjacent array elements
         auto factor = static_cast<float>(
-            k -
             (time - startTime) * static_cast<double>(length - 1) /
-                (endTime - startTime));
+                (endTime - startTime) -
+            k);
         return dsp::linearInterpolate(values->data(), k, k + 1, factor);
       }
 

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

@@ -5,12 +5,15 @@
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/effects/WorkletNode.h>
+#include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/sources/StreamerNode.h>
+#include <audioapi/core/sources/WorkletSourceNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
@@ -24,12 +27,12 @@ namespace audioapi {
 BaseAudioContext::BaseAudioContext(
     const std::shared_ptr<IAudioEventHandlerRegistry>
         &audioEventHandlerRegistry,
-    const std::shared_ptr<UiWorkletsRunner> &workletRunner) {
+    const RuntimeRegistry &runtimeRegistry) {
   nodeManager_ = std::make_shared<AudioNodeManager>();
   destination_ = std::make_shared<AudioDestinationNode>(this);
 
   audioEventHandlerRegistry_ = audioEventHandlerRegistry;
-  workletRunner_ = workletRunner;
+  runtimeRegistry_ = runtimeRegistry;
 }
 
 std::string BaseAudioContext::getState() {
@@ -62,16 +65,36 @@ std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() {
   return destination_;
 }
 
+std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+  auto workletSourceNode =
+      std::make_shared<WorkletSourceNode>(this, shareableWorklet, runtime);
+  nodeManager_->addSourceNode(workletSourceNode);
+  return workletSourceNode;
+}
+
 std::shared_ptr<WorkletNode> BaseAudioContext::createWorkletNode(
     std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
     size_t bufferLength,
     size_t inputChannelCount) {
   auto workletNode = std::make_shared<WorkletNode>(
-      this, shareableWorklet, bufferLength, inputChannelCount);
+      this, shareableWorklet, runtime, bufferLength, inputChannelCount);
   nodeManager_->addProcessingNode(workletNode);
   return workletNode;
 }
 
+std::shared_ptr<WorkletProcessingNode>
+BaseAudioContext::createWorkletProcessingNode(
+    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime) {
+  auto workletProcessingNode =
+      std::make_shared<WorkletProcessingNode>(this, shareableWorklet, runtime);
+  nodeManager_->addProcessingNode(workletProcessingNode);
+  return workletProcessingNode;
+}
+
 std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
   auto recorderAdapter = std::make_shared<RecorderAdapterNode>(this);
   nodeManager_->addProcessingNode(recorderAdapter);
@@ -84,6 +107,12 @@ std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
   return oscillator;
 }
 
+std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource() {
+  auto constantSource = std::make_shared<ConstantSourceNode>(this);
+  nodeManager_->addSourceNode(constantSource);
+  return constantSource;
+}
+
 #ifndef AUDIO_API_TEST_SUITE
 std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
   auto streamer = std::make_shared<StreamerNode>(this);

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

@@ -2,7 +2,6 @@
 
 #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>
@@ -21,6 +20,7 @@ class GainNode;
 class AudioBuffer;
 class PeriodicWave;
 class OscillatorNode;
+class ConstantSourceNode;
 class StereoPannerNode;
 class AudioNodeManager;
 class BiquadFilterNode;
@@ -32,12 +32,14 @@ class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
 class RecorderAdapterNode;
+class WorkletSourceNode;
 class WorkletNode;
+class WorkletProcessingNode;
 class StreamerNode;
 
 class BaseAudioContext {
  public:
-  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const std::shared_ptr<UiWorkletsRunner> &workletRunner);
+  explicit BaseAudioContext(const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   virtual ~BaseAudioContext() = default;
 
   std::string getState();
@@ -47,8 +49,11 @@ 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<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<OscillatorNode> createOscillator();
+  std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
@@ -96,7 +101,7 @@ class BaseAudioContext {
 
  public:
     std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
-    std::shared_ptr<UiWorkletsRunner> workletRunner_;
+    RuntimeRegistry runtimeRegistry_;
 };
 
 } // namespace audioapi

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

@@ -24,8 +24,8 @@ OfflineAudioContext::OfflineAudioContext(
     float sampleRate,
     const std::shared_ptr<IAudioEventHandlerRegistry>
         &audioEventHandlerRegistry,
-    const std::shared_ptr<UiWorkletsRunner> &workletRunner)
-    : BaseAudioContext(audioEventHandlerRegistry, workletRunner),
+    const RuntimeRegistry &runtimeRegistry)
+    : BaseAudioContext(audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {

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

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "BaseAudioContext.h"
-#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <mutex>
 #include <map>
@@ -15,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, const std::shared_ptr<UiWorkletsRunner> &workletRunner);
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate, const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry, const RuntimeRegistry &runtimeRegistry);
   ~OfflineAudioContext() override;
 
   void resume();

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

@@ -5,12 +5,13 @@ namespace audioapi {
 WorkletNode::WorkletNode(
     BaseAudioContext *context,
     std::shared_ptr<worklets::SerializableWorklet> &worklet,
+    std::weak_ptr<worklets::WorkletRuntime> runtime,
     size_t bufferLength,
     size_t inputChannelCount)
     : AudioNode(context),
       buffRealLength_(bufferLength * sizeof(float)),
       bufferLength_(bufferLength),
-      workletRunner_(context->workletRunner_),
+      workletRunner_(runtime),
       shareableWorklet_(worklet),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
@@ -57,7 +58,7 @@ void WorkletNode::processNode(
     if (curBuffIndex_ == bufferLength_) {
       // Reset buffer index, channel buffers and execute worklet
       curBuffIndex_ = 0;
-      workletRunner_->executeOnRuntimeGuardedSync(
+      workletRunner_.executeOnRuntimeGuardedSync(
           [this, channelCount_](jsi::Runtime &uiRuntimeRaw) {
             /// Arguments preparation
             auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
@@ -73,7 +74,7 @@ void WorkletNode::processNode(
             jsArray.setExternalMemoryPressure(
                 uiRuntimeRaw, channelCount_ * buffRealLength_);
 
-            workletRunner_->executeWorklet(
+            workletRunner_.executeWorklet(
                 shareableWorklet_,
                 std::move(jsArray),
                 jsi::Value(uiRuntimeRaw, static_cast<int>(channelCount_)));

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

@@ -2,7 +2,7 @@
 
 
 #include <jsi/jsi.h>
-#include <audioapi/core/utils/worklets/UiWorkletsRunner.h>
+#include <audioapi/core/utils/worklets/WorkletsRunner.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/utils/AudioBus.h>
@@ -20,10 +20,10 @@ class WorkletNode : public AudioNode {
   explicit WorkletNode(
       BaseAudioContext *context,
       std::shared_ptr<worklets::SerializableWorklet> &worklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
       size_t bufferLength,
       size_t inputChannelCount
   ) : AudioNode(context) {}
-  ~WorkletNode() override = default;
 
  protected:
   void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override {}
@@ -37,6 +37,7 @@ class WorkletNode : public AudioNode {
   explicit WorkletNode(
       BaseAudioContext *context,
       std::shared_ptr<worklets::SerializableWorklet> &worklet,
+      std::weak_ptr<worklets::WorkletRuntime> runtime,
       size_t bufferLength,
       size_t inputChannelCount
   );
@@ -48,7 +49,7 @@ class WorkletNode : public AudioNode {
 
 
  private:
-  std::shared_ptr<UiWorkletsRunner> workletRunner_;
+  WorkletsRunner workletRunner_;
   std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
   std::vector<uint8_t*> buffs_;