software-mansion · maciejmakowski2003 · Feb 2, 2026 · Feb 2, 2026 · Feb 2, 2026 · Feb 2, 2026
diff --git a/apps/common-app/src/examples/Streaming/Streaming.tsx b/apps/common-app/src/examples/Streaming/Streaming.tsx
@@ -30,11 +30,8 @@ const Streaming: FC = () => {
       console.error('StreamerNode is already initialized');
       return;
     }
-    streamerRef.current = aCtxRef.current.createStreamer();
+    streamerRef.current = aCtxRef.current.createStreamer('https://liveradio.timesa.pl/2980-1.aac/playlist.m3u8');
 
-    streamerRef.current.initialize(
-      'https://liveradio.timesa.pl/2980-1.aac/playlist.m3u8'
-    );
     streamerRef.current.connect(gainRef.current);
     gainRef.current.connect(aCtxRef.current.destination);
     streamerRef.current.start(aCtxRef.current.currentTime);

diff --git a/packages/audiodocs/docs/guides/create-your-own-effect.mdx b/packages/audiodocs/docs/guides/create-your-own-effect.mdx
@@ -77,7 +77,7 @@ namespace audioapi {
     MyProcessorNode::MyProcessorNode(const std::shared_ptr<BaseAudioContext> &context)
         //highlight-next-line
         : AudioNode(context), gain(0.5) {
-        isInitialized_ = true;
+        isInitialized_.store(true, std::memory_order_release);
     }
 
     std::shared_ptr<AudioBuffer> MyProcessorNode::processNode(const std::shared_ptr<AudioBuffer> &buffer,

diff --git a/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.cpp b/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.cpp
@@ -5,7 +5,7 @@ namespace audioapi {
 MyProcessorNode::MyProcessorNode(
     const std::shared_ptr<BaseAudioContext> &context, )
     : AudioNode(context) {
-  isInitialized_ = true;
+  isInitialized_.store(true, std::memory_order_release);
 }
 
 std::shared_ptr<AudioBuffer>

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -8,7 +8,13 @@
 namespace audioapi {
 
 AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node,
-                                         const AudioNodeOptions &options) : node_(node) {
+                                         const AudioNodeOptions &options)
+    : node_(node),
+      numberOfInputs_(options.numberOfInputs),
+      numberOfOutputs_(options.numberOfOutputs),
+      channelCount_(options.channelCount),
+      channelCountMode_(options.channelCountMode),
+      channelInterpretation_(options.channelInterpretation) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfInputs),
       JSI_EXPORT_PROPERTY_GETTER(AudioNodeHostObject, numberOfOutputs),
@@ -28,23 +34,23 @@ AudioNodeHostObject::AudioNodeHostObject(const std::shared_ptr<AudioNode> &node,
 AudioNodeHostObject::~AudioNodeHostObject() = default;
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, numberOfInputs) {
-  return {node_->getNumberOfInputs()};
+  return {numberOfInputs_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, numberOfOutputs) {
-  return {node_->getNumberOfOutputs()};
+  return {numberOfOutputs_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCount) {
-  return {static_cast<int>(node_->getChannelCount())};
+  return {static_cast<int>(channelCount_)};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelCountMode) {
-  return jsi::String::createFromUtf8(runtime, js_enum_parser::channelCountModeToString(node_->getChannelCountMode()));
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
-  return jsi::String::createFromUtf8(runtime, js_enum_parser::channelInterpretationToString(node_->getChannelInterpretation()));
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/types/ChannelCountMode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/jsi/JsiHostObject.h>
 #include <audioapi/types/NodeOptions.h>
 
@@ -30,5 +32,11 @@ class AudioNodeHostObject : public JsiHostObject {
 
  protected:
   std::shared_ptr<AudioNode> node_;
+
+  const int numberOfInputs_;
+  const int numberOfOutputs_;
+  size_t channelCount_;
+  const ChannelCountMode channelCountMode_;
+  const ChannelInterpretation channelInterpretation_;
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
@@ -9,7 +9,7 @@
 namespace audioapi {
 
 AudioParamHostObject::AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
-    : param_(param) {
+    : param_(param), defaultValue_(param->getDefaultValue()), minValue_(param->getMinValue()), maxValue_(param->getMaxValue()) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
@@ -33,47 +33,58 @@ JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, value) {
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, defaultValue) {
-  return {param_->getDefaultValue()};
+  return {defaultValue_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, minValue) {
-  return {param_->getMinValue()};
+  return {minValue_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, maxValue) {
-  return {param_->getMaxValue()};
+  return {maxValue_};
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioParamHostObject, value) {
-  param_->setValue(static_cast<float>(value.getNumber()));
+    auto event = [param = param_, value = static_cast<float>(value.getNumber())](BaseAudioContext &) {
+        param->setValue(value);
+    };
+
+    param_->scheduleAudioEvent(std::move(event));
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueAtTime) {
-  auto value = static_cast<float>(args[0].getNumber());
-  double startTime = args[1].getNumber();
-  param_->setValueAtTime(value, startTime);
+    auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), startTime = args[1].getNumber()](BaseAudioContext &) {
+        param->setValueAtTime(value, startTime);
+    };
+
+    param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, linearRampToValueAtTime) {
-  auto value = static_cast<float>(args[0].getNumber());
-  double endTime = args[1].getNumber();
-  param_->linearRampToValueAtTime(value, endTime);
+    auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), endTime = args[1].getNumber()](BaseAudioContext &) {
+        param->linearRampToValueAtTime(value, endTime);
+    };
+
+    param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, exponentialRampToValueAtTime) {
-  auto value = static_cast<float>(args[0].getNumber());
-  double endTime = args[1].getNumber();
-  param_->exponentialRampToValueAtTime(value, endTime);
+    auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), endTime = args[1].getNumber()](BaseAudioContext &) {
+        param->exponentialRampToValueAtTime(value, endTime);
+    };
+
+    param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setTargetAtTime) {
-  auto target = static_cast<float>(args[0].getNumber());
-  double startTime = args[1].getNumber();
-  double timeConstant = args[2].getNumber();
-  param_->setTargetAtTime(target, startTime, timeConstant);
+    auto event = [param = param_, target = static_cast<float>(args[0].getNumber()), startTime = args[1].getNumber(), timeConstant = args[2].getNumber()](BaseAudioContext &) {
+        param->setTargetAtTime(target, startTime, timeConstant);
+    };
+
+    param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
@@ -82,23 +93,31 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueCurveAtTime) {
       args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto rawValues = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime));
-  auto values = std::make_unique<AudioArray>(rawValues, length);
+  auto values = std::make_shared<AudioArray>(rawValues, length);
+
+    auto event = [param = param_, values, length, startTime = args[1].getNumber(), duration = args[2].getNumber()](BaseAudioContext &) {
+        param->setValueCurveAtTime(values, length, startTime, duration);
+    };
 
-  double startTime = args[1].getNumber();
-  double duration = args[2].getNumber();
-  param_->setValueCurveAtTime(std::move(values), length, startTime, duration);
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelScheduledValues) {
-  double cancelTime = args[0].getNumber();
-  param_->cancelScheduledValues(cancelTime);
+  auto event = [param = param_, cancelTime = args[0].getNumber()](BaseAudioContext &) {
+    param->cancelScheduledValues(cancelTime);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelAndHoldAtTime) {
-  double cancelTime = args[0].getNumber();
-  param_->cancelAndHoldAtTime(cancelTime);
+  auto event = [param = param_, cancelTime = args[0].getNumber()](BaseAudioContext &) {
+    param->cancelAndHoldAtTime(cancelTime);
+  };
+
+  param_->scheduleAudioEvent(std::move(event));
   return jsi::Value::undefined();
 }
 

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
@@ -36,5 +36,8 @@ class AudioParamHostObject : public JsiHostObject {
   friend class AudioNodeHostObject;
 
   std::shared_ptr<AudioParam> param_;
+  float defaultValue_;
+  float minValue_;
+  float maxValue_;
 };
 } // namespace audioapi
diff --git a/...eact-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp b/...eact-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp
@@ -5,14 +5,19 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 
 #include <memory>
+#include <utility>
 
 namespace audioapi {
 
 AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<BaseAudioContext>& context, const AnalyserOptions &options)
-    : AudioNodeHostObject(context->createAnalyser(options), options) {
+    : AudioNodeHostObject(context->createAnalyser(options), options),
+      fftSize_(options.fftSize),
+      minDecibels_(options.minDecibels),
+      maxDecibels_(options.maxDecibels),
+      smoothingTimeConstant_(options.smoothingTimeConstant),
+      windowType_(options.windowType) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
-      JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, maxDecibels),
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant),
@@ -33,64 +38,74 @@ AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<BaseAudioCo
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, fftSize) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  return {static_cast<int>(analyserNode->getFftSize())};
-}
-
-JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, frequencyBinCount) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  return {static_cast<int>(analyserNode->getFrequencyBinCount())};
+  return {fftSize_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, minDecibels) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  return {analyserNode->getMinDecibels()};
+  return {minDecibels_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, maxDecibels) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  return {analyserNode->getMaxDecibels()};
+  return {maxDecibels_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  return {analyserNode->getSmoothingTimeConstant()};
+  return {smoothingTimeConstant_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, window) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  auto windowType = analyserNode->getWindowType();
-  return jsi::String::createFromUtf8(runtime, js_enum_parser::windowTypeToString(windowType));
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::windowTypeToString(windowType_));
 }
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, fftSize) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+
   auto fftSize = static_cast<int>(value.getNumber());
-  analyserNode->setFftSize(fftSize);
+  auto event = [analyserNode, fftSize](BaseAudioContext&) {
+    analyserNode->setFftSize(fftSize);
+  };
+  analyserNode->scheduleAudioEvent(std::move(event));
+  fftSize_ = fftSize;
 }
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, minDecibels) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
   auto minDecibels = static_cast<float>(value.getNumber());
-  analyserNode->setMinDecibels(minDecibels);
+  auto event = [analyserNode, minDecibels](BaseAudioContext&) {
+    analyserNode->setMinDecibels(minDecibels);
+  };
+    analyserNode->scheduleAudioEvent(std::move(event));
+    minDecibels_ = minDecibels;
 }
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, maxDecibels) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
   auto maxDecibels = static_cast<float>(value.getNumber());
-  analyserNode->setMaxDecibels(maxDecibels);
+  auto event = [analyserNode, maxDecibels](BaseAudioContext&) {
+    analyserNode->setMaxDecibels(maxDecibels);
+  };
+    analyserNode->scheduleAudioEvent(std::move(event));
+    maxDecibels_ = maxDecibels;
 }
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
   auto smoothingTimeConstant = static_cast<float>(value.getNumber());
-  analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
+    auto event = [analyserNode, smoothingTimeConstant](BaseAudioContext&) {
+        analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
+    };
+        analyserNode->scheduleAudioEvent(std::move(event));
+        smoothingTimeConstant_ = smoothingTimeConstant;
 }
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, window) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  auto type = value.asString(runtime).utf8(runtime);
-  analyserNode->setWindowType(js_enum_parser::windowTypeFromString(type));
+  auto windowType = js_enum_parser::windowTypeFromString(value.asString(runtime).utf8(runtime));
+  auto event = [analyserNode, windowType](BaseAudioContext&) {
+    analyserNode->setWindowType(windowType);
+  };
+  analyserNode->scheduleAudioEvent(std::move(event));
+  windowType_ = windowType;
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {

diff --git a/.../react-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.h b/.../react-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.h
@@ -1,10 +1,10 @@
 #pragma once
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/types/WindowType.h>
 
 #include <memory>
 #include <string>
-#include <vector>
 
 namespace audioapi {
 using namespace facebook;
@@ -19,7 +19,6 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
       const AnalyserOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(fftSize);
-  JSI_PROPERTY_GETTER_DECL(frequencyBinCount);
   JSI_PROPERTY_GETTER_DECL(minDecibels);
   JSI_PROPERTY_GETTER_DECL(maxDecibels);
   JSI_PROPERTY_GETTER_DECL(smoothingTimeConstant);
@@ -35,6 +34,13 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
   JSI_HOST_FUNCTION_DECL(getByteFrequencyData);
   JSI_HOST_FUNCTION_DECL(getFloatTimeDomainData);
   JSI_HOST_FUNCTION_DECL(getByteTimeDomainData);
+
+ private:
+  int fftSize_;
+  float minDecibels_;
+  float maxDecibels_;
+  float smoothingTimeConstant_;
+  WindowType windowType_;
 };
 
 } // namespace audioapi