From 8274a95c4d3dab06d84dfdfe9eec32730ffb6ef6 Mon Sep 17 00:00:00 2001
From: poneciak <poneciak@gmail.com>
Date: Thu, 19 Mar 2026 12:54:37 +0100
Subject: [PATCH 01/38] feat: added base GraphObject

---
 .../common/cpp/audioapi/core/AudioNode.h      | 13 ++-
 .../common/cpp/audioapi/core/AudioParam.h     | 16 +++-
 .../audioapi/core/utils/graph/AudioGraph.hpp  | 66 ++++++---------
 .../cpp/audioapi/core/utils/graph/Graph.hpp   | 44 +++++-----
 .../audioapi/core/utils/graph/GraphObject.hpp | 54 +++++++++++++
 .../audioapi/core/utils/graph/HostGraph.hpp   | 57 +++++--------
 .../audioapi/core/utils/graph/HostNode.hpp    | 31 ++++---
 .../audioapi/core/utils/graph/NodeHandle.hpp  |  9 ++-
 .../cpp/test/src/graph/AudioGraphFuzzTest.cpp | 16 ++--
 .../cpp/test/src/graph/AudioGraphTest.cpp     | 25 +++---
 .../test/src/graph/GraphCycleDebugTest.cpp    | 13 +--
 .../cpp/test/src/graph/GraphFuzzTest.cpp      | 10 +--
 .../common/cpp/test/src/graph/GraphTest.cpp   | 32 ++++----
 .../cpp/test/src/graph/HostGraphTest.cpp      | 80 +++++++++----------
 .../cpp/test/src/graph/MockGraphProcessor.h   | 28 ++++---
 .../cpp/test/src/graph/TestGraphUtils.cpp     | 33 ++++----
 .../cpp/test/src/graph/TestGraphUtils.h       | 36 ++++++---
 17 files changed, 314 insertions(+), 249 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 8cdc71f34..1346291f7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -4,6 +4,7 @@
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/graph/GraphObject.hpp>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
@@ -18,7 +19,7 @@ namespace audioapi {
 
 class AudioParam;
 
-class AudioNode : public std::enable_shared_from_this<AudioNode> {
+class AudioNode : public utils::graph::GraphObject, public std::enable_shared_from_this<AudioNode> {
  public:
   explicit AudioNode(
       const std::shared_ptr<BaseAudioContext> &context,
@@ -62,7 +63,15 @@ class AudioNode : public std::enable_shared_from_this<AudioNode> {
     return false;
   }
 
-  virtual bool canBeDestructed() const;
+  bool canBeDestructed() const override;
+
+  [[nodiscard]] AudioNode *asAudioNode() override {
+    return this;
+  }
+
+  [[nodiscard]] const AudioNode *asAudioNode() const override {
+    return this;
+  }
 
  protected:
   friend class AudioGraphManager;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
index 932e1a289..ebd875398 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
@@ -5,6 +5,7 @@
 #include <audioapi/core/types/ParamChangeEventType.h>
 #include <audioapi/core/utils/AudioParamEventQueue.h>
 #include <audioapi/core/utils/ParamChangeEvent.hpp>
+#include <audioapi/core/utils/graph/GraphObject.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
@@ -15,7 +16,7 @@
 
 namespace audioapi {
 
-class AudioParam {
+class AudioParam : public utils::graph::GraphObject {
  public:
   explicit AudioParam(
       float defaultValue,
@@ -79,6 +80,19 @@ class AudioParam {
     return false;
   }
 
+  /// @brief Temporary lifecycle policy for GraphObject-based graph storage.
+  [[nodiscard]] bool canBeDestructed() const override {
+    return true;
+  }
+
+  [[nodiscard]] AudioParam *asAudioParam() override {
+    return this;
+  }
+
+  [[nodiscard]] const AudioParam *asAudioParam() const override {
+    return this;
+  }
+
   /// Audio-Thread only methods
   /// These methods are called only from the Audio rendering thread.
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
index 1d56c9322..051ccd6cc 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
@@ -1,12 +1,10 @@
 #pragma once
 
-#include <audioapi/core/AudioNode.h>
 #include <audioapi/core/utils/graph/InputPool.hpp>
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
 
 #include <algorithm>
 #include <cassert>
-#include <concepts>
 #include <cstdint>
 #include <iterator>
 #include <memory>
@@ -16,9 +14,6 @@
 
 namespace audioapi::utils::graph {
 
-template <typename T>
-concept AudioGraphNode = std::derived_from<T, ::audioapi::AudioNode>;
-
 /// @brief Cache-friendly, index-stable node storage with in-place topological sort.
 ///
 /// Nodes are stored in a flat vector that is kept topologically sorted
@@ -26,16 +21,15 @@ concept AudioGraphNode = std::derived_from<T, ::audioapi::AudioNode>;
 /// orphaned nodes and O(1)-extra-space Kahn's toposort.
 ///
 /// @note Can store at most 2^30 nodes due to bit-packed indices (~10^9).
-template <AudioGraphNode NodeType>
 class AudioGraph {
   // ── Node ────────────────────────────────────────────────────────────────
 
   struct Node {
     Node() = default;
-    explicit Node(std::shared_ptr<NodeHandle<NodeType>> handle) : handle(handle) {}
+    explicit Node(std::shared_ptr<NodeHandle> handle) : handle(handle) {}
 
-    std::shared_ptr<NodeHandle<NodeType>> handle = nullptr; // owned handle bridging to HostGraph
-    std::uint32_t input_head = InputPool::kNull;            // head of input linked list in pool_
+    std::shared_ptr<NodeHandle> handle = nullptr; // owned handle bridging to HostGraph
+    std::uint32_t input_head = InputPool::kNull;  // head of input linked list in pool_
 
     std::uint32_t topo_out_degree : 31 = 0; // scratch — Kahn's out-degree counter
     unsigned will_be_deleted : 1 = 0;       // scratch — marked for compaction removal
@@ -60,10 +54,10 @@ class AudioGraph {
   AudioGraph(AudioGraph &&) noexcept = default;
   AudioGraph &operator=(AudioGraph &&) noexcept = default;
 
-  /// @brief Entry returned by iter() — a reference to the audio node and a view of its inputs.
+  /// @brief Entry returned by iter() — a reference to the graph object and a view of its inputs.
   template <typename InputsView>
   struct Entry {
-    NodeType &audioNode;
+    GraphObject &graphObject;
     InputsView inputs;
   };
 
@@ -83,13 +77,13 @@ class AudioGraph {
 
   /// @brief Provides an iterable view of the nodes in topological order.
   ///
-  /// Each entry contains a reference to the AudioNode and an immutable view
-  /// of its inputs (as references to AudioNodes).
+  /// Each entry contains a reference to the GraphObject and an immutable view
+  /// of its inputs (as references to GraphObject).
   ///
   /// ## Example usage:
   /// ```cpp
-  /// for (auto [audioNode, inputs] : graph.iter()) {
-  ///   // process audioNode and its inputs
+  /// for (auto [graphObject, inputs] : graph.iter()) {
+  ///   // process graphObject and its inputs
   /// }
   /// ```
   /// @note Lifetime of entries is bound to this graph — they are not owned.
@@ -115,14 +109,14 @@ class AudioGraph {
 
   /// @brief Adds a new node. AudioGraph takes shared ownership of the handle.
   /// @param handle shared NodeHandle bridging to HostGraph
-  void addNode(std::shared_ptr<NodeHandle<NodeType>> handle);
+  void addNode(std::shared_ptr<NodeHandle> handle);
 
   /// @brief Recomputes topological order (if dirty), then compacts the graph
   /// by removing orphaned, input-free, destructible nodes.
   ///
   /// When a node is compacted out its `shared_ptr<NodeHandle>` is released
   /// (refcount drops 2 → 1). HostGraph detects this via `use_count() == 1`
-  /// and destroys the ghost + AudioNode on the main thread.
+  /// and destroys the ghost + GraphObject on the main thread.
   ///
   /// Uses a two-pass approach: pass 1 marks deletions (cascading in topo
   /// order) and computes index remapping; pass 2 remaps inputs and shifts
@@ -155,68 +149,57 @@ class AudioGraph {
 
 // ── Accessors ─────────────────────────────────────────────────────────────
 
-template <AudioGraphNode NodeType>
-auto AudioGraph<NodeType>::operator[](std::uint32_t index) -> Node & {
+inline auto AudioGraph::operator[](std::uint32_t index) -> Node & {
   return nodes[index];
 }
 
-template <AudioGraphNode NodeType>
-auto AudioGraph<NodeType>::operator[](std::uint32_t index) const -> const Node & {
+inline auto AudioGraph::operator[](std::uint32_t index) const -> const Node & {
   return nodes[index];
 }
 
-template <AudioGraphNode NodeType>
-size_t AudioGraph<NodeType>::size() const {
+inline size_t AudioGraph::size() const {
   return nodes.size();
 }
 
-template <AudioGraphNode NodeType>
-bool AudioGraph<NodeType>::empty() const {
+inline bool AudioGraph::empty() const {
   return nodes.empty();
 }
 
-template <AudioGraphNode NodeType>
-auto AudioGraph<NodeType>::iter() {
+inline auto AudioGraph::iter() {
   return nodes | std::views::transform([this](Node &node) {
            return Entry{
                *node.handle->audioNode,
                pool_.view(node.input_head) |
-                   std::views::transform([this](std::uint32_t idx) -> const NodeType & {
+                   std::views::transform([this](std::uint32_t idx) -> const GraphObject & {
                      return *nodes[idx].handle->audioNode;
                    })};
          });
 }
 
-template <AudioGraphNode NodeType>
-InputPool &AudioGraph<NodeType>::pool() {
+inline InputPool &AudioGraph::pool() {
   return pool_;
 }
 
-template <AudioGraphNode NodeType>
-const InputPool &AudioGraph<NodeType>::pool() const {
+inline const InputPool &AudioGraph::pool() const {
   return pool_;
 }
 
-template <AudioGraphNode NodeType>
-void AudioGraph<NodeType>::reserveNodes(std::uint32_t capacity) {
+inline void AudioGraph::reserveNodes(std::uint32_t capacity) {
   nodes.reserve(capacity);
 }
 
 // ── Mutators ──────────────────────────────────────────────────────────────
 
-template <AudioGraphNode NodeType>
-void AudioGraph<NodeType>::markDirty() {
+inline void AudioGraph::markDirty() {
   topo_order_dirty = true;
 }
 
-template <AudioGraphNode NodeType>
-void AudioGraph<NodeType>::addNode(std::shared_ptr<NodeHandle<NodeType>> handle) {
+inline void AudioGraph::addNode(std::shared_ptr<NodeHandle> handle) {
   handle->index = static_cast<std::uint32_t>(nodes.size());
   nodes.emplace_back(std::move(handle));
 }
 
-template <AudioGraphNode NodeType>
-void AudioGraph<NodeType>::process() {
+inline void AudioGraph::process() {
   if (topo_order_dirty) {
     topo_order_dirty = false;
     kahn_toposort();
@@ -293,8 +276,7 @@ void AudioGraph<NodeType>::process() {
 
 // ── Kahn's toposort ───────────────────────────────────────────────────────
 
-template <AudioGraphNode NodeType>
-void AudioGraph<NodeType>::kahn_toposort() {
+inline void AudioGraph::kahn_toposort() {
   const auto n = static_cast<std::uint32_t>(nodes.size());
   if (n <= 1)
     return;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 269f32476..7df057e96 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -32,9 +32,8 @@ namespace audioapi::utils::graph {
 /// graph.process();             // toposort + compaction
 /// for (auto&& [node, inputs] : graph.iter()) { ... }
 /// ```
-template <AudioGraphNode NodeType>
 class Graph {
-  using AGEvent = HostGraph<NodeType>::AGEvent;
+  using AGEvent = HostGraph::AGEvent;
 
   // ── Event channel (main → audio): grow + graph mutations ───────────────
 
@@ -47,10 +46,10 @@ class Graph {
       audioapi::channels::spsc::OverflowStrategy::WAIT_ON_FULL,
       audioapi::channels::spsc::WaitStrategy::BUSY_LOOP>;
 
-  using HNode = HostGraph<NodeType>::Node;
+  using HNode = HostGraph::Node;
 
  public:
-  using ResultError = HostGraph<NodeType>::ResultError;
+  using ResultError = HostGraph::ResultError;
   using Res = Result<NoneType, ResultError>;
 
   explicit Graph(size_t eventQueueCapacity) {
@@ -106,8 +105,8 @@ class Graph {
 
   /// @brief Returns an iterable view of nodes in topological order.
   ///
-  /// Each entry contains a reference to the NodeType and an immutable view
-  /// of its inputs (as references to NodeType).
+  /// Each entry contains a reference to GraphObject and an immutable view
+  /// of its inputs (as references to GraphObject).
   /// Allocation-free.
   ///
   /// @note Should be called only from the audio thread, after process().
@@ -120,10 +119,10 @@ class Graph {
   /// @brief Adds a new node to the graph and returns a pointer to it.
   /// @param audioNode the audio processing node to add (ownership transferred)
   /// @return pointer to the newly added HostGraph::Node
-  HNode *addNode(std::unique_ptr<NodeType> audioNode = nullptr) {
+  HNode *addNode(std::unique_ptr<GraphObject> audioNode = nullptr) {
     hostGraph.collectDisposedNodes();
 
-    auto handle = std::make_shared<NodeHandle<NodeType>>(0, std::move(audioNode));
+    auto handle = std::make_shared<NodeHandle>(0, std::move(audioNode));
     auto [hostNode, event] = hostGraph.addNode(handle);
 
     sendNodeGrowIfNeeded();
@@ -132,6 +131,11 @@ class Graph {
     return hostNode;
   }
 
+  template <typename TObject, typename = std::enable_if_t<std::derived_from<TObject, GraphObject>>>
+  HNode *addNode(std::unique_ptr<TObject> audioNode) {
+    return addNode(std::unique_ptr<GraphObject>(std::move(audioNode)));
+  }
+
   /// @brief Removes a node (marks as ghost). Pointer remains valid until
   /// the ghost is collected after AudioGraph releases its shared_ptr.
   Res removeNode(HNode *node) {
@@ -162,13 +166,13 @@ class Graph {
   }
 
  private:
-  static constexpr size_t kDisposerPayloadSize = HostGraph<NodeType>::kDisposerPayloadSize;
+  static constexpr size_t kDisposerPayloadSize = HostGraph::kDisposerPayloadSize;
 
   using OwnedSlotBuffer = std::unique_ptr<InputPool::Slot[]>;
 
   // Aligning to cache line size to prevent false sharing between audio and main thread
-  alignas(hardware_destructive_interference_size) AudioGraph<NodeType> audioGraph;
-  alignas(hardware_destructive_interference_size) HostGraph<NodeType> hostGraph;
+  alignas(hardware_destructive_interference_size) AudioGraph audioGraph;
+  alignas(hardware_destructive_interference_size) HostGraph hostGraph;
 
   // ── Channel (immutable after construction — no false sharing) ───────────
 
@@ -196,14 +200,13 @@ class Graph {
     if (edges > poolCapacity_ / 2) {
       std::uint32_t newCap = std::max(static_cast<std::uint32_t>(edges * 2), std::uint32_t{64});
       auto buf = std::make_unique<InputPool::Slot[]>(newCap);
-      eventSender_.send(
-          [buf = std::move(buf), newCap](
-              AudioGraph<NodeType> &graph, Disposer<kDisposerPayloadSize> &disposer) mutable {
-            auto *old = graph.pool().adoptBuffer(buf.release(), newCap);
-            if (old) {
-              disposer.dispose(OwnedSlotBuffer(old));
-            }
-          });
+      eventSender_.send([buf = std::move(buf), newCap](
+                            AudioGraph &graph, Disposer<kDisposerPayloadSize> &disposer) mutable {
+        auto *old = graph.pool().adoptBuffer(buf.release(), newCap);
+        if (old) {
+          disposer.dispose(OwnedSlotBuffer(old));
+        }
+      });
       poolCapacity_ = newCap;
     }
   }
@@ -215,8 +218,7 @@ class Graph {
     auto nodes = static_cast<std::uint32_t>(hostGraph.nodeCount());
     if (nodes > nodeCapacity_) {
       std::uint32_t newCap = std::max(static_cast<std::uint32_t>(nodes * 2), std::uint32_t{64});
-      eventSender_.send(
-          [newCap](AudioGraph<NodeType> &graph, auto &) { graph.reserveNodes(newCap); });
+      eventSender_.send([newCap](AudioGraph &graph, auto &) { graph.reserveNodes(newCap); });
       nodeCapacity_ = newCap;
     }
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
new file mode 100644
index 000000000..e348c26dd
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+namespace audioapi {
+class AudioNode;
+class AudioParam;
+} // namespace audioapi
+
+namespace audioapi::utils::graph {
+
+/// @brief Base class for graph objects (AudioNode or AudioParam).
+/// GraphObjects are owned by NodeHandles and stored in AudioGraph's flat vector
+///
+/// ## Lifecycle
+/// - Created on the main thread as a unique_ptr
+/// - Transferred to AudioGraph via NodeHandle on node addition
+/// - Accessed on the audio thread during processing (e.g. for processAudio)
+/// - Destroyed when all below conditions are met:
+///   1. The HostNode is removed and the NodeHandle is marked as a ghost
+///   2. The Node has no inputs
+///   3. canBeDestructed() returns true (e.g. AudioNode-specific lifecycle checks)
+class GraphObject {
+ public:
+  virtual ~GraphObject() = default;
+
+  /// @brief Returns whether this graph object can be safely destroyed.
+  ///
+  /// Default behavior is permissive for new GraphObject-based entities.
+  /// AudioNode / AudioParam can override with richer lifecycle checks.
+  [[nodiscard]] virtual bool canBeDestructed() const {
+    return true;
+  }
+
+  /// @brief Downcast helper for node-specific handling.
+  [[nodiscard]] virtual AudioNode *asAudioNode() {
+    return nullptr;
+  }
+
+  /// @brief Downcast helper for node-specific handling.
+  [[nodiscard]] virtual const AudioNode *asAudioNode() const {
+    return nullptr;
+  }
+
+  /// @brief Downcast helper for param-specific handling.
+  [[nodiscard]] virtual AudioParam *asAudioParam() {
+    return nullptr;
+  }
+
+  /// @brief Downcast helper for param-specific handling.
+  [[nodiscard]] virtual const AudioParam *asAudioParam() const {
+    return nullptr;
+  }
+};
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
index c785248a5..fc9161cf1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
@@ -15,9 +15,7 @@ class GraphCycleDebugTest;
 
 namespace audioapi::utils::graph {
 
-template <AudioGraphNode NodeType>
 class HostGraph;
-template <AudioGraphNode NodeType>
 class Graph;
 class TestGraphUtils;
 
@@ -33,7 +31,6 @@ class TestGraphUtils;
 /// shared_ptr (detected via `use_count() == 1`).
 ///
 /// @note Use through the Graph wrapper for safety.
-template <AudioGraphNode NodeType>
 class HostGraph {
  public:
   enum class ResultError {
@@ -48,7 +45,7 @@ class HostGraph {
 
   /// Event that modifies AudioGraph to keep it consistent with HostGraph.
   /// The second argument is the Disposer used to offload buffer deallocation.
-  using AGEvent = FatFunction<32, void(AudioGraph<NodeType> &, Disposer<kDisposerPayloadSize> &)>;
+  using AGEvent = FatFunction<32, void(AudioGraph &, Disposer<kDisposerPayloadSize> &)>;
 
   using Res = Result<AGEvent, ResultError>;
 
@@ -65,7 +62,7 @@ class HostGraph {
     std::vector<Node *> inputs;  // reversed edges
     std::vector<Node *> outputs; // forward edges
     TraversalState traversalState;
-    std::shared_ptr<NodeHandle<NodeType>> handle; // shared handle bridging to AudioGraph
+    std::shared_ptr<NodeHandle> handle; // shared handle bridging to AudioGraph
     bool ghost = false; // kept for cycle detection until AudioGraph confirms deletion
 
 #if RN_AUDIO_API_TEST
@@ -92,7 +89,7 @@ class HostGraph {
   /// @brief Adds a new node to the graph.
   /// @param handle shared handle that bridges HostGraph ↔ AudioGraph
   /// @return pair of (raw Node pointer, AGEvent to replay on AudioGraph)
-  std::pair<Node *, AGEvent> addNode(std::shared_ptr<NodeHandle<NodeType>> handle);
+  std::pair<Node *, AGEvent> addNode(std::shared_ptr<NodeHandle> handle);
 
   /// @brief Removes a node (marks it as ghost, keeps edges for cycle detection).
   /// @return AGEvent that sets `orphaned = true` on the AudioGraph side.
@@ -124,7 +121,7 @@ class HostGraph {
   /// `use_count() == 1`, meaning AudioGraph has released its reference.
   void collectDisposedNodes();
 
-  friend class Graph<NodeType>;
+  friend class Graph;
   friend class TestGraphUtils;
   friend class HostGraphTest;
   friend class GraphCycleDebugTest;
@@ -134,8 +131,7 @@ class HostGraph {
 // Implementation
 // =========================================================================
 
-template <AudioGraphNode NodeType>
-bool HostGraph<NodeType>::TraversalState::visit(size_t currentTerm) {
+inline bool HostGraph::TraversalState::visit(size_t currentTerm) {
   if (term == currentTerm) {
     return false;
   }
@@ -143,8 +139,7 @@ bool HostGraph<NodeType>::TraversalState::visit(size_t currentTerm) {
   return true;
 }
 
-template <AudioGraphNode NodeType>
-HostGraph<NodeType>::Node::~Node() {
+inline HostGraph::Node::~Node() {
   for (Node *input : inputs) {
     auto &outs = input->outputs;
     outs.erase(std::remove(outs.begin(), outs.end(), this), outs.end());
@@ -157,23 +152,20 @@ HostGraph<NodeType>::Node::~Node() {
 
 // ── Lifecycle ─────────────────────────────────────────────────────────────
 
-template <AudioGraphNode NodeType>
-HostGraph<NodeType>::~HostGraph() {
+inline HostGraph::~HostGraph() {
   for (Node *n : nodes) {
     delete n;
   }
   nodes.clear();
 }
 
-template <AudioGraphNode NodeType>
-HostGraph<NodeType>::HostGraph(HostGraph &&other) noexcept
+inline HostGraph::HostGraph(HostGraph &&other) noexcept
     : nodes(std::move(other.nodes)), edgeCount_(other.edgeCount_), last_term(other.last_term) {
   other.edgeCount_ = 0;
   other.last_term = 0;
 }
 
-template <AudioGraphNode NodeType>
-auto HostGraph<NodeType>::operator=(HostGraph &&other) noexcept -> HostGraph & {
+inline auto HostGraph::operator=(HostGraph &&other) noexcept -> HostGraph & {
   if (this != &other) {
     for (Node *n : nodes) {
       delete n;
@@ -187,9 +179,7 @@ auto HostGraph<NodeType>::operator=(HostGraph &&other) noexcept -> HostGraph & {
   return *this;
 }
 
-template <AudioGraphNode NodeType>
-auto HostGraph<NodeType>::addNode(std::shared_ptr<NodeHandle<NodeType>> handle)
-    -> std::pair<Node *, AGEvent> {
+inline auto HostGraph::addNode(std::shared_ptr<NodeHandle> handle) -> std::pair<Node *, AGEvent> {
   Node *newNode = new Node();
   newNode->handle = handle;
   nodes.push_back(newNode);
@@ -201,8 +191,7 @@ auto HostGraph<NodeType>::addNode(std::shared_ptr<NodeHandle<NodeType>> handle)
   return {newNode, std::move(event)};
 }
 
-template <AudioGraphNode NodeType>
-auto HostGraph<NodeType>::removeNode(Node *node) -> Res {
+inline auto HostGraph::removeNode(Node *node) -> Res {
   auto it = std::find(nodes.begin(), nodes.end(), node);
   if (it == nodes.end()) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
@@ -211,11 +200,10 @@ auto HostGraph<NodeType>::removeNode(Node *node) -> Res {
   node->ghost = true;
 
   return Res::Ok(
-      [h = node->handle](AudioGraph<NodeType> &graph, auto &) { graph[h->index].orphaned = true; });
+      [h = node->handle](AudioGraph &graph, auto &) { graph[h->index].orphaned = true; });
 }
 
-template <AudioGraphNode NodeType>
-auto HostGraph<NodeType>::addEdge(Node *from, Node *to) -> Res {
+inline auto HostGraph::addEdge(Node *from, Node *to) -> Res {
   if (std::find(nodes.begin(), nodes.end(), from) == nodes.end() ||
       std::find(nodes.begin(), nodes.end(), to) == nodes.end()) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
@@ -237,14 +225,13 @@ auto HostGraph<NodeType>::addEdge(Node *from, Node *to) -> Res {
   to->inputs.push_back(from);
   edgeCount_++;
 
-  return Res::Ok([hFrom = from->handle, hTo = to->handle](AudioGraph<NodeType> &graph, auto &) {
+  return Res::Ok([hFrom = from->handle, hTo = to->handle](AudioGraph &graph, auto &) {
     graph.pool().push(graph[hTo->index].input_head, hFrom->index);
     graph.markDirty();
   });
 }
 
-template <AudioGraphNode NodeType>
-auto HostGraph<NodeType>::removeEdge(Node *from, Node *to) -> Res {
+inline auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
   if (std::find(nodes.begin(), nodes.end(), from) == nodes.end() ||
       std::find(nodes.begin(), nodes.end(), to) == nodes.end()) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
@@ -265,14 +252,13 @@ auto HostGraph<NodeType>::removeEdge(Node *from, Node *to) -> Res {
   from->outputs.erase(itOut);
   edgeCount_--;
 
-  return Res::Ok([hFrom = from->handle, hTo = to->handle](AudioGraph<NodeType> &graph, auto &) {
+  return Res::Ok([hFrom = from->handle, hTo = to->handle](AudioGraph &graph, auto &) {
     graph.pool().remove(graph[hTo->index].input_head, hFrom->index);
     graph.markDirty();
   });
 }
 
-template <AudioGraphNode NodeType>
-bool HostGraph<NodeType>::hasPath(Node *start, Node *end) {
+inline bool HostGraph::hasPath(Node *start, Node *end) {
   if (start == end) {
     return true;
   }
@@ -301,18 +287,15 @@ bool HostGraph<NodeType>::hasPath(Node *start, Node *end) {
   return false;
 }
 
-template <AudioGraphNode NodeType>
-size_t HostGraph<NodeType>::edgeCount() const {
+inline size_t HostGraph::edgeCount() const {
   return edgeCount_;
 }
 
-template <AudioGraphNode NodeType>
-size_t HostGraph<NodeType>::nodeCount() const {
+inline size_t HostGraph::nodeCount() const {
   return nodes.size();
 }
 
-template <AudioGraphNode NodeType>
-void HostGraph<NodeType>::collectDisposedNodes() {
+inline void HostGraph::collectDisposedNodes() {
   for (auto it = nodes.begin(); it != nodes.end();) {
     Node *n = *it;
     if (n->ghost && n->handle.use_count() == 1) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
index e591ac848..84f6d392a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
@@ -2,6 +2,7 @@
 
 #include <audioapi/core/utils/graph/Graph.hpp>
 
+#include <concepts>
 #include <memory>
 #include <utility>
 
@@ -9,13 +10,13 @@ namespace audioapi::utils::graph {
 
 /// @brief RAII base class for host-side nodes.
 ///
-/// Holds a `shared_ptr<Graph<NodeType>>` to keep the graph alive and owns a
+/// Holds a `shared_ptr<Graph>` to keep the graph alive and owns a
 /// `HostGraph::Node*` managed by that graph. On construction the node is
 /// registered in the graph (and an event is sent to AudioGraph); on
 /// destruction the node is removed (scheduling orphan-marking on AudioGraph).
 ///
 /// Host objects that represent audio processing nodes should publicly inherit
-/// from HostNode and pass their payload (the AudioNode-like object) to the
+/// from HostNode and pass their payload (GraphObject-derived object) to the
 /// constructor. `connect` / `disconnect` provide edge management.
 ///
 /// @note HostNode intentionally does NOT prevent cycles — callers must handle
@@ -23,9 +24,9 @@ namespace audioapi::utils::graph {
 ///
 /// ## Example usage:
 /// ```cpp
-/// class MyGainNode : public HostNode<AudioNode> {
+/// class MyGainNode : public HostNode {
 ///  public:
-///   MyGainNode(std::shared_ptr<Graph<AudioNode>> g,
+///   MyGainNode(std::shared_ptr<Graph> g,
 ///              std::unique_ptr<AudioNode> impl)
 ///       : HostNode(std::move(g), std::move(impl)) {}
 /// };
@@ -34,21 +35,27 @@ namespace audioapi::utils::graph {
 /// gain->connect(*destination);
 /// gain.reset(); // destructor removes the node from the graph
 /// ```
-template <AudioGraphNode NodeType>
 class HostNode {
  public:
-  using GraphType = Graph<NodeType>;
-  using HNode = HostGraph<NodeType>::Node;
-  using ResultError = HostGraph<NodeType>::ResultError;
+  using GraphType = Graph;
+  using HNode = HostGraph::Node;
+  using ResultError = HostGraph::ResultError;
   using Res = Result<NoneType, ResultError>;
 
   /// @brief Constructs a HostNode, adding it to the graph.
   /// @param graph shared ownership of the Graph — prevents the graph from
   ///              being destroyed while any HostNode still references it
-  /// @param audioNode the audio processing payload (ownership transferred
-  ///                  through to AudioGraph via NodeHandle)
-  explicit HostNode(std::shared_ptr<GraphType> graph, std::unique_ptr<NodeType> audioNode = nullptr)
-      : graph_(std::move(graph)), node_(graph_->addNode(std::move(audioNode))) {}
+  /// @param graphObject the payload (ownership transferred through to
+  ///                    AudioGraph via NodeHandle)
+  explicit HostNode(
+      std::shared_ptr<GraphType> graph,
+      std::unique_ptr<GraphObject> graphObject = nullptr)
+      : graph_(std::move(graph)), node_(graph_->addNode(std::move(graphObject))) {}
+
+  template <typename TObject>
+    requires std::derived_from<TObject, GraphObject>
+  explicit HostNode(std::shared_ptr<GraphType> graph, std::unique_ptr<TObject> graphObject)
+      : HostNode(std::move(graph), std::unique_ptr<GraphObject>(std::move(graphObject))) {}
 
   /// @brief Destructor removes the node from the graph.
   /// This marks the node as a ghost in HostGraph, and schedules an event
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
index 6765677c5..5c5fc1a1e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/graph/GraphObject.hpp>
+
 #include <cstdint>
 #include <memory>
 #include <utility>
@@ -20,12 +22,11 @@ namespace audioapi::utils::graph {
 /// - When AudioGraph compacts out an orphaned node it releases its shared_ptr
 ///   (refcount 2 → 1). HostGraph detects use_count() == 1 and destroys the
 ///   ghost + payload on the main thread.
-template <typename T>
 struct NodeHandle {
-  std::uint32_t index;          // current position in AudioGraph::nodes
-  std::unique_ptr<T> audioNode; // the payload node (may be null in tests)
+  std::unique_ptr<GraphObject> audioNode; // payload graph object (may be null in tests)
+  std::uint32_t index;                    // current position in AudioGraph::nodes
 
-  NodeHandle(std::uint32_t index, std::unique_ptr<T> audioNode)
+  NodeHandle(std::uint32_t index, std::unique_ptr<GraphObject> audioNode)
       : index(index), audioNode(std::move(audioNode)) {}
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
index 941ca6296..8e679116e 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
@@ -9,6 +9,7 @@
 #include <random>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace audioapi::utils::graph {
@@ -24,11 +25,11 @@ class AudioGraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
  protected:
   using MNode = MockNode;
 
-  AudioGraph<MNode> graph;
+  AudioGraph graph;
   std::mt19937_64 rng;
 
   // Track live handles so we can reference them
-  std::vector<std::shared_ptr<NodeHandle<MNode>>> handles;
+  std::vector<std::shared_ptr<NodeHandle>> handles;
   size_t nextId = 0;
 
   void SetUp() override {
@@ -37,8 +38,9 @@ class AudioGraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
 
   // ── Helpers ─────────────────────────────────────────────────────────────
 
-  std::shared_ptr<NodeHandle<MNode>> doAddNode() {
-    auto h = std::make_shared<NodeHandle<MNode>>(0, std::make_unique<MNode>());
+  std::shared_ptr<NodeHandle> doAddNode() {
+    std::unique_ptr<GraphObject> obj = std::make_unique<MNode>();
+    auto h = std::make_shared<NodeHandle>(0, std::move(obj));
     graph.addNode(h);
     graph[h->index].test_node_identifier__ = nextId++;
     handles.push_back(h);
@@ -52,7 +54,7 @@ class AudioGraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
     // pickLive() will skip it because it checks orphaned status.
   }
 
-  void doAddEdge(std::shared_ptr<NodeHandle<MNode>> &from, std::shared_ptr<NodeHandle<MNode>> &to) {
+  void doAddEdge(std::shared_ptr<NodeHandle> &from, std::shared_ptr<NodeHandle> &to) {
     auto fromIdx = from->index;
     auto toIdx = to->index;
     // Verify at point-of-add that this edge doesn't create a duplicate
@@ -67,9 +69,7 @@ class AudioGraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
     graph.markDirty();
   }
 
-  void doRemoveEdge(
-      std::shared_ptr<NodeHandle<MNode>> &from,
-      std::shared_ptr<NodeHandle<MNode>> &to) {
+  void doRemoveEdge(std::shared_ptr<NodeHandle> &from, std::shared_ptr<NodeHandle> &to) {
     // Same as what HostGraph's removeEdge event does
     graph.pool().remove(graph[to->index].input_head, from->index);
     graph.markDirty();
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
index e99780ed6..e21c32b47 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
@@ -14,26 +14,25 @@ namespace audioapi::utils::graph {
 // ---------------------------------------------------------------------------
 class AudioGraphTest : public ::testing::Test {
  protected:
-  AudioGraph<MockNode> graph;
+  AudioGraph graph;
 
   // Helpers ----------------------------------------------------------------
 
-  /// @brief Creates a shared NodeHandle<MockNode> with no node (for structural tests)
-  std::shared_ptr<NodeHandle<MockNode>> makeHandle(size_t testId = 0) {
-    auto h = std::make_shared<NodeHandle<MockNode>>(0, nullptr);
+  /// @brief Creates a shared NodeHandle with no node (for structural tests)
+  std::shared_ptr<NodeHandle> makeHandle(size_t testId = 0) {
+    auto h = std::make_shared<NodeHandle>(0, nullptr);
     return h;
   }
 
-  /// @brief Creates a shared NodeHandle<MockNode> with a MockNode
-  std::shared_ptr<NodeHandle<MockNode>> makeHandleWithNode(bool destructible = true) {
-    return std::make_shared<NodeHandle<MockNode>>(0, std::make_unique<MockNode>(destructible));
+  /// @brief Creates a shared NodeHandle with a MockNode
+  std::shared_ptr<NodeHandle> makeHandleWithNode(bool destructible = true) {
+    std::unique_ptr<GraphObject> obj = std::make_unique<MockNode>(destructible);
+    return std::make_shared<NodeHandle>(0, std::move(obj));
   }
 
   /// @brief Adds N nodes with test identifiers 0..N-1 and returns their handles
-  std::vector<std::shared_ptr<NodeHandle<MockNode>>> addNodes(
-      size_t n,
-      bool withAudioNode = false) {
-    std::vector<std::shared_ptr<NodeHandle<MockNode>>> handles;
+  std::vector<std::shared_ptr<NodeHandle>> addNodes(size_t n, bool withAudioNode = false) {
+    std::vector<std::shared_ptr<NodeHandle>> handles;
     handles.reserve(n);
     for (size_t i = 0; i < n; i++) {
       auto h = withAudioNode ? makeHandleWithNode() : makeHandle(i);
@@ -293,7 +292,9 @@ TEST_F(AudioGraphTest, Compact_RemovesOnceDestructible) {
   EXPECT_EQ(graph.size(), 2u);
 
   // Now make it destructible
-  h1->audioNode->setDestructible(true);
+  auto *mockNode = dynamic_cast<MockNode *>(h1->audioNode.get());
+  ASSERT_NE(mockNode, nullptr);
+  mockNode->setDestructible(true);
 
   graph.process(); // second pass: node 1 should be removed
   EXPECT_EQ(graph.size(), 1u);
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
index 6c26d867d..5b4d18b53 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
@@ -18,14 +18,14 @@ namespace audioapi::utils::graph {
 class GraphCycleDebugTest : public ::testing::TestWithParam<uint64_t> {
  protected:
   using MNode = MockNode;
-  using HNode = HostGraph<MNode>::Node;
-  using AGEvent = HostGraph<MNode>::AGEvent;
+  using HNode = HostGraph::Node;
+  using AGEvent = HostGraph::AGEvent;
 
-  static constexpr size_t kPayloadSize = HostGraph<MNode>::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
 
   std::mt19937_64 rng;
-  AudioGraph<MNode> audioGraph;
-  HostGraph<MNode> hostGraph;
+  AudioGraph audioGraph;
+  HostGraph hostGraph;
   DisposerImpl<kPayloadSize> disposer_{64};
   std::vector<HNode *> liveNodes;
   size_t nextId = 0;
@@ -37,7 +37,8 @@ class GraphCycleDebugTest : public ::testing::TestWithParam<uint64_t> {
   // ── Helpers ─────────────────────────────────────────────────────────────
 
   HNode *doAddNode() {
-    auto handle = std::make_shared<NodeHandle<MNode>>(0, std::make_unique<MNode>());
+    std::unique_ptr<GraphObject> obj = std::make_unique<MNode>();
+    auto handle = std::make_shared<NodeHandle>(0, std::move(obj));
     auto [hostNode, event] = hostGraph.addNode(handle);
     size_t id = nextId++;
     hostNode->test_node_identifier__ = id;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
index 9e5829f3e..340bcba25 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
@@ -23,12 +23,12 @@ using audioapi::test::MockGraphProcessor;
 class GraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
  protected:
   using PNode = ProcessableMockNode;
-  using HNode = HostGraph<PNode>::Node;
-  using Res = Graph<PNode>::Res;
-  using ResultError = Graph<PNode>::ResultError;
+  using HNode = HostGraph::Node;
+  using Res = Graph::Res;
+  using ResultError = Graph::ResultError;
 
   std::mt19937_64 rng;
-  std::unique_ptr<Graph<PNode>> graph;
+  std::unique_ptr<Graph> graph;
   std::vector<HNode *> nodes; // tracks live (non-removed) nodes
   size_t initialNodeCount;
   size_t operationCount;
@@ -49,7 +49,7 @@ class GraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
     // Ensure graph growth does not happen on the audio thread during this fuzz run.
     const auto maxNodes = static_cast<std::uint32_t>(initialNodeCount + operationCount + 64);
     const auto maxEdges = static_cast<std::uint32_t>(operationCount * 2 + 64);
-    graph = std::make_unique<Graph<PNode>>(4096, maxNodes, maxEdges);
+    graph = std::make_unique<Graph>(4096, maxNodes, maxEdges);
 
     // Randomly partition the range 0..99 into 4 operation weights
     size_t total = 100;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
index 944dd055f..cb0ad3a71 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
@@ -13,17 +13,17 @@ namespace audioapi::utils::graph {
 
 class GraphTest : public ::testing::Test {
  protected:
-  std::unique_ptr<Graph<MockNode>> graph;
+  std::unique_ptr<Graph> graph;
 
   void SetUp() override {
-    graph = std::make_unique<Graph<MockNode>>(4096);
+    graph = std::make_unique<Graph>(4096);
   }
 
-  const AudioGraph<MockNode> &getAudioGraph() {
+  const AudioGraph &getAudioGraph() {
     return graph->audioGraph;
   }
 
-  const HostGraph<MockNode> &getHostGraph() {
+  const HostGraph &getHostGraph() {
     return graph->hostGraph;
   }
 };
@@ -32,7 +32,7 @@ TEST_F(GraphTest, EventsAreScheduledButNotExecutedUntilProcess) {
   auto *node = graph->addNode();
   ASSERT_NE(node, nullptr);
 
-  // AudioGraph<MockNode> should not be aware of the node yet (event not processed)
+  // AudioGraph should not be aware of the node yet (event not processed)
   const auto &ag = getAudioGraph();
 
   size_t sizeBefore = ag.size();
@@ -55,8 +55,7 @@ TEST_F(GraphTest, NoUselessEventsScheduled) {
   const auto &ag = getAudioGraph();
   // Convert to verify
   auto initialAdj = TestGraphUtils::convertAudioGraphToAdjacencyList(
-      const_cast<AudioGraph<MockNode> &>(
-          ag)); // casting const away if utils need it, or verifyutils usage
+      const_cast<AudioGraph &>(ag)); // casting const away if utils need it, or verifyutils usage
 
   // Try adding duplicate edge (should fail and NOT schedule event)
   ASSERT_TRUE(graph->addEdge(node1, node2).is_ok()); // Success first time
@@ -64,19 +63,18 @@ TEST_F(GraphTest, NoUselessEventsScheduled) {
 
   // Result of valid op
   auto intermediateAdj =
-      TestGraphUtils::convertAudioGraphToAdjacencyList(const_cast<AudioGraph<MockNode> &>(ag));
+      TestGraphUtils::convertAudioGraphToAdjacencyList(const_cast<AudioGraph &>(ag));
 
   // Try adding SAME edge (should fail)
   auto result = graph->addEdge(node1, node2);
   EXPECT_TRUE(result.is_err());
-  EXPECT_EQ(result.unwrap_err(), HostGraph<MockNode>::ResultError::EDGE_ALREADY_EXISTS);
+  EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::EDGE_ALREADY_EXISTS);
 
   // Even if we call processEvents, state should not change (and no event should be consumed ideally,
   // impossible to check queue count easily without friend or mock, but state check is good enough)
   graph->processEvents();
 
-  auto finalAdj =
-      TestGraphUtils::convertAudioGraphToAdjacencyList(const_cast<AudioGraph<MockNode> &>(ag));
+  auto finalAdj = TestGraphUtils::convertAudioGraphToAdjacencyList(const_cast<AudioGraph &>(ag));
   EXPECT_EQ(intermediateAdj, finalAdj);
 }
 
@@ -86,7 +84,7 @@ TEST_F(GraphTest, ThreadRaceConcurrency) {
   // One thread processes events (consumer)
 
   std::atomic<bool> running{true};
-  std::vector<HostGraph<MockNode>::Node *> nodes;
+  std::vector<HostGraph::Node *> nodes;
 
   // Add initial nodes
   for (int i = 0; i < 10; ++i) {
@@ -112,7 +110,7 @@ TEST_F(GraphTest, ThreadRaceConcurrency) {
       nodes.push_back(n);
     } else if (op == 1 && nodes.size() > 2) {
       // Add edge
-      HostGraph<MockNode>::Node *n1, *n2;
+      HostGraph::Node *n1, *n2;
       {
         n1 = nodes[rand_r(&seed) % nodes.size()];
         n2 = nodes[rand_r(&seed) % nodes.size()];
@@ -123,7 +121,7 @@ TEST_F(GraphTest, ThreadRaceConcurrency) {
       }
     } else if (op == 2 && nodes.size() > 5) {
       // Remove edge
-      HostGraph<MockNode>::Node *n1, *n2;
+      HostGraph::Node *n1, *n2;
       {
         n1 = nodes[rand_r(&seed) % nodes.size()];
         n2 = nodes[rand_r(&seed) % nodes.size()];
@@ -146,10 +144,8 @@ TEST_F(GraphTest, ThreadRaceConcurrency) {
     const auto &ag = getAudioGraph();
     const auto &hg = getHostGraph();
 
-    auto audioAdj =
-        TestGraphUtils::convertAudioGraphToAdjacencyList(const_cast<AudioGraph<MockNode> &>(ag));
-    auto hostAdj =
-        TestGraphUtils::convertHostGraphToAdjacencyList(const_cast<HostGraph<MockNode> &>(hg));
+    auto audioAdj = TestGraphUtils::convertAudioGraphToAdjacencyList(const_cast<AudioGraph &>(ag));
+    auto hostAdj = TestGraphUtils::convertHostGraphToAdjacencyList(const_cast<HostGraph &>(hg));
 
     // They should match
     EXPECT_EQ(audioAdj, hostAdj);
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
index e796c0003..7dd3c68b6 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
@@ -13,19 +13,19 @@ namespace audioapi::utils::graph {
 
 class HostGraphTest : public ::testing::Test {
  protected:
-  static constexpr size_t kPayloadSize = HostGraph<MockNode>::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
   DisposerImpl<kPayloadSize> disposer_{64};
 
   void verifyAddEdge(
-      HostGraph<MockNode> &hostGraph,
-      AudioGraph<MockNode> &audioGraph,
+      HostGraph &hostGraph,
+      AudioGraph &audioGraph,
       size_t fromId,
       size_t toId,
       const std::vector<std::vector<size_t>> &expectedAdjacencyList) {
     // Find nodes by ID
 
-    HostGraph<MockNode>::Node *fromNode = nullptr;
-    HostGraph<MockNode>::Node *toNode = nullptr;
+    HostGraph::Node *fromNode = nullptr;
+    HostGraph::Node *toNode = nullptr;
 
     for (auto *n : hostGraph.nodes) {
       if (n->test_node_identifier__ == fromId)
@@ -44,26 +44,25 @@ class HostGraphTest : public ::testing::Test {
     auto result = hostGraph.addEdge(fromNode, toNode);
     ASSERT_TRUE(result.is_ok()) << "addEdge failed";
 
-    // Verify AudioGraph<MockNode> UNCHANGED
+    // Verify AudioGraph UNCHANGED
     auto intermediateAudioAdj = TestGraphUtils::convertAudioGraphToAdjacencyList(audioGraph);
-    EXPECT_EQ(initialAudioAdj, intermediateAudioAdj)
-        << "AudioGraph<MockNode> changed before event execution";
+    EXPECT_EQ(initialAudioAdj, intermediateAudioAdj) << "AudioGraph changed before event execution";
 
     // Perform Event
     auto event = std::move(result).unwrap();
     event(audioGraph, disposer_);
 
-    // Verify AudioGraph<MockNode> UPDATED and CONSISTENT
+    // Verify AudioGraph UPDATED and CONSISTENT
     auto finalAudioAdj = TestGraphUtils::convertAudioGraphToAdjacencyList(audioGraph);
     auto finalHostAdj = TestGraphUtils::convertHostGraphToAdjacencyList(hostGraph);
 
     EXPECT_EQ(finalAudioAdj, expectedAdjacencyList)
-        << "AudioGraph<MockNode> does not match expected adjacency list";
+        << "AudioGraph does not match expected adjacency list";
     EXPECT_EQ(finalHostAdj, expectedAdjacencyList)
-        << "HostGraph<MockNode> does not match expected adjacency list";
+        << "HostGraph does not match expected adjacency list";
   }
 
-  HostGraph<MockNode>::Node *findNode(const HostGraph<MockNode> &hostGraph, size_t id) {
+  HostGraph::Node *findNode(const HostGraph &hostGraph, size_t id) {
     for (auto *n : hostGraph.nodes) {
       if (n->test_node_identifier__ == id)
         return n;
@@ -79,19 +78,19 @@ TEST_F(HostGraphTest, AddNode) {
       {}      // 2
   });
 
-  // Create a new handle and add it via HostGraph<MockNode>
-  auto handle = std::make_shared<NodeHandle<MockNode>>(0, nullptr);
+  // Create a new handle and add it via HostGraph
+  auto handle = std::make_shared<NodeHandle>(0, nullptr);
   auto [hostNode, event] = hostGraph.addNode(handle);
 
   EXPECT_EQ(hostNode->handle, handle);
   hostNode->test_node_identifier__ = 3;
 
-  // AudioGraph<MockNode> unchanged before event
+  // AudioGraph unchanged before event
   EXPECT_EQ(audioGraph.size(), 3u);
 
   event(audioGraph, disposer_);
 
-  // After event: node added to AudioGraph<MockNode>
+  // After event: node added to AudioGraph
   EXPECT_EQ(audioGraph.size(), 4u);
   audioGraph[handle->index].test_node_identifier__ = 3;
 
@@ -200,21 +199,21 @@ TEST_F(HostGraphTest, AddEdge_CycleDetection) {
   auto hostAdjBefore = TestGraphUtils::convertHostGraphToAdjacencyList(hostGraph);
   auto audioAdjBefore = TestGraphUtils::convertAudioGraphToAdjacencyList(audioGraph);
 
-  HostGraph<MockNode>::Node *node0 = findNode(hostGraph, 0);
-  HostGraph<MockNode>::Node *node2 = findNode(hostGraph, 2);
+  HostGraph::Node *node0 = findNode(hostGraph, 0);
+  HostGraph::Node *node2 = findNode(hostGraph, 2);
 
   // Try adding cycle 2->0
   auto result = hostGraph.addEdge(node2, node0);
   EXPECT_TRUE(result.is_err());
-  EXPECT_EQ(result.unwrap_err(), HostGraph<MockNode>::ResultError::CYCLE_DETECTED);
+  EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::CYCLE_DETECTED);
 
-  // HostGraph<MockNode> should NOT change
+  // HostGraph should NOT change
   auto hostAdjAfter = TestGraphUtils::convertHostGraphToAdjacencyList(hostGraph);
-  EXPECT_EQ(hostAdjBefore, hostAdjAfter) << "HostGraph<MockNode> modified despite cycle detection";
+  EXPECT_EQ(hostAdjBefore, hostAdjAfter) << "HostGraph modified despite cycle detection";
 
-  // AudioGraph<MockNode> should NOT change (no event executed)
+  // AudioGraph should NOT change (no event executed)
   auto audioAdjAfter = TestGraphUtils::convertAudioGraphToAdjacencyList(audioGraph);
-  EXPECT_EQ(audioAdjBefore, audioAdjAfter) << "AudioGraph<MockNode> modified";
+  EXPECT_EQ(audioAdjBefore, audioAdjAfter) << "AudioGraph modified";
 }
 
 TEST_F(HostGraphTest, AddEdge_LargeSpecificGraph) {
@@ -267,8 +266,8 @@ TEST_F(HostGraphTest, AddEdge_GridInterconnect) {
   // If we try 5->0 -> Cycle (5 reachable from 0)
 
   auto hostAdjBefore = TestGraphUtils::convertHostGraphToAdjacencyList(hostGraph);
-  HostGraph<MockNode>::Node *node5 = findNode(hostGraph, 5);
-  HostGraph<MockNode>::Node *node0 = findNode(hostGraph, 0);
+  HostGraph::Node *node5 = findNode(hostGraph, 5);
+  HostGraph::Node *node0 = findNode(hostGraph, 0);
 
   auto result = hostGraph.addEdge(node5, node0);
   EXPECT_TRUE(result.is_err());
@@ -276,17 +275,17 @@ TEST_F(HostGraphTest, AddEdge_GridInterconnect) {
 }
 
 // ---------------------------------------------------------------------------
-// BUG demonstration: ghost node in AudioGraph<MockNode> causes accepted cycle
+// BUG demonstration: ghost node in AudioGraph causes accepted cycle
 // ---------------------------------------------------------------------------
 //
-// When a node is removed from HostGraph<MockNode> it is deleted immediately (edges torn
-// down, pointer freed).  The corresponding AudioGraph<MockNode> event only marks the
+// When a node is removed from HostGraph it is deleted immediately (edges torn
+// down, pointer freed).  The corresponding AudioGraph event only marks the
 // node as `orphaned` — it stays in the vector with all its edges until
 // compaction eventually removes it.
 //
-// This creates a window where HostGraph<MockNode> no longer "sees" the node, so its
+// This creates a window where HostGraph no longer "sees" the node, so its
 // cycle-detection (hasPath) can miss paths that still exist in AudioGraph.
-// If a new edge is added through that blind-spot, AudioGraph<MockNode> ends up with a
+// If a new edge is added through that blind-spot, AudioGraph ends up with a
 // cycle and toposort produces garbage.
 //
 TEST_F(HostGraphTest, RemoveNode_GhostNodeMustNotAllowCycle) {
@@ -297,32 +296,31 @@ TEST_F(HostGraphTest, RemoveNode_GhostNodeMustNotAllowCycle) {
       {}   // 2
   });
 
-  HostGraph<MockNode>::Node *node0 = findNode(hostGraph, 0);
-  HostGraph<MockNode>::Node *node1 = findNode(hostGraph, 1);
-  HostGraph<MockNode>::Node *node2 = findNode(hostGraph, 2);
+  HostGraph::Node *node0 = findNode(hostGraph, 0);
+  HostGraph::Node *node1 = findNode(hostGraph, 1);
+  HostGraph::Node *node2 = findNode(hostGraph, 2);
   ASSERT_NE(node0, nullptr);
   ASSERT_NE(node1, nullptr);
   ASSERT_NE(node2, nullptr);
 
-  // ── Step 1: remove node 1 from HostGraph<MockNode> ──
+  // ── Step 1: remove node 1 from HostGraph ──
   auto removeResult = hostGraph.removeNode(node1);
   ASSERT_TRUE(removeResult.is_ok());
 
-  // Execute the remove-event on AudioGraph<MockNode> (only sets orphaned=true).
+  // Execute the remove-event on AudioGraph (only sets orphaned=true).
   auto removeEvent = std::move(removeResult).unwrap();
   removeEvent(audioGraph, disposer_);
 
-  // AudioGraph<MockNode> still has the ghost: 0 → 1(orphaned) → 2
+  // AudioGraph still has the ghost: 0 → 1(orphaned) → 2
   EXPECT_EQ(audioGraph.size(), 3u);
 
   // ── Step 2: add edge 2 → 0 ──
-  // Because node 1 still bridges 0→2 in AudioGraph<MockNode>, this would create
-  // a cycle: 0 → 1 → 2 → 0.  HostGraph<MockNode> MUST reject it.
+  // Because node 1 still bridges 0→2 in AudioGraph, this would create
+  // a cycle: 0 → 1 → 2 → 0.  HostGraph MUST reject it.
   auto addResult = hostGraph.addEdge(node2, node0);
 
-  EXPECT_TRUE(addResult.is_err())
-      << "HostGraph<MockNode> should detect the cycle through the ghost node";
-  EXPECT_EQ(addResult.unwrap_err(), HostGraph<MockNode>::ResultError::CYCLE_DETECTED);
+  EXPECT_TRUE(addResult.is_err()) << "HostGraph should detect the cycle through the ghost node";
+  EXPECT_EQ(addResult.unwrap_err(), HostGraph::ResultError::CYCLE_DETECTED);
 }
 
 } // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h b/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h
index 2d296d7f7..aeb671b67 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h
@@ -6,6 +6,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <ranges>
 #include <thread>
 
 #ifdef __APPLE__
@@ -21,15 +22,15 @@ namespace audioapi::test {
 /// Spawns a dedicated thread that repeatedly:
 ///   1. Processes SPSC events (graph mutations from the main thread)
 ///   2. Runs toposort + compaction
-///   3. Iterates nodes in topological order, calling `process()` if the
-///      NodeType supports it (SFINAE via `requires`)
+///   3. Iterates graph objects in topological order, downcasts to `NodeType`,
+///      then calls `process(inputs)` if available
 ///
 /// The thread is instrumented with AudioThreadGuard to detect heap
 /// allocations / deallocations and sample context-switch counters.
 ///
 /// ## Usage
 /// ```cpp
-/// Graph<ProcessableMockNode> graph(4096);
+/// Graph graph(4096);
 /// MockGraphProcessor processor(graph);
 /// processor.start();
 /// // … mutate graph from main thread …
@@ -37,11 +38,11 @@ namespace audioapi::test {
 /// EXPECT_TRUE(processor.allocationClean());
 /// ```
 ///
-/// @tparam NodeType the audio graph node type (must satisfy AudioGraphNode)
-template <audioapi::utils::graph::AudioGraphNode NodeType>
+/// @tparam NodeType concrete GraphObject subtype expected by this processor.
+template <typename NodeType>
 class MockGraphProcessor {
  public:
-  explicit MockGraphProcessor(audioapi::utils::graph::Graph<NodeType> &graph) : graph_(graph) {}
+  explicit MockGraphProcessor(audioapi::utils::graph::Graph &graph) : graph_(graph) {}
 
   ~MockGraphProcessor() {
     stop();
@@ -136,16 +137,21 @@ class MockGraphProcessor {
     cycles_.fetch_add(1, std::memory_order_relaxed);
   }
 
-  /// @brief Iterates nodes in topological order and calls process(inputs).
+  /// @brief Iterates graph objects in topological order and calls process(inputs).
   void processNodes() {
-    for (auto &&[node, inputs] : graph_.iter()) {
-      if constexpr (requires { node.process(inputs); }) {
-        node.process(inputs);
+    for (auto &&[graphObject, inputs] : graph_.iter()) {
+      auto *node = dynamic_cast<NodeType *>(&graphObject);
+      if (!node) {
+        continue;
+      }
+
+      if constexpr (requires { node->process(inputs); }) {
+        node->process(inputs);
       }
     }
   }
 
-  audioapi::utils::graph::Graph<NodeType> &graph_;
+  audioapi::utils::graph::Graph &graph_;
   std::thread thread_;
   std::atomic<bool> running_{false};
   std::atomic<size_t> allocationViolations_{0};
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.cpp
index c092fef18..47b5afc1f 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.cpp
@@ -8,15 +8,15 @@
 
 namespace audioapi::utils::graph {
 
-std::pair<AudioGraph<MockNode>, HostGraph<MockNode>> TestGraphUtils::createTestGraph(
+std::pair<AudioGraph, HostGraph> TestGraphUtils::createTestGraph(
     std::vector<std::vector<size_t>> adjacencyList) {
-  HostGraph<MockNode> hostGraph = makeFromAdjacencyList(adjacencyList);
-  AudioGraph<MockNode> audioGraph = createAudioGraphFromHostGraph(hostGraph);
+  HostGraph hostGraph = makeFromAdjacencyList(adjacencyList);
+  AudioGraph audioGraph = createAudioGraphFromHostGraph(hostGraph);
   return {std::move(audioGraph), std::move(hostGraph)};
 }
 
 std::vector<std::vector<size_t>> TestGraphUtils::convertAudioGraphToAdjacencyList(
-    const AudioGraph<MockNode> &audioGraph) {
+    const AudioGraph &audioGraph) {
   std::vector<std::vector<size_t>> adjacencyList;
   if (audioGraph.size() == 0)
     return {};
@@ -50,7 +50,7 @@ std::vector<std::vector<size_t>> TestGraphUtils::convertAudioGraphToAdjacencyLis
 }
 
 std::vector<std::vector<size_t>> TestGraphUtils::convertHostGraphToAdjacencyList(
-    const HostGraph<MockNode> &hostGraph) {
+    const HostGraph &hostGraph) {
   std::vector<std::vector<size_t>> adjacencyList;
   if (hostGraph.nodes.empty())
     return {};
@@ -66,7 +66,7 @@ std::vector<std::vector<size_t>> TestGraphUtils::convertHostGraphToAdjacencyList
 
   for (auto *n : hostGraph.nodes) {
     size_t nodeId = n->test_node_identifier__;
-    for (HostGraph<MockNode>::Node *output : n->outputs) {
+    for (HostGraph::Node *output : n->outputs) {
       if (output) {
         adjacencyList[nodeId].push_back(output->test_node_identifier__);
       }
@@ -77,15 +77,15 @@ std::vector<std::vector<size_t>> TestGraphUtils::convertHostGraphToAdjacencyList
   return adjacencyList;
 }
 
-HostGraph<MockNode> TestGraphUtils::makeFromAdjacencyList(
+HostGraph TestGraphUtils::makeFromAdjacencyList(
     const std::vector<std::vector<size_t>> &adjacencyList) {
-  HostGraph<MockNode> graph;
-  std::vector<HostGraph<MockNode>::Node *> nodesVec;
+  HostGraph graph;
+  std::vector<HostGraph::Node *> nodesVec;
   nodesVec.reserve(adjacencyList.size());
 
   for (size_t i = 0; i < adjacencyList.size(); ++i) {
-    auto handle = std::make_shared<NodeHandle<MockNode>>(static_cast<uint32_t>(i), nullptr);
-    auto *node = new HostGraph<MockNode>::Node();
+    auto handle = std::make_shared<NodeHandle>(static_cast<uint32_t>(i), nullptr);
+    auto *node = new HostGraph::Node();
     node->handle = handle;
     node->test_node_identifier__ = i;
     nodesVec.push_back(node);
@@ -95,8 +95,8 @@ HostGraph<MockNode> TestGraphUtils::makeFromAdjacencyList(
   for (size_t fromIndex = 0; fromIndex < adjacencyList.size(); ++fromIndex) {
     for (size_t toIndex : adjacencyList[fromIndex]) {
       if (fromIndex < nodesVec.size() && toIndex < nodesVec.size()) {
-        HostGraph<MockNode>::Node *fromNode = nodesVec[fromIndex];
-        HostGraph<MockNode>::Node *toNode = nodesVec[toIndex];
+        HostGraph::Node *fromNode = nodesVec[fromIndex];
+        HostGraph::Node *toNode = nodesVec[toIndex];
         fromNode->outputs.push_back(toNode);
         toNode->inputs.push_back(fromNode);
       }
@@ -107,9 +107,8 @@ HostGraph<MockNode> TestGraphUtils::makeFromAdjacencyList(
   return graph;
 }
 
-AudioGraph<MockNode> TestGraphUtils::createAudioGraphFromHostGraph(
-    const HostGraph<MockNode> &hostGraph) {
-  AudioGraph<MockNode> audioGraph;
+AudioGraph TestGraphUtils::createAudioGraphFromHostGraph(const HostGraph &hostGraph) {
+  AudioGraph audioGraph;
   if (hostGraph.nodes.empty())
     return audioGraph;
 
@@ -122,7 +121,7 @@ AudioGraph<MockNode> TestGraphUtils::createAudioGraphFromHostGraph(
     audioGraph[idx].test_node_identifier__ = n->test_node_identifier__;
 
     audioGraph.pool().freeAll(audioGraph[idx].input_head);
-    for (HostGraph<MockNode>::Node *input : n->inputs) {
+    for (HostGraph::Node *input : n->inputs) {
       audioGraph.pool().push(audioGraph[idx].input_head, input->handle->index);
     }
   }
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
index d7fa631a2..bc010d593 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
@@ -5,6 +5,7 @@
 #define RN_AUDIO_API_TEST true // for intellisense
 #endif
 
+#include <audioapi/core/AudioNode.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
@@ -58,11 +59,11 @@ struct MockNode : AudioNode {
 };
 
 // ── MockHostNode ──────────────────────────────────────────────────────────
-// RAII wrapper around HostNode<MockNode> for testing the HostNode lifecycle.
+// RAII wrapper around HostNode for testing the HostNode lifecycle.
 
-class MockHostNode : public HostNode<MockNode> {
+class MockHostNode : public HostNode {
  public:
-  explicit MockHostNode(std::shared_ptr<Graph<MockNode>> graph, bool destructible = true)
+  explicit MockHostNode(std::shared_ptr<Graph> graph, bool destructible = true)
       : HostNode(std::move(graph), std::make_unique<MockNode>(destructible)) {}
 };
 
@@ -89,8 +90,10 @@ struct ProcessableMockNode : MockNode {
       bool destructible = true)
       : MockNode(destructible), value(initialValue), processFn_(std::move(processFn)) {}
 
-  /// @brief Called by the audio thread with the inputs range from iter().
-  /// Collects input values into a stack buffer — no heap allocation.
+  /// @brief Called by the audio thread with an input range from `Graph::iter()`.
+  ///
+  /// Supports both strongly-typed test ranges and GraphObject-based ranges,
+  /// collecting values into a stack buffer with no heap allocation.
   template <std::ranges::input_range R>
   void process(R &&inputs) {
     if (!processFn_)
@@ -98,8 +101,18 @@ struct ProcessableMockNode : MockNode {
     int buf[kMaxInputs];
     size_t n = 0;
     for (const auto &input : inputs) {
-      if (n < kMaxInputs)
+      if (n >= kMaxInputs) {
+        continue;
+      }
+
+      if constexpr (requires { input.value.load(std::memory_order_acquire); }) {
         buf[n++] = input.value.load(std::memory_order_acquire);
+      } else {
+        auto *typed = dynamic_cast<const ProcessableMockNode *>(&input);
+        if (typed) {
+          buf[n++] = typed->value.load(std::memory_order_acquire);
+        }
+      }
     }
     value.store(processFn_({buf, n}), std::memory_order_release);
   }
@@ -115,22 +128,21 @@ class TestGraphUtils {
   /// @brief Creates a paired AudioGraph + HostGraph from an adjacency list.
   /// @param adjacencyList adjacencyList[i] = {j, k} means edges i→j, i→k
   /// @return (AudioGraph, HostGraph) pair with consistent structure
-  static std::pair<AudioGraph<MockNode>, HostGraph<MockNode>> createTestGraph(
+  static std::pair<AudioGraph, HostGraph> createTestGraph(
       std::vector<std::vector<size_t>> adjacencyList);
 
   /// @brief Converts AudioGraph to adjacency list for equality comparison.
   static std::vector<std::vector<size_t>> convertAudioGraphToAdjacencyList(
-      const AudioGraph<MockNode> &audioGraph);
+      const AudioGraph &audioGraph);
 
   /// @brief Converts HostGraph to adjacency list for equality comparison.
   static std::vector<std::vector<size_t>> convertHostGraphToAdjacencyList(
-      const HostGraph<MockNode> &hostGraph);
+      const HostGraph &hostGraph);
 
  private:
-  static HostGraph<MockNode> makeFromAdjacencyList(
-      const std::vector<std::vector<size_t>> &adjacencyList);
+  static HostGraph makeFromAdjacencyList(const std::vector<std::vector<size_t>> &adjacencyList);
 
-  static AudioGraph<MockNode> createAudioGraphFromHostGraph(const HostGraph<MockNode> &hostGraph);
+  static AudioGraph createAudioGraphFromHostGraph(const HostGraph &hostGraph);
 };
 
 } // namespace audioapi::utils::graph

From b4625aaf826f8a3ee004ab3503fd9309b4c95a77 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 19 Mar 2026 18:59:59 +0100
Subject: [PATCH 02/38] feat: integrated new memory disposer

---
 .../effects/ConvolverNodeHostObject.cpp       |  8 +-
 .../cpp/audioapi/core/BaseAudioContext.cpp    |  9 ++-
 .../cpp/audioapi/core/BaseAudioContext.h      |  5 +-
 .../audioapi/core/effects/ConvolverNode.cpp   | 28 +++++--
 .../cpp/audioapi/core/effects/ConvolverNode.h |  4 +-
 .../sources/AudioBufferQueueSourceNode.cpp    | 14 ++--
 .../core/sources/AudioBufferSourceNode.cpp    | 10 ++-
 .../audioapi/core/utils/AudioDestructor.hpp   | 74 -------------------
 .../audioapi/core/utils/AudioGraphManager.cpp | 15 +---
 .../audioapi/core/utils/AudioGraphManager.h   | 22 ++----
 .../core/utils/{graph => }/Disposer.hpp       | 11 ++-
 .../cpp/audioapi/core/utils/graph/Graph.hpp   |  2 +-
 .../audioapi/core/utils/graph/HostGraph.hpp   |  2 +-
 .../cpp/test/src/graph/HostGraphTest.cpp      |  2 +-
 14 files changed, 71 insertions(+), 135 deletions(-)
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDestructor.hpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/{graph => }/Disposer.hpp (95%)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
index ba939cefa..383a00f49 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
@@ -67,17 +67,17 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
   }
 
   auto threadPool = std::make_shared<ThreadPool>(4);
-  std::vector<Convolver> convolvers;
+  std::vector<std::unique_ptr<Convolver>> convolvers;
   for (size_t i = 0; i < copiedBuffer->getNumberOfChannels(); ++i) {
     AudioArray channelData(*copiedBuffer->getChannel(i));
     convolvers.emplace_back();
-    convolvers.back().init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
+    convolvers.back()->init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
   }
   if (copiedBuffer->getNumberOfChannels() == 1) {
     // add one more convolver, because right now input is always stereo
     AudioArray channelData(*copiedBuffer->getChannel(0));
     convolvers.emplace_back();
-    convolvers.back().init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
+    convolvers.back()->init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
   }
 
   auto internalBuffer = std::make_shared<DSPAudioBuffer>(
@@ -87,7 +87,7 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
 
   struct SetupData {
     std::shared_ptr<AudioBuffer> buffer;
-    std::vector<Convolver> convolvers;
+    std::vector<std::unique_ptr<Convolver>> convolvers;
     std::shared_ptr<ThreadPool> threadPool;
     std::shared_ptr<DSPAudioBuffer> internalBuffer;
     std::shared_ptr<DSPAudioBuffer> intermediateBuffer;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 67e4013e0..7d5ac63c1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -38,10 +38,11 @@ BaseAudioContext::BaseAudioContext(
     const RuntimeRegistry &runtimeRegistry)
     : state_(ContextState::SUSPENDED),
       sampleRate_(sampleRate),
-      graphManager_(std::make_shared<AudioGraphManager>()),
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry),
-      audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY) {}
+      audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
+      disposer_(std::make_shared<utils::DisposerImpl<16>>(AUDIO_SCHEDULER_CAPACITY)),
+      graphManager_(std::make_shared<AudioGraphManager>(disposer_)) {}
 
 void BaseAudioContext::initialize() {
   destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
@@ -256,4 +257,8 @@ const RuntimeRegistry &BaseAudioContext::getRuntimeRegistry() const {
   return runtimeRegistry_;
 }
 
+std::shared_ptr<utils::DisposerImpl<16>> BaseAudioContext::getDisposer() const {
+  return disposer_;
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index e3f52fd28..23a72ab07 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -2,6 +2,7 @@
 
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
@@ -107,6 +108,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<AudioGraphManager> getGraphManager() const;
   std::shared_ptr<IAudioEventHandlerRegistry> getAudioEventHandlerRegistry() const;
   const RuntimeRegistry &getRuntimeRegistry() const;
+  std::shared_ptr<utils::DisposerImpl<16>> getDisposer() const;
 
   virtual void initialize();
 
@@ -131,7 +133,6 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
  private:
   std::atomic<ContextState> state_;
   std::atomic<float> sampleRate_;
-  std::shared_ptr<AudioGraphManager> graphManager_;
   std::shared_ptr<IAudioEventHandlerRegistry> audioEventHandlerRegistry_;
   RuntimeRegistry runtimeRegistry_;
 
@@ -142,6 +143,8 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
+  std::shared_ptr<utils::DisposerImpl<16>> disposer_;
+  std::shared_ptr<AudioGraphManager> graphManager_;
 
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
 };
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index d2bf43911..e24fd348f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -27,7 +27,7 @@ ConvolverNode::ConvolverNode(
 
 void ConvolverNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer,
-    std::vector<Convolver> convolvers,
+    std::vector<std::unique_ptr<Convolver>> convolvers,
     const std::shared_ptr<ThreadPool> &threadPool,
     const std::shared_ptr<DSPAudioBuffer> &internalBuffer,
     const std::shared_ptr<DSPAudioBuffer> &intermediateBuffer,
@@ -39,11 +39,25 @@ void ConvolverNode::setBuffer(
 
   auto graphManager = context->getGraphManager();
 
-  if (buffer_) {
-    graphManager->addAudioBufferForDestruction(std::move(buffer_));
+  if (buffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(buffer_));
   }
 
-  // TODO move convolvers, thread pool and DSPAudioBuffers destruction to graph manager as well
+  if (threadPool_ != nullptr) {
+    context->getDisposer()->dispose(std::move(threadPool_));
+  }
+
+  for (auto it = convolvers_.begin(); it != convolvers_.end(); ++it) {
+    context->getDisposer()->dispose(std::move(*it));
+  }
+
+  if (internalBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(internalBuffer_));
+  }
+
+  if (intermediateBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(intermediateBuffer_));
+  }
 
   buffer_ = buffer;
   convolvers_ = std::move(convolvers);
@@ -86,7 +100,7 @@ void ConvolverNode::onInputDisabled() {
   numberOfEnabledInputNodes_ -= 1;
   if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
     signalledToStop_ = true;
-    remainingSegments_ = convolvers_.at(0).getSegCount();
+    remainingSegments_ = convolvers_.at(0)->getSegCount();
   }
 }
 
@@ -144,7 +158,7 @@ void ConvolverNode::performConvolution(const std::shared_ptr<DSPAudioBuffer> &pr
   if (processingBuffer->getNumberOfChannels() == 1) {
     for (int i = 0; i < convolvers_.size(); ++i) {
       threadPool_->schedule([&, i] {
-        convolvers_[i].process(
+        convolvers_[i]->process(
             *processingBuffer->getChannel(0), *intermediateBuffer_->getChannel(i));
       });
     }
@@ -160,7 +174,7 @@ void ConvolverNode::performConvolution(const std::shared_ptr<DSPAudioBuffer> &pr
     }
     for (int i = 0; i < convolvers_.size(); ++i) {
       threadPool_->schedule([this, i, inputChannelMap, outputChannelMap, &processingBuffer] {
-        convolvers_[i].process(
+        convolvers_[i]->process(
             *processingBuffer->getChannel(inputChannelMap[i]),
             *intermediateBuffer_->getChannel(outputChannelMap[i]));
       });
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
index 489fa191b..7f04e3d13 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
@@ -27,7 +27,7 @@ class ConvolverNode : public AudioNode {
   /// @note Audio Thread only
   void setBuffer(
       const std::shared_ptr<AudioBuffer> &buffer,
-      std::vector<Convolver> convolvers,
+      std::vector<std::unique_ptr<Convolver>> convolvers,
       const std::shared_ptr<ThreadPool> &threadPool,
       const std::shared_ptr<DSPAudioBuffer> &internalBuffer,
       const std::shared_ptr<DSPAudioBuffer> &intermediateBuffer,
@@ -58,7 +58,7 @@ class ConvolverNode : public AudioNode {
   // buffer to hold internal processed data
   std::shared_ptr<DSPAudioBuffer> internalBuffer_;
   // vectors of convolvers, one per channel
-  std::vector<Convolver> convolvers_;
+  std::vector<std::unique_ptr<Convolver>> convolvers_;
   std::shared_ptr<ThreadPool> threadPool_;
 
   void performConvolution(const std::shared_ptr<DSPAudioBuffer> &processingBuffer);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
index 05abf41c5..260688e8e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
@@ -81,7 +81,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
     auto graphManager = context->getGraphManager();
 
     if (buffers_.front().first == bufferId) {
-      graphManager->addAudioBufferForDestruction(std::move(buffers_.front().second));
+      context->getDisposer()->dispose(std::move(buffers_.front().second));
       buffers_.pop_front();
       vReadIndex_ = 0.0;
       return;
@@ -91,7 +91,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
     // And keep vReadIndex_ at the same position.
     for (auto it = std::next(buffers_.begin()); it != buffers_.end(); ++it) {
       if (it->first == bufferId) {
-        graphManager->addAudioBufferForDestruction(std::move(it->second));
+        context->getDisposer()->dispose(std::move(it->second));
         buffers_.erase(it);
         return;
       }
@@ -102,7 +102,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
 void AudioBufferQueueSourceNode::clearBuffers() {
   if (auto context = context_.lock()) {
     for (auto it = buffers_.begin(); it != buffers_.end(); ++it) {
-      context->getGraphManager()->addAudioBufferForDestruction(std::move(it->second));
+      context->getDisposer()->dispose(std::move(it->second));
     }
 
     buffers_.clear();
@@ -215,7 +215,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
             buffers_.emplace_back(bufferId, tailBuffer_);
             addExtraTailFrames_ = false;
           } else {
-            context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
+            context->getDisposer()->dispose(std::move(buffer));
             processingBuffer->zero(writeIndex, framesLeft);
             readIndex = 0;
 
@@ -223,7 +223,7 @@ void AudioBufferQueueSourceNode::processWithoutInterpolation(
           }
         }
 
-        context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
+        context->getDisposer()->dispose(std::move(buffer));
         data = buffers_.front();
         bufferId = data.first;
         buffer = data.second;
@@ -296,14 +296,14 @@ void AudioBufferQueueSourceNode::processWithInterpolation(
         sendOnBufferEndedEvent(bufferId, buffers_.empty());
 
         if (buffers_.empty()) {
-          context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
+          context->getDisposer()->dispose(std::move(buffer));
           processingBuffer->zero(writeIndex, framesLeft);
           vReadIndex_ = 0.0;
           break;
         }
 
-        context->getGraphManager()->addAudioBufferForDestruction(std::move(buffer));
         vReadIndex_ = vReadIndex_ - buffer->getSize();
+        context->getDisposer()->dispose(std::move(buffer));
         data = buffers_.front();
         bufferId = data.first;
         buffer = data.second;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index e5bf7ec4a..0fce4ca90 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -58,10 +58,16 @@ void AudioBufferSourceNode::setBuffer(
   auto graphManager = context->getGraphManager();
 
   if (buffer_ != nullptr) {
-    graphManager->addAudioBufferForDestruction(std::move(buffer_));
+    context->getDisposer()->dispose(std::move(buffer_));
   }
 
-  // TODO move DSPAudioBuffers destruction to graph manager as well
+  if (playbackRateBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(playbackRateBuffer_));
+  }
+
+  if (audioBuffer_ != nullptr) {
+    context->getDisposer()->dispose(std::move(audioBuffer_));
+  }
 
   if (buffer == nullptr) {
     loopEnd_ = 0;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDestructor.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDestructor.hpp
deleted file mode 100644
index 28f768993..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDestructor.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-
-#include <audioapi/utils/SpscChannel.hpp>
-#include <atomic>
-#include <memory>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace audioapi {
-
-/// @brief A generic class to offload object destruction to a separate thread.
-/// @tparam T The type of object to be destroyed.
-template <typename T>
-class AudioDestructor {
- public:
-  AudioDestructor() : isExiting_(false) {
-    auto [sender, receiver] = channels::spsc::channel<
-        std::shared_ptr<T>,
-        channels::spsc::OverflowStrategy::WAIT_ON_FULL,
-        channels::spsc::WaitStrategy::ATOMIC_WAIT>(kChannelCapacity);
-    sender_ = std::move(sender);
-    workerHandle_ = std::thread(&AudioDestructor::process, this, std::move(receiver));
-  }
-
-  ~AudioDestructor() {
-    isExiting_.store(true, std::memory_order_release);
-
-    // We need to send a nullptr to unblock the receiver
-    sender_.send(nullptr);
-    if (workerHandle_.joinable()) {
-      workerHandle_.join();
-    }
-  }
-
-  /// @brief Adds an audio object to the deconstruction queue.
-  /// @param object The audio object to be deconstructed.
-  /// @return True if the node was successfully added, false otherwise.
-  /// @note audio object does NOT get moved out if it is not successfully added.
-  bool tryAddForDeconstruction(std::shared_ptr<T> &&object) {
-    return sender_.try_send(std::move(object)) == channels::spsc::ResponseStatus::SUCCESS;
-  }
-
- private:
-  static constexpr size_t kChannelCapacity = 1024;
-
-  std::thread workerHandle_;
-  std::atomic<bool> isExiting_;
-
-  using SenderType = channels::spsc::Sender<
-      std::shared_ptr<T>,
-      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
-      channels::spsc::WaitStrategy::ATOMIC_WAIT>;
-
-  using ReceiverType = channels::spsc::Receiver<
-      std::shared_ptr<T>,
-      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
-      channels::spsc::WaitStrategy::ATOMIC_WAIT>;
-
-  SenderType sender_;
-
-  /// @brief Processes audio objects for deconstruction.
-  /// @param receiver The receiver channel for incoming audio objects.
-  void process(ReceiverType &&receiver) {
-    auto rcv = std::move(receiver);
-    while (!isExiting_.load(std::memory_order_acquire)) {
-      rcv.receive();
-    }
-  }
-};
-
-#undef AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
index 1689fc6b6..0f6dffd92 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
@@ -72,11 +72,11 @@ AudioGraphManager::Event::~Event() {
   }
 }
 
-AudioGraphManager::AudioGraphManager() {
+AudioGraphManager::AudioGraphManager(const std::shared_ptr<utils::DisposerImpl<16>> &disposer)
+    : disposer_(disposer) {
   sourceNodes_.reserve(kInitialCapacity);
   processingNodes_.reserve(kInitialCapacity);
   audioParams_.reserve(kInitialCapacity);
-  audioBuffers_.reserve(kInitialCapacity);
 
   auto channel_pair = channels::spsc::channel<
       std::unique_ptr<Event>,
@@ -119,9 +119,8 @@ void AudioGraphManager::addPendingParamConnection(
 
 void AudioGraphManager::preProcessGraph() {
   settlePendingConnections();
-  AudioGraphManager::prepareForDestruction(sourceNodes_, nodeDestructor_);
-  AudioGraphManager::prepareForDestruction(processingNodes_, nodeDestructor_);
-  AudioGraphManager::prepareForDestruction(audioBuffers_, bufferDestructor_);
+  prepareForDestruction(sourceNodes_);
+  prepareForDestruction(processingNodes_);
 }
 
 void AudioGraphManager::addProcessingNode(const std::shared_ptr<AudioNode> &node) {
@@ -151,11 +150,6 @@ void AudioGraphManager::addAudioParam(const std::shared_ptr<AudioParam> &param)
   sender_.send(std::move(event));
 }
 
-void AudioGraphManager::addAudioBufferForDestruction(std::shared_ptr<AudioBuffer> buffer) {
-  // direct access because this is called from the Audio thread
-  audioBuffers_.emplace_back(std::move(buffer));
-}
-
 void AudioGraphManager::settlePendingConnections() {
   std::unique_ptr<Event> value;
   while (receiver_.try_receive(value) != channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
@@ -234,7 +228,6 @@ void AudioGraphManager::cleanup() {
   sourceNodes_.clear();
   processingNodes_.clear();
   audioParams_.clear();
-  audioBuffers_.clear();
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
index 462fbddb0..dacdf45f1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <audioapi/core/utils/AudioDestructor.hpp>
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/SpscChannel.hpp>
 
@@ -59,7 +59,7 @@ class AudioGraphManager {
     ~Event();
   };
 
-  AudioGraphManager();
+  explicit AudioGraphManager(const std::shared_ptr<utils::DisposerImpl<16>> &disposer);
   ~AudioGraphManager();
 
   void preProcessGraph();
@@ -99,15 +99,10 @@ class AudioGraphManager {
   /// @note Should be only used from JavaScript/HostObjects thread
   void addAudioParam(const std::shared_ptr<AudioParam> &param);
 
-  /// @brief Adds an audio buffer to the manager for destruction.
-  /// @note Called directly from the Audio thread (bypasses SPSC).
-  void addAudioBufferForDestruction(std::shared_ptr<AudioBuffer> buffer);
-
   void cleanup();
 
  private:
-  AudioDestructor<AudioNode> nodeDestructor_;
-  AudioDestructor<AudioBuffer> bufferDestructor_;
+  const std::shared_ptr<utils::DisposerImpl<16>> disposer_;
 
   /// @brief Initial capacity for various node types for deletion
   /// @note Higher capacity decreases number of reallocations at runtime (can be easily adjusted to 128 if needed)
@@ -120,10 +115,8 @@ class AudioGraphManager {
   std::vector<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
   std::vector<std::shared_ptr<AudioNode>> processingNodes_;
   std::vector<std::shared_ptr<AudioParam>> audioParams_;
-  std::vector<std::shared_ptr<AudioBuffer>> audioBuffers_;
 
   channels::spsc::Receiver<AUDIO_GRAPH_MANAGER_SPSC_OPTIONS> receiver_;
-
   channels::spsc::Sender<AUDIO_GRAPH_MANAGER_SPSC_OPTIONS> sender_;
 
   void settlePendingConnections();
@@ -154,11 +147,8 @@ class AudioGraphManager {
     return node.use_count() == 1;
   }
 
-  template <typename T, typename D>
-    requires std::convertible_to<T *, D *>
-  static void prepareForDestruction(
-      std::vector<std::shared_ptr<T>> &vec,
-      AudioDestructor<D> &audioDestructor) {
+  template <typename T>
+  void prepareForDestruction(std::vector<std::shared_ptr<T>> &vec) {
     if (vec.empty()) {
       return;
     }
@@ -201,7 +191,7 @@ class AudioGraphManager {
       /// If we fail to add we can't safely remove the node from the vector
       /// so we swap it and advance begin cursor
       /// @note vec[i] does NOT get moved out if it is not successfully added.
-      if (!audioDestructor.tryAddForDeconstruction(std::move(vec[i]))) {
+      if (!disposer_->dispose(std::move(vec[i]))) {
         std::swap(vec[i], vec[begin]);
         begin++;
       }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Disposer.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Disposer.hpp
similarity index 95%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Disposer.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/Disposer.hpp
index 7b2e6f030..6a1883f54 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Disposer.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Disposer.hpp
@@ -4,12 +4,11 @@
 
 #include <cstddef>
 #include <cstring>
-#include <new>
 #include <thread>
 #include <type_traits>
 #include <utility>
 
-namespace audioapi::utils::graph {
+namespace audioapi::utils {
 
 /// @brief A disposal payload that can hold any trivially-relocatable or
 /// move-constructible type up to N bytes. The value is moved into a raw byte
@@ -22,7 +21,7 @@ struct DisposalPayload {
   void (*destructor)(void *); // type-erased destructor
 
   /// @brief Sentinel check — a null destructor means "shutdown".
-  bool isSentinel() const;
+  [[nodiscard]] bool isSentinel() const;
 
   /// @brief Creates a sentinel payload used to signal worker thread shutdown.
   static DisposalPayload sentinel();
@@ -139,9 +138,9 @@ DisposerImpl<N>::DisposerImpl(size_t channelCapacity) {
   auto [sender, receiver] =
       channel<Payload, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::ATOMIC_WAIT>(channelCapacity);
   sender_ = std::move(sender);
-  workerHandle_ = std::thread([receiver = std::move(receiver)]() mutable {
+  workerHandle_ = std::thread([receiver_ = std::move(receiver)]() mutable {
     while (true) {
-      auto payload = receiver.receive();
+      auto payload = receiver_.receive();
       if (payload.isSentinel()) {
         break;
       }
@@ -163,4 +162,4 @@ bool DisposerImpl<N>::doDispose(DisposalPayload<N> &&payload) {
   return sender_.try_send(std::move(payload)) == audioapi::channels::spsc::ResponseStatus::SUCCESS;
 }
 
-} // namespace audioapi::utils::graph
+} // namespace audioapi::utils
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 269f32476..0f537d92e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/Disposer.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/core/utils/graph/InputPool.hpp>
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
index c785248a5..0d9dd73b8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/Disposer.hpp>
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
 #include <audioapi/utils/FatFunction.hpp>
 #include <audioapi/utils/Result.hpp>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
index e796c0003..7ee9457a9 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
@@ -1,5 +1,5 @@
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/Disposer.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
 #include <gtest/gtest.h>

From a010057bbfe6f7ca07464ee81adfe1e60776935d Mon Sep 17 00:00:00 2001
From: poneciak <poneciak@gmail.com>
Date: Fri, 20 Mar 2026 13:31:02 +0100
Subject: [PATCH 03/38] feat: added bridge node

---
 .../audioapi/core/utils/graph/AudioGraph.hpp  |   4 +-
 .../audioapi/core/utils/graph/BridgeNode.hpp  |  44 ++
 .../cpp/audioapi/core/utils/graph/Graph.hpp   | 166 +++++
 .../audioapi/core/utils/graph/GraphObject.hpp |   9 +
 .../audioapi/core/utils/graph/HostNode.hpp    |  12 +
 .../cpp/test/src/graph/BridgeNodeTest.cpp     | 615 ++++++++++++++++++
 .../cpp/test/src/graph/TestGraphUtils.h       |  15 +
 .../react-native-audio-api/scripts/cpplint.sh |   2 +-
 8 files changed, 865 insertions(+), 2 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
 create mode 100644 packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
index 051ccd6cc..9a2b98295 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
@@ -166,7 +166,9 @@ inline bool AudioGraph::empty() const {
 }
 
 inline auto AudioGraph::iter() {
-  return nodes | std::views::transform([this](Node &node) {
+  return nodes |
+      std::views::filter([](const Node &n) { return n.handle->audioNode->isProcessable(); }) |
+      std::views::transform([this](Node &node) {
            return Entry{
                *node.handle->audioNode,
                pool_.view(node.input_head) |
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
new file mode 100644
index 000000000..d373977a2
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <audioapi/core/utils/graph/GraphObject.hpp>
+
+namespace audioapi {
+class AudioParam;
+}
+
+namespace audioapi::utils::graph {
+
+/// @brief Lightweight graph-only node that represents an AudioParam connection.
+///
+/// A BridgeNode sits between a source AudioNode and the owner AudioNode of a
+/// param, forming the path: source → bridge → owner. This lets the graph
+/// system detect cycles and compute correct topological ordering for param
+/// connections without creating real ownership dependencies.
+///
+/// BridgeNodes are:
+///   - **Not processable** — skipped by `AudioGraph::iter()`.
+///   - **Always destructible** — removed by compaction when orphaned with no inputs.
+///   - **Non-owning** — stores a raw `AudioParam*` whose lifetime is guaranteed
+///     by the owner node.
+class BridgeNode final : public GraphObject {
+ public:
+  explicit BridgeNode(AudioParam *param) : param_(param) {}
+
+  [[nodiscard]] bool isProcessable() const override {
+    return false;
+  }
+
+  [[nodiscard]] bool canBeDestructed() const override {
+    return true;
+  }
+
+  /// @brief Returns the param this bridge represents a connection to.
+  [[nodiscard]] AudioParam *param() const {
+    return param_;
+  }
+
+ private:
+  AudioParam *param_; // non-owning — lifetime guaranteed by owner node
+};
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 7df057e96..0e974bf0b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
+#include <audioapi/core/utils/graph/BridgeNode.hpp>
 #include <audioapi/core/utils/graph/Disposer.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/core/utils/graph/InputPool.hpp>
@@ -13,8 +14,13 @@
 #include <algorithm>
 #include <cstdint>
 #include <memory>
+#include <unordered_map>
 #include <utility>
 
+namespace audioapi {
+class AudioParam;
+}
+
 namespace audioapi::utils::graph {
 
 /// @brief Thread-safe graph coordinator that bridges HostGraph (main thread)
@@ -165,6 +171,115 @@ class Graph {
     });
   }
 
+  // ── Param bridge API ───────────────────────────────────────────────────
+
+  /// @brief Creates a bridge node representing: source → bridge → owner.
+  ///
+  /// The bridge encodes a param connection in the graph for cycle detection
+  /// and topological ordering. The bridge itself is not processable.
+  ///
+  /// @param source the node whose output feeds the param
+  /// @param owner the node that owns the param
+  /// @param param raw pointer to the AudioParam (lifetime guaranteed by owner)
+  /// @return Ok on success, Err on cycle/duplicate/not-found
+  Res connectParam(HNode *source, HNode *owner, AudioParam *param) {
+    hostGraph.collectDisposedNodes();
+
+    BridgeKey key{source, param};
+    if (bridgeMap_.count(key)) {
+      return Res::Err(ResultError::EDGE_ALREADY_EXISTS);
+    }
+
+    // Create bridge node
+    auto bridgeObj = std::make_unique<BridgeNode>(param);
+    auto bridgeHandle = std::make_shared<NodeHandle>(0, std::move(bridgeObj));
+    auto [bridgeHostNode, addEvent] = hostGraph.addNode(bridgeHandle);
+
+    // source → bridge
+    auto edgeRes1 = hostGraph.addEdge(source, bridgeHostNode);
+    if (edgeRes1.is_err()) {
+      // Rollback: remove bridge node
+      (void)hostGraph.removeNode(bridgeHostNode);
+      return Res::Err(edgeRes1.unwrap_err());
+    }
+
+    // bridge → owner
+    auto edgeRes2 = hostGraph.addEdge(bridgeHostNode, owner);
+    if (edgeRes2.is_err()) {
+      // Rollback: remove source→bridge edge and bridge node
+      (void)hostGraph.removeEdge(source, bridgeHostNode);
+      (void)hostGraph.removeNode(bridgeHostNode);
+      return Res::Err(edgeRes2.unwrap_err());
+    }
+
+    // All succeeded — send events through SPSC
+    sendNodeGrowIfNeeded();
+    eventSender_.send(std::move(addEvent));
+
+    sendPoolGrowIfNeeded();
+    eventSender_.send(std::move(edgeRes1).unwrap());
+
+    sendPoolGrowIfNeeded();
+    eventSender_.send(std::move(edgeRes2).unwrap());
+
+    // Track bridge
+    bridgeMap_[key] = bridgeHostNode;
+    bridgeOwners_[bridgeHostNode] = owner;
+
+    return Res::Ok(NoneType{});
+  }
+
+  /// @brief Removes a bridge node for the given (source, param) pair.
+  Res disconnectParam(HNode *source, HNode * /*owner*/, AudioParam *param) {
+    hostGraph.collectDisposedNodes();
+
+    BridgeKey key{source, param};
+    auto it = bridgeMap_.find(key);
+    if (it == bridgeMap_.end()) {
+      return Res::Err(ResultError::EDGE_NOT_FOUND);
+    }
+
+    HNode *bridge = it->second;
+    removeBridge(source, bridge);
+    bridgeMap_.erase(it);
+
+    return Res::Ok(NoneType{});
+  }
+
+  /// @brief Removes a node and cascade-removes any bridges where this node
+  /// is the source or owner.
+  Res removeNodeWithBridges(HNode *node) {
+    hostGraph.collectDisposedNodes();
+
+    // Cascade: remove bridges where this node is source
+    for (auto it = bridgeMap_.begin(); it != bridgeMap_.end();) {
+      if (it->first.source == node) {
+        HNode *bridge = it->second;
+        removeBridge(node, bridge);
+        bridgeOwners_.erase(bridge);
+        it = bridgeMap_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+
+    // Cascade: remove bridges where this node is owner
+    for (auto it = bridgeMap_.begin(); it != bridgeMap_.end();) {
+      auto ownerIt = bridgeOwners_.find(it->second);
+      if (ownerIt != bridgeOwners_.end() && ownerIt->second == node) {
+        HNode *bridge = it->second;
+        HNode *source = it->first.source;
+        removeBridge(source, bridge);
+        bridgeOwners_.erase(ownerIt);
+        it = bridgeMap_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+
+    return removeNode(node);
+  }
+
  private:
   static constexpr size_t kDisposerPayloadSize = HostGraph::kDisposerPayloadSize;
 
@@ -223,6 +338,57 @@ class Graph {
     }
   }
 
+  // ── Bridge tracking (main thread only) ──────────────────────────────────
+
+  struct BridgeKey {
+    HNode *source;
+    AudioParam *param;
+
+    bool operator==(const BridgeKey &other) const {
+      return source == other.source && param == other.param;
+    }
+  };
+
+  struct BridgeKeyHash {
+    size_t operator()(const BridgeKey &k) const {
+      auto h1 = std::hash<HNode *>{}(k.source);
+      auto h2 = std::hash<AudioParam *>{}(k.param);
+      return h1 ^ (h2 << 1);
+    }
+  };
+
+  /// Maps (source, param) → bridge host node
+  std::unordered_map<BridgeKey, HNode *, BridgeKeyHash> bridgeMap_;
+
+  /// Maps bridge host node → owner host node (for cascade removal)
+  std::unordered_map<HNode *, HNode *> bridgeOwners_;
+
+  /// @brief Removes a bridge node: tears down edges and marks for removal.
+  void removeBridge(HNode *source, HNode *bridge) {
+    // Find the owner from bridgeOwners_
+    auto ownerIt = bridgeOwners_.find(bridge);
+    HNode *owner = (ownerIt != bridgeOwners_.end()) ? ownerIt->second : nullptr;
+
+    // Remove edges: source→bridge, bridge→owner
+    auto res1 = hostGraph.removeEdge(source, bridge);
+    if (res1.is_ok()) {
+      eventSender_.send(std::move(res1).unwrap());
+    }
+
+    if (owner) {
+      auto res2 = hostGraph.removeEdge(bridge, owner);
+      if (res2.is_ok()) {
+        eventSender_.send(std::move(res2).unwrap());
+      }
+    }
+
+    // Remove bridge node
+    auto res3 = hostGraph.removeNode(bridge);
+    if (res3.is_ok()) {
+      eventSender_.send(std::move(res3).unwrap());
+    }
+  }
+
   friend class GraphTest;
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
index e348c26dd..2363af77c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
@@ -30,6 +30,15 @@ class GraphObject {
     return true;
   }
 
+  /// @brief Returns whether this node should be processed during audio iteration.
+  ///
+  /// Default is true. BridgeNodes override to return false — they exist only
+  /// for graph structure (cycle detection, topo ordering) and are skipped
+  /// by AudioGraph::iter().
+  [[nodiscard]] virtual bool isProcessable() const {
+    return true;
+  }
+
   /// @brief Downcast helper for node-specific handling.
   [[nodiscard]] virtual AudioNode *asAudioNode() {
     return nullptr;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
index 84f6d392a..2b1b66e5a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
@@ -103,6 +103,18 @@ class HostNode {
     return graph_->removeEdge(node_, other.node_);
   }
 
+  /// @brief Connects this node's output to a param on the owner node via a bridge.
+  /// @return Ok on success, Err on cycle / duplicate / not-found
+  Res connectParam(HostNode &owner, AudioParam *param) {
+    return graph_->connectParam(node_, owner.node_, param);
+  }
+
+  /// @brief Disconnects this node's output from a param on the owner node.
+  /// @return Ok on success, Err on not-found
+  Res disconnectParam(HostNode &owner, AudioParam *param) {
+    return graph_->disconnectParam(node_, owner.node_, param);
+  }
+
   /// @brief Returns the raw HostGraph::Node pointer (for advanced usage / testing).
   [[nodiscard]] HNode *rawNode() const {
     return node_;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
new file mode 100644
index 000000000..024eae045
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
@@ -0,0 +1,615 @@
+#include <audioapi/core/utils/graph/BridgeNode.hpp>
+#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <memory>
+#include <random>
+#include <utility>
+#include <vector>
+
+#include "MockGraphProcessor.h"
+#include "TestGraphUtils.h"
+
+namespace audioapi::utils::graph {
+
+// =========================================================================
+// A. isProcessable contract
+// =========================================================================
+
+TEST(BridgeNodeContract, MockNodeIsProcessable) {
+  MockNode node;
+  EXPECT_TRUE(node.isProcessable());
+}
+
+TEST(BridgeNodeContract, BridgeNodeIsNotProcessable) {
+  BridgeNode bridge(nullptr);
+  EXPECT_FALSE(bridge.isProcessable());
+}
+
+TEST(BridgeNodeContract, BridgeNodeIsAlwaysDestructible) {
+  BridgeNode bridge(nullptr);
+  EXPECT_TRUE(bridge.canBeDestructed());
+}
+
+TEST(BridgeNodeContract, NonProcessableMockNodeIsNotProcessable) {
+  NonProcessableMockNode node;
+  EXPECT_FALSE(node.isProcessable());
+  EXPECT_TRUE(node.canBeDestructed());
+}
+
+TEST(BridgeNodeContract, BridgeNodeStoresParam) {
+  // Use a dummy pointer to verify storage
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0xDEAD);
+  BridgeNode bridge(fakeParam);
+  EXPECT_EQ(bridge.param(), fakeParam);
+}
+
+// =========================================================================
+// B. Graph structural tests (HostGraph + AudioGraph)
+// =========================================================================
+
+class BridgeGraphTest : public ::testing::Test {
+ protected:
+  using HNode = HostGraph::Node;
+  using AGEvent = HostGraph::AGEvent;
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+
+  AudioGraph audioGraph;
+  HostGraph hostGraph;
+  DisposerImpl<kPayloadSize> disposer_{64};
+
+  HNode *addMockNode() {
+    auto obj = std::make_unique<MockNode>();
+    auto handle = std::make_shared<NodeHandle>(0, std::move(obj));
+    auto [hostNode, event] = hostGraph.addNode(handle);
+    event(audioGraph, disposer_);
+    return hostNode;
+  }
+
+  HNode *addBridgeNode(AudioParam *param = nullptr) {
+    auto obj = std::make_unique<BridgeNode>(param);
+    auto handle = std::make_shared<NodeHandle>(0, std::move(obj));
+    auto [hostNode, event] = hostGraph.addNode(handle);
+    event(audioGraph, disposer_);
+    return hostNode;
+  }
+
+  bool addEdge(HNode *from, HNode *to) {
+    auto result = hostGraph.addEdge(from, to);
+    if (result.is_ok()) {
+      auto event = std::move(result).unwrap();
+      event(audioGraph, disposer_);
+      return true;
+    }
+    return false;
+  }
+
+  bool removeEdge(HNode *from, HNode *to) {
+    auto result = hostGraph.removeEdge(from, to);
+    if (result.is_ok()) {
+      auto event = std::move(result).unwrap();
+      event(audioGraph, disposer_);
+      return true;
+    }
+    return false;
+  }
+
+  bool removeNode(HNode *node) {
+    auto result = hostGraph.removeNode(node);
+    if (result.is_ok()) {
+      auto event = std::move(result).unwrap();
+      event(audioGraph, disposer_);
+      return true;
+    }
+    return false;
+  }
+};
+
+TEST_F(BridgeGraphTest, BridgeCreatesThreeNodePath) {
+  auto *source = addMockNode();
+  auto *owner = addMockNode();
+  auto *bridge = addBridgeNode();
+
+  ASSERT_TRUE(addEdge(source, bridge));
+  ASSERT_TRUE(addEdge(bridge, owner));
+
+  // 3 nodes in graph
+  EXPECT_EQ(audioGraph.size(), 3u);
+
+  // Topo sort should place them: source, bridge, owner
+  audioGraph.process();
+
+  // Verify source comes before bridge comes before owner
+  auto srcIdx = source->handle->index;
+  auto bridgeIdx = bridge->handle->index;
+  auto ownerIdx = owner->handle->index;
+  EXPECT_LT(srcIdx, bridgeIdx);
+  EXPECT_LT(bridgeIdx, ownerIdx);
+}
+
+TEST_F(BridgeGraphTest, CycleDetectionThroughBridges) {
+  // Create: A → bridge → B → A would be a cycle
+  auto *nodeA = addMockNode();
+  auto *nodeB = addMockNode();
+  auto *bridge = addBridgeNode();
+
+  ASSERT_TRUE(addEdge(nodeA, bridge));
+  ASSERT_TRUE(addEdge(bridge, nodeB));
+
+  // Now B → A should be rejected as a cycle
+  auto result = hostGraph.addEdge(nodeB, nodeA);
+  EXPECT_TRUE(result.is_err());
+  EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::CYCLE_DETECTED);
+}
+
+TEST_F(BridgeGraphTest, DuplicateEdgeRejectionWithBridges) {
+  auto *source = addMockNode();
+  auto *bridge = addBridgeNode();
+
+  ASSERT_TRUE(addEdge(source, bridge));
+  // Same edge again should be rejected
+  auto result = hostGraph.addEdge(source, bridge);
+  EXPECT_TRUE(result.is_err());
+  EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::EDGE_ALREADY_EXISTS);
+}
+
+// =========================================================================
+// C. AudioGraph::iter() filtering
+// =========================================================================
+
+class BridgeIterTest : public ::testing::Test {
+ protected:
+  using HNode = HostGraph::Node;
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+
+  AudioGraph audioGraph;
+  HostGraph hostGraph;
+  DisposerImpl<kPayloadSize> disposer_{64};
+
+  HNode *addNode(std::unique_ptr<GraphObject> obj) {
+    auto handle = std::make_shared<NodeHandle>(0, std::move(obj));
+    auto [hostNode, event] = hostGraph.addNode(handle);
+    event(audioGraph, disposer_);
+    return hostNode;
+  }
+
+  bool addEdge(HNode *from, HNode *to) {
+    auto result = hostGraph.addEdge(from, to);
+    if (result.is_ok()) {
+      std::move(result).unwrap()(audioGraph, disposer_);
+      return true;
+    }
+    return false;
+  }
+};
+
+TEST_F(BridgeIterTest, IterSkipsNonProcessableNodes) {
+  auto *processable1 = addNode(std::make_unique<MockNode>());
+  auto *nonProcessable = addNode(std::make_unique<NonProcessableMockNode>());
+  auto *processable2 = addNode(std::make_unique<MockNode>());
+
+  ASSERT_TRUE(addEdge(processable1, nonProcessable));
+  ASSERT_TRUE(addEdge(nonProcessable, processable2));
+  audioGraph.process();
+
+  // iter() should only yield 2 nodes (skip the non-processable one)
+  size_t count = 0;
+  for (auto &&[graphObject, inputs] : audioGraph.iter()) {
+    EXPECT_TRUE(graphObject.isProcessable());
+    count++;
+  }
+  EXPECT_EQ(count, 2u);
+}
+
+TEST_F(BridgeIterTest, AllProcessableNodesInTopoOrder) {
+  // A → bridge → B → C
+  auto *a = addNode(std::make_unique<ProcessableMockNode>(nullptr, 1));
+  auto *bridge = addNode(std::make_unique<BridgeNode>(nullptr));
+  auto *b = addNode(std::make_unique<ProcessableMockNode>(nullptr, 2));
+  auto *c = addNode(std::make_unique<ProcessableMockNode>(nullptr, 3));
+
+  ASSERT_TRUE(addEdge(a, bridge));
+  ASSERT_TRUE(addEdge(bridge, b));
+  ASSERT_TRUE(addEdge(b, c));
+  audioGraph.process();
+
+  // Should yield A, B, C in topo order (bridge skipped)
+  std::vector<int> values;
+  for (auto &&[graphObject, inputs] : audioGraph.iter()) {
+    auto *node = dynamic_cast<ProcessableMockNode *>(&graphObject);
+    ASSERT_NE(node, nullptr);
+    values.push_back(node->value.load());
+  }
+  ASSERT_EQ(values.size(), 3u);
+  EXPECT_EQ(values[0], 1);
+  EXPECT_EQ(values[1], 2);
+  EXPECT_EQ(values[2], 3);
+}
+
+TEST_F(BridgeIterTest, InputsViewMayReferenceBridgeIndices) {
+  // source → bridge → owner
+  // iter() skips bridge but owner's input list in AudioGraph still
+  // references the bridge's index. Callers use asAudioNode() to handle this.
+  auto *source = addNode(std::make_unique<MockNode>());
+  auto *bridge = addNode(std::make_unique<BridgeNode>(nullptr));
+  auto *owner = addNode(std::make_unique<MockNode>());
+
+  ASSERT_TRUE(addEdge(source, bridge));
+  ASSERT_TRUE(addEdge(bridge, owner));
+  audioGraph.process();
+
+  size_t processableCount = 0;
+  for (auto &&[graphObject, inputs] : audioGraph.iter()) {
+    processableCount++;
+    // Owner should see bridge as input (which is a BridgeNode, not AudioNode)
+    for (const auto &input : inputs) {
+      // Input could be bridge or source — both are valid GraphObjects
+      (void)input;
+    }
+  }
+  EXPECT_EQ(processableCount, 2u); // source + owner (bridge skipped)
+}
+
+// =========================================================================
+// D. Compaction tests
+// =========================================================================
+
+TEST_F(BridgeGraphTest, OrphanedBridgeWithNoInputsRemoved) {
+  auto *bridge = addBridgeNode();
+  EXPECT_EQ(audioGraph.size(), 1u);
+
+  // Mark orphaned
+  removeNode(bridge);
+  audioGraph.process();
+
+  EXPECT_EQ(audioGraph.size(), 0u);
+}
+
+TEST_F(BridgeGraphTest, SourceRemovalCascadesBridgeRemoval) {
+  auto *source = addMockNode();
+  auto *bridge = addBridgeNode();
+  auto *owner = addMockNode();
+
+  ASSERT_TRUE(addEdge(source, bridge));
+  ASSERT_TRUE(addEdge(bridge, owner));
+  audioGraph.process();
+  EXPECT_EQ(audioGraph.size(), 3u);
+
+  // Remove source — bridge loses its only input
+  removeNode(source);
+  audioGraph.process();
+
+  // Source compacted (orphaned, no inputs, destructible)
+  // Bridge compacted (orphaned via edge removal cascade — its input was removed)
+  // Owner stays (not orphaned)
+  // Actually: source is orphaned+no inputs → removed
+  // Then bridge has no inputs → but bridge is NOT orphaned unless explicitly marked
+  // Bridge keeps its edge to owner. Bridge itself is not orphaned.
+  // So only source is removed.
+  // After first process: source removed, bridge has no inputs but not orphaned.
+  // Bridge won't be compacted unless it's also orphaned.
+  // This is correct — bridge removal needs to be done via disconnectParam or removeNodeWithBridges.
+  EXPECT_EQ(audioGraph.size(), 2u); // bridge + owner remain
+}
+
+TEST_F(BridgeGraphTest, BridgeOrphanedAndNoInputsGetsCompacted) {
+  auto *source = addMockNode();
+  auto *bridge = addBridgeNode();
+  auto *owner = addMockNode();
+
+  ASSERT_TRUE(addEdge(source, bridge));
+  ASSERT_TRUE(addEdge(bridge, owner));
+  audioGraph.process();
+  EXPECT_EQ(audioGraph.size(), 3u);
+
+  // Orphan source and bridge
+  removeNode(source);
+  removeEdge(bridge, owner);
+  removeNode(bridge);
+  audioGraph.process();
+
+  // Both source and bridge should be compacted
+  EXPECT_EQ(audioGraph.size(), 1u); // only owner remains
+}
+
+// =========================================================================
+// E. Full Graph wrapper integration
+// =========================================================================
+
+class BridgeGraphWrapperTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<Graph> graph;
+
+  void SetUp() override {
+    graph = std::make_shared<Graph>(4096);
+  }
+
+  void processAll() {
+    graph->processEvents();
+    graph->process();
+  }
+};
+
+TEST_F(BridgeGraphWrapperTest, ConnectParamCreatesBridge) {
+  auto *source = graph->addNode(std::make_unique<MockNode>());
+  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+
+  auto result = graph->connectParam(source, owner, fakeParam);
+  ASSERT_TRUE(result.is_ok());
+
+  processAll();
+
+  // Should have 3 nodes: source, bridge, owner
+  size_t iterCount = 0;
+  for (auto &&[graphObject, inputs] : graph->iter()) {
+    iterCount++;
+  }
+  // iter() skips non-processable bridge, so we see 2
+  EXPECT_EQ(iterCount, 2u);
+}
+
+TEST_F(BridgeGraphWrapperTest, DisconnectParamRemovesBridge) {
+  auto *source = graph->addNode(std::make_unique<MockNode>());
+  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+
+  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  processAll();
+
+  ASSERT_TRUE(graph->disconnectParam(source, owner, fakeParam).is_ok());
+  processAll();
+
+  // Bridge should be compacted away (orphaned + no inputs)
+  size_t iterCount = 0;
+  for (auto &&[graphObject, inputs] : graph->iter()) {
+    iterCount++;
+  }
+  EXPECT_EQ(iterCount, 2u); // source + owner
+}
+
+TEST_F(BridgeGraphWrapperTest, DuplicateConnectParamRejected) {
+  auto *source = graph->addNode(std::make_unique<MockNode>());
+  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+
+  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+
+  // Same connection again should fail
+  auto result = graph->connectParam(source, owner, fakeParam);
+  EXPECT_TRUE(result.is_err());
+  EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::EDGE_ALREADY_EXISTS);
+}
+
+TEST_F(BridgeGraphWrapperTest, ConnectParamCycleDetected) {
+  auto *nodeA = graph->addNode(std::make_unique<MockNode>());
+  auto *nodeB = graph->addNode(std::make_unique<MockNode>());
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+
+  // A → B (regular edge)
+  ASSERT_TRUE(graph->addEdge(nodeA, nodeB).is_ok());
+
+  // Now try B →(param)→ A — this would create: B → bridge → A
+  // Combined with A → B, this creates cycle: A → B → bridge → A
+  auto result = graph->connectParam(nodeB, nodeA, fakeParam);
+  EXPECT_TRUE(result.is_err());
+  EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::CYCLE_DETECTED);
+}
+
+TEST_F(BridgeGraphWrapperTest, OwnerRemovalCascadesBridgeCleanup) {
+  auto *source = graph->addNode(std::make_unique<MockNode>());
+  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+
+  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  processAll();
+
+  // Remove owner — should cascade remove the bridge
+  ASSERT_TRUE(graph->removeNodeWithBridges(owner).is_ok());
+  processAll();
+
+  // Only source should remain as processable
+  size_t iterCount = 0;
+  for (auto &&[graphObject, inputs] : graph->iter()) {
+    iterCount++;
+  }
+  EXPECT_EQ(iterCount, 1u);
+}
+
+TEST_F(BridgeGraphWrapperTest, SourceRemovalCascadesBridgeCleanup) {
+  auto *source = graph->addNode(std::make_unique<MockNode>());
+  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+
+  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  processAll();
+
+  // Remove source — should cascade remove the bridge
+  ASSERT_TRUE(graph->removeNodeWithBridges(source).is_ok());
+  processAll();
+
+  // Only owner should remain as processable
+  size_t iterCount = 0;
+  for (auto &&[graphObject, inputs] : graph->iter()) {
+    iterCount++;
+  }
+  EXPECT_EQ(iterCount, 1u);
+}
+
+TEST_F(BridgeGraphWrapperTest, MultipleBridgesFromSameSource) {
+  auto *source = graph->addNode(std::make_unique<MockNode>());
+  auto *ownerA = graph->addNode(std::make_unique<MockNode>());
+  auto *ownerB = graph->addNode(std::make_unique<MockNode>());
+  auto *paramA = reinterpret_cast<AudioParam *>(0xA);
+  auto *paramB = reinterpret_cast<AudioParam *>(0xB);
+
+  ASSERT_TRUE(graph->connectParam(source, ownerA, paramA).is_ok());
+  ASSERT_TRUE(graph->connectParam(source, ownerB, paramB).is_ok());
+  processAll();
+
+  // Disconnect one
+  ASSERT_TRUE(graph->disconnectParam(source, ownerA, paramA).is_ok());
+  processAll();
+
+  // Other bridge should still exist (source → bridge → ownerB)
+  // Disconnected bridge should be compacted away
+
+  // Connect again should work
+  ASSERT_TRUE(graph->connectParam(source, ownerA, paramA).is_ok());
+  processAll();
+}
+
+TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
+  using Processor = audioapi::test::MockGraphProcessor<ProcessableMockNode>;
+  // Pre-allocate node/pool capacity to avoid grow-event allocations inside
+  // the AudioThreadGuard scope.
+  auto sharedGraph = std::make_shared<Graph>(4096, 16, 64);
+  Processor processor(*sharedGraph);
+  processor.start();
+
+  auto *source = sharedGraph->addNode(std::make_unique<ProcessableMockNode>(nullptr, 10));
+  auto *owner = sharedGraph->addNode(std::make_unique<ProcessableMockNode>(nullptr, 20));
+  auto *fakeParam = reinterpret_cast<AudioParam *>(0x42);
+
+  ASSERT_TRUE(sharedGraph->connectParam(source, owner, fakeParam).is_ok());
+
+  // Let processor run a few cycles
+  while (processor.cyclesCompleted() < 10) {
+    std::this_thread::yield();
+  }
+
+  ASSERT_TRUE(sharedGraph->disconnectParam(source, owner, fakeParam).is_ok());
+
+  while (processor.cyclesCompleted() < 20) {
+    std::this_thread::yield();
+  }
+
+  processor.stop();
+  EXPECT_TRUE(processor.allocationClean());
+}
+
+// =========================================================================
+// F. Fuzz test extension with connectParam/disconnectParam
+// =========================================================================
+
+class BridgeFuzzTest : public ::testing::TestWithParam<uint64_t> {
+ protected:
+  using HNode = HostGraph::Node;
+
+  std::shared_ptr<Graph> graph;
+  std::mt19937_64 rng;
+  std::vector<HNode *> liveNodes;
+  std::vector<AudioParam *> fakeParams;
+
+  void SetUp() override {
+    graph = std::make_shared<Graph>(4096);
+    rng.seed(GetParam());
+
+    // Create a set of fake param pointers
+    for (int i = 1; i <= 8; i++) {
+      fakeParams.push_back(reinterpret_cast<AudioParam *>(static_cast<uintptr_t>(i * 0x100)));
+    }
+  }
+
+  void processAll() {
+    graph->processEvents();
+    graph->process();
+  }
+
+  HNode *pickRandom() {
+    if (liveNodes.empty())
+      return nullptr;
+    return liveNodes[std::uniform_int_distribution<size_t>(0, liveNodes.size() - 1)(rng)];
+  }
+
+  AudioParam *pickParam() {
+    return fakeParams[std::uniform_int_distribution<size_t>(0, fakeParams.size() - 1)(rng)];
+  }
+};
+
+TEST_P(BridgeFuzzTest, RandomParamOps) {
+  size_t initialCount = std::uniform_int_distribution<size_t>(4, 16)(rng);
+  size_t opCount = std::uniform_int_distribution<size_t>(50, 200)(rng);
+
+  // Seed nodes
+  for (size_t i = 0; i < initialCount; i++) {
+    liveNodes.push_back(graph->addNode(std::make_unique<MockNode>()));
+  }
+  processAll();
+
+  for (size_t i = 0; i < opCount; i++) {
+    size_t op = std::uniform_int_distribution<size_t>(0, 99)(rng);
+
+    if (op < 10) {
+      // Add node
+      liveNodes.push_back(graph->addNode(std::make_unique<MockNode>()));
+
+    } else if (op < 25) {
+      // Add regular edge
+      auto *a = pickRandom();
+      auto *b = pickRandom();
+      if (a && b && a != b) {
+        (void)graph->addEdge(a, b);
+      }
+
+    } else if (op < 40) {
+      // Connect param
+      auto *source = pickRandom();
+      auto *owner = pickRandom();
+      if (source && owner && source != owner) {
+        (void)graph->connectParam(source, owner, pickParam());
+      }
+
+    } else if (op < 55) {
+      // Disconnect param
+      auto *source = pickRandom();
+      auto *owner = pickRandom();
+      if (source && owner) {
+        (void)graph->disconnectParam(source, owner, pickParam());
+      }
+
+    } else if (op < 70) {
+      // Remove node with bridges
+      auto *n = pickRandom();
+      if (n) {
+        (void)graph->removeNodeWithBridges(n);
+        liveNodes.erase(std::remove(liveNodes.begin(), liveNodes.end(), n), liveNodes.end());
+      }
+
+    } else if (op < 85) {
+      // Remove regular edge
+      auto *a = pickRandom();
+      auto *b = pickRandom();
+      if (a && b) {
+        (void)graph->removeEdge(a, b);
+      }
+
+    } else {
+      // Process
+      processAll();
+    }
+  }
+
+  // Final process — should not crash or produce bad state
+  processAll();
+
+  // Verify iter doesn't crash
+  for (auto &&[graphObject, inputs] : graph->iter()) {
+    (void)graphObject;
+    for (const auto &input : inputs) {
+      (void)input;
+    }
+  }
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Seeds,
+    BridgeFuzzTest,
+    ::testing::Range(uint64_t{0}, uint64_t{100}),
+    [](const ::testing::TestParamInfo<uint64_t> &info) {
+      return "seed_" + std::to_string(info.param);
+    });
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
index bc010d593..ded44520d 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
@@ -8,6 +8,7 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
+#include <audioapi/core/utils/graph/BridgeNode.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/core/utils/graph/HostNode.hpp>
 #include <test/src/MockAudioEventHandlerRegistry.h>
@@ -58,6 +59,20 @@ struct MockNode : AudioNode {
   std::atomic<bool> destructible_;
 };
 
+// ── NonProcessableMockNode ────────────────────────────────────────────────
+// Pure GraphObject subclass that is not processable. Used to test
+// iter() filtering at the AudioGraph level without depending on BridgeNode.
+
+struct NonProcessableMockNode : GraphObject {
+  [[nodiscard]] bool isProcessable() const override {
+    return false;
+  }
+
+  [[nodiscard]] bool canBeDestructed() const override {
+    return true;
+  }
+};
+
 // ── MockHostNode ──────────────────────────────────────────────────────────
 // RAII wrapper around HostNode for testing the HostNode lifecycle.
 
diff --git a/packages/react-native-audio-api/scripts/cpplint.sh b/packages/react-native-audio-api/scripts/cpplint.sh
index 306b75c7a..bc8881917 100755
--- a/packages/react-native-audio-api/scripts/cpplint.sh
+++ b/packages/react-native-audio-api/scripts/cpplint.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 if which cpplint >/dev/null; then
-  find common/cpp android/src/main/cpp -path 'common/cpp/audioapi/libs' -prune -o -path 'common/cpp/audioapi/external' -prune -o -path 'common/cpp/audioapi/dsp/r8brain' -prune -o \( -name '*.cpp' -o -name '*.h' -o -name '*.hpp' \) -print | xargs cpplint --linelength=100 --filter=-legal/copyright,-readability/todo,-build/namespaces,-build/include_order,-whitespace,-build/c++17,-build/c++20,-runtime/references,-runtime/string,-readability/braces --quiet --recursive "$@"
+  find common/cpp android/src/main/cpp -path 'common/cpp/audioapi/libs' -prune -o -path 'common/cpp/audioapi/external' -prune -o -path 'common/cpp/audioapi/dsp/r8brain' -prune -o -path 'common/cpp/test/build' -prune -o \( -name '*.cpp' -o -name '*.h' -o -name '*.hpp' \) -print | xargs cpplint --linelength=100 --filter=-legal/copyright,-readability/todo,-build/namespaces,-build/include_order,-whitespace,-build/c++17,-build/c++20,-runtime/references,-runtime/string,-readability/braces --quiet --recursive "$@"
 else
   echo "error: cpplint not installed, download from https://github.com/cpplint/cpplint" 1>&2
   exit 1

From d9d1791b6f78f78e99b8eb6d34c5d46350f2ef62 Mon Sep 17 00:00:00 2001
From: poneciak <poneciak@gmail.com>
Date: Mon, 23 Mar 2026 12:44:03 +0100
Subject: [PATCH 04/38] fix: changed from shared_ptr to using unique_ptr for
 singly owned components

---
 .../common/cpp/audioapi/core/BaseAudioContext.cpp   | 13 +++++++------
 .../common/cpp/audioapi/core/BaseAudioContext.h     |  9 +++++----
 .../cpp/audioapi/core/effects/ConvolverNode.cpp     |  3 ---
 .../core/sources/AudioBufferQueueSourceNode.cpp     |  3 ---
 .../audioapi/core/sources/AudioBufferSourceNode.cpp |  3 ---
 .../cpp/audioapi/core/utils/AudioGraphManager.cpp   |  5 +++--
 .../cpp/audioapi/core/utils/AudioGraphManager.h     |  6 ++++--
 .../common/cpp/audioapi/core/utils/Constants.h      |  3 +++
 8 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 7d5ac63c1..1f62ef555 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -41,8 +41,9 @@ BaseAudioContext::BaseAudioContext(
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry),
       audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
-      disposer_(std::make_shared<utils::DisposerImpl<16>>(AUDIO_SCHEDULER_CAPACITY)),
-      graphManager_(std::make_shared<AudioGraphManager>(disposer_)) {}
+      disposer_(
+          std::make_unique<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>>(AUDIO_SCHEDULER_CAPACITY)),
+      graphManager_(std::make_unique<AudioGraphManager>(this)) {}
 
 void BaseAudioContext::initialize() {
   destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
@@ -245,8 +246,8 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType
   }
 }
 
-std::shared_ptr<AudioGraphManager> BaseAudioContext::getGraphManager() const {
-  return graphManager_;
+AudioGraphManager *BaseAudioContext::getGraphManager() const {
+  return graphManager_.get();
 }
 
 std::shared_ptr<IAudioEventHandlerRegistry> BaseAudioContext::getAudioEventHandlerRegistry() const {
@@ -257,8 +258,8 @@ const RuntimeRegistry &BaseAudioContext::getRuntimeRegistry() const {
   return runtimeRegistry_;
 }
 
-std::shared_ptr<utils::DisposerImpl<16>> BaseAudioContext::getDisposer() const {
-  return disposer_;
+utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *BaseAudioContext::getDisposer() const {
+  return disposer_.get();
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 23a72ab07..b4c4a9f70 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -2,6 +2,7 @@
 
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioBuffer.hpp>
@@ -105,10 +106,10 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<WaveShaperNode> createWaveShaper(const WaveShaperOptions &options);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
-  std::shared_ptr<AudioGraphManager> getGraphManager() const;
+  AudioGraphManager *getGraphManager() const;
   std::shared_ptr<IAudioEventHandlerRegistry> getAudioEventHandlerRegistry() const;
   const RuntimeRegistry &getRuntimeRegistry() const;
-  std::shared_ptr<utils::DisposerImpl<16>> getDisposer() const;
+  utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *getDisposer() const;
 
   virtual void initialize();
 
@@ -143,8 +144,8 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
-  std::shared_ptr<utils::DisposerImpl<16>> disposer_;
-  std::shared_ptr<AudioGraphManager> graphManager_;
+  std::unique_ptr<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>> disposer_;
+  std::unique_ptr<AudioGraphManager> graphManager_;
 
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
 };
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index e24fd348f..58adf4441 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -1,6 +1,5 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/ConvolverNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
@@ -37,8 +36,6 @@ void ConvolverNode::setBuffer(
     return;
   }
 
-  auto graphManager = context->getGraphManager();
-
   if (buffer_ != nullptr) {
     context->getDisposer()->dispose(std::move(buffer_));
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
index 260688e8e..14cbb63da 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
@@ -1,7 +1,6 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.hpp>
@@ -78,8 +77,6 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
       return;
     }
 
-    auto graphManager = context->getGraphManager();
-
     if (buffers_.front().first == bufferId) {
       context->getDisposer()->dispose(std::move(buffers_.front().second));
       buffers_.pop_front();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index 0fce4ca90..acd85fa9b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -1,7 +1,6 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/AudioUtils.hpp>
@@ -55,8 +54,6 @@ void AudioBufferSourceNode::setBuffer(
     return;
   }
 
-  auto graphManager = context->getGraphManager();
-
   if (buffer_ != nullptr) {
     context->getDisposer()->dispose(std::move(buffer_));
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
index 0f6dffd92..453171738 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
@@ -1,5 +1,6 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/ConvolverNode.h>
 #include <audioapi/core/effects/DelayNode.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
@@ -72,8 +73,8 @@ AudioGraphManager::Event::~Event() {
   }
 }
 
-AudioGraphManager::AudioGraphManager(const std::shared_ptr<utils::DisposerImpl<16>> &disposer)
-    : disposer_(disposer) {
+AudioGraphManager::AudioGraphManager(BaseAudioContext *context)
+    : disposer_(context->getDisposer()) {
   sourceNodes_.reserve(kInitialCapacity);
   processingNodes_.reserve(kInitialCapacity);
   audioParams_.reserve(kInitialCapacity);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
index dacdf45f1..7b51eed0b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/SpscChannel.hpp>
@@ -14,6 +15,7 @@ namespace audioapi {
 class AudioNode;
 class AudioScheduledSourceNode;
 class AudioParam;
+class BaseAudioContext;
 
 #define AUDIO_GRAPH_MANAGER_SPSC_OPTIONS \
   std::unique_ptr<Event>, channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
@@ -59,7 +61,7 @@ class AudioGraphManager {
     ~Event();
   };
 
-  explicit AudioGraphManager(const std::shared_ptr<utils::DisposerImpl<16>> &disposer);
+  explicit AudioGraphManager(BaseAudioContext *context);
   ~AudioGraphManager();
 
   void preProcessGraph();
@@ -102,7 +104,7 @@ class AudioGraphManager {
   void cleanup();
 
  private:
-  const std::shared_ptr<utils::DisposerImpl<16>> disposer_;
+  utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *const disposer_;
 
   /// @brief Initial capacity for various node types for deletion
   /// @note Higher capacity decreases number of reallocations at runtime (can be easily adjusted to 128 if needed)
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
index 79a9a3f69..319e0067a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
@@ -30,6 +30,9 @@ inline float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FL
 inline float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
 inline constexpr float PI = std::numbers::pi_v<float>;
 
+// disposer
+inline constexpr size_t DISPOSER_PAYLOAD_SIZE = 16;
+
 // buffer sizes
 inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;
 inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE = 32;

From 52d274dae1bad2ee5ac56ce8f433ceeb564ce05c Mon Sep 17 00:00:00 2001
From: poneciak <poneciak@gmail.com>
Date: Mon, 23 Mar 2026 13:11:48 +0100
Subject: [PATCH 05/38] feat: moved disposer out of graph class

---
 .../common/cpp/audioapi/core/utils/graph/Graph.hpp   | 12 ++++++------
 .../common/cpp/test/src/graph/BridgeNodeTest.cpp     | 10 +++++++---
 .../common/cpp/test/src/graph/GraphFuzzTest.cpp      |  5 ++++-
 .../common/cpp/test/src/graph/GraphTest.cpp          |  4 +++-
 4 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 90daad974..c272bc315 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -55,10 +55,11 @@ class Graph {
   using HNode = HostGraph::Node;
 
  public:
+  static constexpr size_t kDisposerPayloadSize = HostGraph::kDisposerPayloadSize;
   using ResultError = HostGraph::ResultError;
   using Res = Result<NoneType, ResultError>;
 
-  explicit Graph(size_t eventQueueCapacity) {
+  Graph(size_t eventQueueCapacity, Disposer<kDisposerPayloadSize> *disposer) : disposer_(disposer) {
     using namespace audioapi::channels::spsc;
 
     auto [es, er] = channel<AGEvent, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::BUSY_LOOP>(
@@ -69,9 +70,10 @@ class Graph {
 
   Graph(
       size_t eventQueueCapacity,
+      Disposer<kDisposerPayloadSize> *disposer,
       std::uint32_t initialNodeCapacity,
       std::uint32_t initialEdgeCapacity)
-      : Graph(eventQueueCapacity) {
+      : Graph(eventQueueCapacity, disposer) {
     if (initialNodeCapacity > 0) {
       audioGraph.reserveNodes(initialNodeCapacity);
       nodeCapacity_ = initialNodeCapacity;
@@ -97,7 +99,7 @@ class Graph {
     AGEvent event;
     while (eventReceiver_.try_receive(event) == audioapi::channels::spsc::ResponseStatus::SUCCESS) {
       if (event) {
-        event(audioGraph, disposer_);
+        event(audioGraph, *disposer_);
       }
     }
   }
@@ -281,8 +283,6 @@ class Graph {
   }
 
  private:
-  static constexpr size_t kDisposerPayloadSize = HostGraph::kDisposerPayloadSize;
-
   using OwnedSlotBuffer = std::unique_ptr<InputPool::Slot[]>;
 
   // Aligning to cache line size to prevent false sharing between audio and main thread
@@ -296,7 +296,7 @@ class Graph {
 
   // ── Disposer — destroys old pool buffers off the audio thread ───────────
 
-  DisposerImpl<kDisposerPayloadSize> disposer_{64};
+  Disposer<kDisposerPayloadSize> *disposer_;
 
   // ── Main-thread tracking for pre-growth ─────────────────────────────────
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
index 024eae045..3751ef8ea 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
@@ -320,10 +320,12 @@ TEST_F(BridgeGraphTest, BridgeOrphanedAndNoInputsGetsCompacted) {
 
 class BridgeGraphWrapperTest : public ::testing::Test {
  protected:
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  DisposerImpl<kPayloadSize> disposer_{64};
   std::shared_ptr<Graph> graph;
 
   void SetUp() override {
-    graph = std::make_shared<Graph>(4096);
+    graph = std::make_shared<Graph>(4096, &disposer_);
   }
 
   void processAll() {
@@ -465,7 +467,7 @@ TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
   using Processor = audioapi::test::MockGraphProcessor<ProcessableMockNode>;
   // Pre-allocate node/pool capacity to avoid grow-event allocations inside
   // the AudioThreadGuard scope.
-  auto sharedGraph = std::make_shared<Graph>(4096, 16, 64);
+  auto sharedGraph = std::make_shared<Graph>(4096, &disposer_, 16, 64);
   Processor processor(*sharedGraph);
   processor.start();
 
@@ -497,14 +499,16 @@ TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
 class BridgeFuzzTest : public ::testing::TestWithParam<uint64_t> {
  protected:
   using HNode = HostGraph::Node;
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
 
+  DisposerImpl<kPayloadSize> disposer_{64};
   std::shared_ptr<Graph> graph;
   std::mt19937_64 rng;
   std::vector<HNode *> liveNodes;
   std::vector<AudioParam *> fakeParams;
 
   void SetUp() override {
-    graph = std::make_shared<Graph>(4096);
+    graph = std::make_shared<Graph>(4096, &disposer_);
     rng.seed(GetParam());
 
     // Create a set of fake param pointers
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
index 340bcba25..3ce789910 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
@@ -15,6 +15,7 @@
 
 using namespace audioapi::utils::graph;
 using audioapi::test::MockGraphProcessor;
+using audioapi::utils::DisposerImpl;
 
 // =========================================================================
 // Fixture — parameterized by seed for reproducible randomized testing
@@ -27,6 +28,8 @@ class GraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
   using Res = Graph::Res;
   using ResultError = Graph::ResultError;
 
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  DisposerImpl<kPayloadSize> disposer_{64};
   std::mt19937_64 rng;
   std::unique_ptr<Graph> graph;
   std::vector<HNode *> nodes; // tracks live (non-removed) nodes
@@ -49,7 +52,7 @@ class GraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
     // Ensure graph growth does not happen on the audio thread during this fuzz run.
     const auto maxNodes = static_cast<std::uint32_t>(initialNodeCount + operationCount + 64);
     const auto maxEdges = static_cast<std::uint32_t>(operationCount * 2 + 64);
-    graph = std::make_unique<Graph>(4096, maxNodes, maxEdges);
+    graph = std::make_unique<Graph>(4096, &disposer_, maxNodes, maxEdges);
 
     // Randomly partition the range 0..99 into 4 operation weights
     size_t total = 100;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
index cb0ad3a71..db8943cbe 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
@@ -13,10 +13,12 @@ namespace audioapi::utils::graph {
 
 class GraphTest : public ::testing::Test {
  protected:
+  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  DisposerImpl<kPayloadSize> disposer_{64};
   std::unique_ptr<Graph> graph;
 
   void SetUp() override {
-    graph = std::make_unique<Graph>(4096);
+    graph = std::make_unique<Graph>(4096, &disposer_);
   }
 
   const AudioGraph &getAudioGraph() {

From c60753497d9a62ec8bc98d1fd05c9f2f1173da62 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 24 Mar 2026 09:09:52 +0100
Subject: [PATCH 06/38] refactor: template nitpick

---
 .../common/cpp/audioapi/core/utils/graph/Graph.hpp              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index c272bc315..2f945d6c0 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -139,7 +139,7 @@ class Graph {
     return hostNode;
   }
 
-  template <typename TObject, typename = std::enable_if_t<std::derived_from<TObject, GraphObject>>>
+  template <std::derived_from<GraphObject> TObject>
   HNode *addNode(std::unique_ptr<TObject> audioNode) {
     return addNode(std::unique_ptr<GraphObject>(std::move(audioNode)));
   }

From 971bf3613e2d6a945919e2184f418a462afb60c1 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:52:03 +0100
Subject: [PATCH 07/38] refactor: update AudioNodeHostObject to use Graph and
 HostNode

---
 .../HostObjects/AudioNodeHostObject.cpp       |  19 ++-
 .../HostObjects/AudioNodeHostObject.h         |   9 +-
 .../BaseAudioContextHostObject.cpp            |  61 +++-----
 .../analysis/AnalyserNodeHostObject.cpp       |  42 +++--
 .../AudioDestinationNodeHostObject.h          |   7 +-
 .../effects/BiquadFilterNodeHostObject.cpp    |  17 ++-
 .../effects/ConvolverNodeHostObject.cpp       |  11 +-
 .../effects/DelayNodeHostObject.cpp           |   9 +-
 .../effects/GainNodeHostObject.cpp            |   7 +-
 .../effects/IIRFilterNodeHostObject.cpp       |   7 +-
 .../effects/StereoPannerNodeHostObject.cpp    |   7 +-
 .../effects/WaveShaperNodeHostObject.cpp      |  19 ++-
 .../effects/WorkletNodeHostObject.h           |  18 ++-
 .../effects/WorkletProcessingNodeHostObject.h |  14 +-
 .../inputs/AudioRecorderHostObject.cpp        |   4 +-
 .../AudioBufferBaseSourceNodeHostObject.cpp   |  38 +++--
 .../AudioBufferBaseSourceNodeHostObject.h     |   3 +-
 .../AudioBufferQueueSourceNodeHostObject.cpp  |  66 +++++---
 .../AudioBufferSourceNodeHostObject.cpp       |  66 +++++---
 .../AudioScheduledSourceNodeHostObject.cpp    |  29 ++--
 .../AudioScheduledSourceNodeHostObject.h      |   5 +-
 .../sources/ConstantSourceNodeHostObject.cpp  |   8 +-
 .../sources/OscillatorNodeHostObject.cpp      |  21 ++-
 .../sources/RecorderAdapterNodeHostObject.h   |  10 +-
 .../sources/StreamerNodeHostObject.h          |   5 +-
 .../sources/WorkletSourceNodeHostObject.h     |  17 ++-
 .../cpp/audioapi/core/BaseAudioContext.cpp    | 143 ++----------------
 .../cpp/audioapi/core/BaseAudioContext.h      |  38 +----
 .../audioapi/core/utils/AudioGraphManager.h   |   3 +-
 .../cpp/audioapi/core/utils/Constants.h       |   3 -
 .../audioapi/core/utils/graph/HostGraph.hpp   |   4 +-
 .../audioapi/core/utils/graph/HostNode.hpp    |  10 +-
 32 files changed, 346 insertions(+), 374 deletions(-)

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
index c00abef23..ccfb5fd34 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -4,13 +4,15 @@
 #include <audioapi/core/AudioNode.h>
 
 #include <memory>
+#include <utility>
 
 namespace audioapi {
 
 AudioNodeHostObject::AudioNodeHostObject(
-    const std::shared_ptr<AudioNode> &node,
+    const std::shared_ptr<utils::graph::Graph> &graph,
+    std::unique_ptr<AudioNode> node,
     const AudioNodeOptions &options)
-    : node_(node),
+    : utils::graph::HostNode(graph, std::move(node)),
       numberOfInputs_(options.numberOfInputs),
       numberOfOutputs_(options.numberOfOutputs),
       channelCount_(options.channelCount),
@@ -60,29 +62,32 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    connectNode(*node);
   }
   if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    node_->connect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    // TODO
+    // connectParam(*param->owner_, param->param_.get());
   }
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
   if (args[0].isUndefined()) {
-    node_->disconnect();
+    // TODO
+    // node_->disconnect();
     return jsi::Value::undefined();
   }
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioNodeHostObject>(node)->node_);
+    disconnectNode(*node);
   }
 
   if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    node_->disconnect(std::shared_ptr<AudioParamHostObject>(param)->param_);
+    // TODO
+    // disconnectParam(*param->owner_, param->param_.get());
   }
   return jsi::Value::undefined();
 }
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
index 5b8c12d3c..b1841021a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
@@ -2,6 +2,8 @@
 
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/HostNode.hpp>
 #include <audioapi/jsi/JsiHostObject.h>
 #include <audioapi/types/NodeOptions.h>
 
@@ -13,10 +15,11 @@ using namespace facebook;
 
 class AudioNode;
 
-class AudioNodeHostObject : public JsiHostObject {
+class AudioNodeHostObject : public JsiHostObject, public utils::graph::HostNode {
  public:
   explicit AudioNodeHostObject(
-      const std::shared_ptr<AudioNode> &node,
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      std::unique_ptr<AudioNode> node,
       const AudioNodeOptions &options = AudioNodeOptions());
   ~AudioNodeHostObject() override;
 
@@ -30,8 +33,6 @@ class AudioNodeHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(disconnect);
 
  protected:
-  std::shared_ptr<AudioNode> node_;
-
   const int numberOfInputs_;
   const int numberOfOutputs_;
   size_t channelCount_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index f4c22c8b2..7c8f17a33 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -36,7 +36,8 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       promiseVendor_(std::make_shared<PromiseVendor>(runtime, callInvoker)),
       callInvoker_(callInvoker) {
   context_->initialize();
-  destination_ = std::make_shared<AudioDestinationNodeHostObject>(context_->getDestination());
+  // TODO
+  // destination_ = std::make_shared<AudioDestinationNodeHostObject>(context_->getGraph(), context_->getDestination());
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
@@ -92,19 +93,13 @@ 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();
-  auto shouldLockRuntime = shouldUseUiRuntime;
-  if (shouldUseUiRuntime) {
-    workletRuntime = context_->getRuntimeRegistry().uiRuntime;
-  } else {
-    workletRuntime = context_->getRuntimeRegistry().audioRuntime;
-  }
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime = shouldUseUiRuntime
+      ? context_->getRuntimeRegistry().uiRuntime
+      : context_->getRuntimeRegistry().audioRuntime;
 
-  auto workletSourceNode =
-      context_->createWorkletSourceNode(shareableWorklet, workletRuntime, shouldLockRuntime);
-  auto workletSourceNodeHostObject =
-      std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
+  auto workletSourceNodeHostObject = std::make_shared<WorkletSourceNodeHostObject>(
+      context_->getGraph(), context_, workletRuntime, shareableWorklet, shouldUseUiRuntime);
   return jsi::Object::createFromHostObject(runtime, workletSourceNodeHostObject);
 #endif
   return jsi::Value::undefined();
@@ -114,21 +109,21 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
 #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();
-  auto shouldLockRuntime = shouldUseUiRuntime;
-  if (shouldUseUiRuntime) {
-    workletRuntime = context_->getRuntimeRegistry().uiRuntime;
-  } else {
-    workletRuntime = context_->getRuntimeRegistry().audioRuntime;
-  }
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime = shouldUseUiRuntime
+      ? context_->getRuntimeRegistry().uiRuntime
+      : context_->getRuntimeRegistry().audioRuntime;
   auto bufferLength = static_cast<size_t>(args[2].getNumber());
   auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
 
-  auto workletNode = context_->createWorkletNode(
-      shareableWorklet, workletRuntime, bufferLength, inputChannelCount, shouldLockRuntime);
-  auto workletNodeHostObject = std::make_shared<WorkletNodeHostObject>(workletNode);
+  auto workletNodeHostObject = std::make_shared<WorkletNodeHostObject>(
+      context_->getGraph(),
+      context_,
+      workletRuntime,
+      shareableWorklet,
+      shouldUseUiRuntime,
+      bufferLength,
+      inputChannelCount);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
   jsiObject.setExternalMemoryPressure(
       runtime,
@@ -142,28 +137,20 @@ 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();
-  auto shouldLockRuntime = shouldUseUiRuntime;
-  if (shouldUseUiRuntime) {
-    workletRuntime = context_->getRuntimeRegistry().uiRuntime;
-  } else {
-    workletRuntime = context_->getRuntimeRegistry().audioRuntime;
-  }
+  std::weak_ptr<worklets::WorkletRuntime> workletRuntime = shouldUseUiRuntime
+      ? context_->getRuntimeRegistry().uiRuntime
+      : context_->getRuntimeRegistry().audioRuntime;
 
-  auto workletProcessingNode =
-      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime, shouldLockRuntime);
-  auto workletProcessingNodeHostObject =
-      std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
+  auto workletProcessingNodeHostObject = std::make_shared<WorkletProcessingNodeHostObject>(
+      context_->getGraph(), context_, workletRuntime, shareableWorklet, shouldUseUiRuntime);
   return jsi::Object::createFromHostObject(runtime, workletProcessingNodeHostObject);
 #endif
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
-  auto recorderAdapter = context_->createRecorderAdapter();
-  auto recorderAdapterHostObject = std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
+  auto recorderAdapterHostObject = std::make_shared<RecorderAdapterNodeHostObject>(context_);
   return jsi::Object::createFromHostObject(runtime, recorderAdapterHostObject);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp
index 2ba7ce41d..9740f3692 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp
@@ -11,7 +11,10 @@ namespace audioapi {
 AnalyserNodeHostObject::AnalyserNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const AnalyserOptions &options)
-    : AudioNodeHostObject(context->createAnalyser(options), options) {
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<AnalyserNode>(context, options),
+          options) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
@@ -32,48 +35,43 @@ AnalyserNodeHostObject::AnalyserNodeHostObject(
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, fftSize) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   return {analyserNode->getFFTSize()};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, minDecibels) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   return {analyserNode->getMinDecibels()};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, maxDecibels) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   return {analyserNode->getMaxDecibels()};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   return {analyserNode->getSmoothingTimeConstant()};
 }
 
 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 analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
+  analyserNode->setFFTSize(static_cast<int>(value.getNumber()));
 }
 
 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 analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
+  analyserNode->setMinDecibels(static_cast<float>(value.getNumber()));
 }
 
 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 analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
+  analyserNode->setMaxDecibels(static_cast<float>(value.getNumber()));
 }
 
 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 analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
+  analyserNode->setSmoothingTimeConstant(static_cast<float>(value.getNumber()));
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
@@ -82,7 +80,7 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
   auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime) / sizeof(float));
 
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   analyserNode->getFloatFrequencyData(data, length);
 
   return jsi::Value::undefined();
@@ -94,7 +92,7 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteFrequencyData) {
   auto data = arrayBuffer.data(runtime);
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   analyserNode->getByteFrequencyData(data, length);
 
   return jsi::Value::undefined();
@@ -106,7 +104,7 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatTimeDomainData) {
   auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime) / sizeof(float));
 
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   analyserNode->getFloatTimeDomainData(data, length);
 
   return jsi::Value::undefined();
@@ -118,7 +116,7 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteTimeDomainData) {
   auto data = arrayBuffer.data(runtime);
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 
-  auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
+  auto analyserNode = static_cast<AnalyserNode *>(node_->handle->audioNode->asAudioNode());
   analyserNode->getByteTimeDomainData(data, length);
 
   return jsi::Value::undefined();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
index 05fa272b9..0cfc0e330 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
@@ -5,13 +5,16 @@
 #include <audioapi/types/NodeOptions.h>
 
 #include <memory>
+#include <utility>
 
 namespace audioapi {
 using namespace facebook;
 
 class AudioDestinationNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit AudioDestinationNodeHostObject(const std::shared_ptr<AudioDestinationNode> &node)
-      : AudioNodeHostObject(node, AudioDestinationOptions()) {}
+  explicit AudioDestinationNodeHostObject(
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      std::unique_ptr<AudioNode> node)
+      : AudioNodeHostObject(graph, std::move(node), AudioDestinationOptions()) {}
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp
index dd555eece..1e111e91f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp
@@ -14,8 +14,12 @@ namespace audioapi {
 BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const BiquadFilterOptions &options)
-    : AudioNodeHostObject(context->createBiquadFilter(options), options), type_(options.type) {
-  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<BiquadFilterNode>(context, options),
+          options),
+      type_(options.type) {
+  auto biquadFilterNode = static_cast<BiquadFilterNode *>(node_->handle->audioNode->asAudioNode());
   frequencyParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getFrequencyParam());
   detuneParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getDetuneParam());
   QParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
@@ -54,11 +58,12 @@ JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, type) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(BiquadFilterNodeHostObject, type) {
-  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto handle = node_->handle;
+  auto biquadFilterNode = static_cast<BiquadFilterNode *>(handle->audioNode->asAudioNode());
 
   auto type = js_enum_parser::filterTypeFromString(value.asString(runtime).utf8(runtime));
-  auto event = [biquadFilterNode, type](BaseAudioContext &) {
-    biquadFilterNode->setType(type);
+  auto event = [handle, type](BaseAudioContext &) {
+    static_cast<BiquadFilterNode *>(handle->audioNode->asAudioNode())->setType(type);
   };
   biquadFilterNode->scheduleAudioEvent(std::move(event));
   type_ = type;
@@ -78,7 +83,7 @@ JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {
       args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
 
-  auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
+  auto biquadFilterNode = static_cast<BiquadFilterNode *>(node_->handle->audioNode->asAudioNode());
   biquadFilterNode->getFrequencyResponse(
       frequencyArray, magResponseOut, phaseResponseOut, length, type_);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
index 383a00f49..f22cfa019 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
@@ -18,7 +18,10 @@ namespace audioapi {
 ConvolverNodeHostObject::ConvolverNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const ConvolverOptions &options)
-    : AudioNodeHostObject(context->createConvolver(options), options),
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<ConvolverNode>(context, options),
+          options),
       normalize_(!options.disableNormalization) {
   if (options.buffer != nullptr) {
     setBuffer(options.buffer);
@@ -57,7 +60,8 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
     return;
   }
 
-  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  auto handle = node_->handle;
+  auto convolverNode = static_cast<ConvolverNode *>(handle->audioNode->asAudioNode());
 
   auto copiedBuffer = std::make_shared<AudioBuffer>(*buffer);
 
@@ -102,7 +106,8 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
       intermediateBuffer,
       scaleFactor});
 
-  auto event = [convolverNode, setupData](BaseAudioContext &) {
+  auto event = [handle, setupData](BaseAudioContext &) {
+    auto convolverNode = static_cast<ConvolverNode *>(handle->audioNode->asAudioNode());
     convolverNode->setBuffer(
         setupData->buffer,
         std::move(setupData->convolvers),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
index 49220a93e..7467f61be 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
@@ -11,8 +11,11 @@ namespace audioapi {
 DelayNodeHostObject::DelayNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const DelayOptions &options)
-    : AudioNodeHostObject(context->createDelay(options), options) {
-  auto delayNode = std::static_pointer_cast<DelayNode>(node_);
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<DelayNode>(context, options),
+          options) {
+  auto delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
   delayTimeParam_ = std::make_shared<AudioParamHostObject>(delayNode->getDelayTimeParam());
   addGetters(JSI_EXPORT_PROPERTY_GETTER(DelayNodeHostObject, delayTime));
 }
@@ -22,7 +25,7 @@ JSI_PROPERTY_GETTER_IMPL(DelayNodeHostObject, delayTime) {
 }
 
 size_t DelayNodeHostObject::getSizeInBytes() const {
-  auto delayNode = std::static_pointer_cast<DelayNode>(node_);
+  auto delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
   auto base = sizeof(float) * delayNode->getDelayTimeParam()->getMaxValue();
   return base * delayNode->getContextSampleRate();
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp
index ecacc7dc5..d33c16fd8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp
@@ -11,8 +11,11 @@ namespace audioapi {
 GainNodeHostObject::GainNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const GainOptions &options)
-    : AudioNodeHostObject(context->createGain(options), options) {
-  auto gainNode = std::static_pointer_cast<GainNode>(node_);
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<GainNode>(context, options),
+          options) {
+  auto gainNode = static_cast<GainNode *>(node_->handle->audioNode->asAudioNode());
   gainParam_ = std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(GainNodeHostObject, gain));
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.cpp
index 4299665fa..7d6923b7c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.cpp
@@ -9,7 +9,10 @@ namespace audioapi {
 IIRFilterNodeHostObject::IIRFilterNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const IIRFilterOptions &options)
-    : AudioNodeHostObject(context->createIIRFilter(options), options) {
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<IIRFilterNode>(context, options),
+          options) {
 
   addFunctions(JSI_EXPORT_FUNCTION(IIRFilterNodeHostObject, getFrequencyResponse));
 }
@@ -28,7 +31,7 @@ JSI_HOST_FUNCTION_IMPL(IIRFilterNodeHostObject, getFrequencyResponse) {
       args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
 
-  auto iirFilterNode = std::static_pointer_cast<IIRFilterNode>(node_);
+  auto iirFilterNode = static_cast<IIRFilterNode *>(node_->handle->audioNode->asAudioNode());
   iirFilterNode->getFrequencyResponse(frequencyArray, magResponseOut, phaseResponseOut, length);
 
   return jsi::Value::undefined();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp
index f9e50b9cd..77c6a76f9 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp
@@ -11,8 +11,11 @@ namespace audioapi {
 StereoPannerNodeHostObject::StereoPannerNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const StereoPannerOptions &options)
-    : AudioNodeHostObject(context->createStereoPanner(options), options) {
-  auto stereoPannerNode = std::static_pointer_cast<StereoPannerNode>(node_);
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<StereoPannerNode>(context, options),
+          options) {
+  auto stereoPannerNode = static_cast<StereoPannerNode *>(node_->handle->audioNode->asAudioNode());
   panParam_ = std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(StereoPannerNodeHostObject, pan));
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp
index 27d26d7bc..f61381c8d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp
@@ -12,7 +12,10 @@ namespace audioapi {
 WaveShaperNodeHostObject::WaveShaperNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const WaveShaperOptions &options)
-    : AudioNodeHostObject(context->createWaveShaper(options), options),
+    : AudioNodeHostObject(
+          context->getGraph(),
+          std::make_unique<WaveShaperNode>(context, options),
+          options),
       oversample_(options.oversample) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, oversample));
   addSetters(JSI_EXPORT_PROPERTY_SETTER(WaveShaperNodeHostObject, oversample));
@@ -24,18 +27,20 @@ JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, oversample) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(WaveShaperNodeHostObject, oversample) {
-  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  auto handle = node_->handle;
+  auto waveShaperNode = static_cast<WaveShaperNode *>(handle->audioNode->asAudioNode());
 
   auto oversample = js_enum_parser::overSampleTypeFromString(value.asString(runtime).utf8(runtime));
-  auto event = [waveShaperNode, oversample](BaseAudioContext &) {
-    waveShaperNode->setOversample(oversample);
+  auto event = [handle, oversample](BaseAudioContext &) {
+    static_cast<WaveShaperNode *>(handle->audioNode->asAudioNode())->setOversample(oversample);
   };
   waveShaperNode->scheduleAudioEvent(std::move(event));
   oversample_ = oversample;
 }
 
 JSI_HOST_FUNCTION_IMPL(WaveShaperNodeHostObject, setCurve) {
-  auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
+  auto handle = node_->handle;
+  auto waveShaperNode = static_cast<WaveShaperNode *>(handle->audioNode->asAudioNode());
 
   std::shared_ptr<AudioArray> curve = nullptr;
 
@@ -50,8 +55,8 @@ JSI_HOST_FUNCTION_IMPL(WaveShaperNodeHostObject, setCurve) {
         std::make_shared<AudioArray>(reinterpret_cast<float *>(arrayBuffer.data(runtime)), size);
   }
 
-  auto event = [waveShaperNode, curve](BaseAudioContext &) {
-    waveShaperNode->setCurve(curve);
+  auto event = [handle, curve](BaseAudioContext &) {
+    static_cast<WaveShaperNode *>(handle->audioNode->asAudioNode())->setCurve(curve);
   };
   waveShaperNode->scheduleAudioEvent(std::move(event));
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h
index 1ee3e2e4e..a6ba1448a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h
@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/effects/WorkletNode.h>
+#include <audioapi/core/utils/graph/Graph.hpp>
 
 #include <memory>
 
@@ -10,7 +11,20 @@ using namespace facebook;
 
 class WorkletNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit WorkletNodeHostObject(const std::shared_ptr<WorkletNode> &node)
-      : AudioNodeHostObject(node) {}
+  explicit WorkletNodeHostObject(
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      const std::shared_ptr<BaseAudioContext> &context,
+      std::weak_ptr<worklets::WorkletRuntime> workletRuntime,
+      const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      bool shouldLockRuntime,
+      size_t bufferLength,
+      size_t inputChannelCount)
+      : AudioNodeHostObject(
+            graph,
+            std::make_unique<WorkletNode>(
+                context,
+                bufferLength,
+                inputChannelCount,
+                WorkletsRunner(workletRuntime, shareableWorklet, shouldLockRuntime))) {}
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h
index 0c17b3cdd..2a7635b52 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h
@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/effects/WorkletProcessingNode.h>
+#include <audioapi/core/utils/graph/Graph.hpp>
 
 #include <memory>
 
@@ -10,7 +11,16 @@ using namespace facebook;
 
 class WorkletProcessingNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit WorkletProcessingNodeHostObject(const std::shared_ptr<WorkletProcessingNode> &node)
-      : AudioNodeHostObject(node) {}
+  explicit WorkletProcessingNodeHostObject(
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      const std::shared_ptr<BaseAudioContext> &context,
+      std::weak_ptr<worklets::WorkletRuntime> workletRuntime,
+      const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      bool shouldLockRuntime)
+      : AudioNodeHostObject(
+            graph,
+            std::make_unique<WorkletProcessingNode>(
+                context,
+                WorkletsRunner(workletRuntime, shareableWorklet, shouldLockRuntime))) {}
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
index 2dbbb3d3c..66bf8ce72 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
@@ -133,8 +133,8 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
   auto adapterNodeHostObject =
       args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(runtime);
 
-  audioRecorder_->connect(
-      std::static_pointer_cast<RecorderAdapterNode>(adapterNodeHostObject->node_));
+  // TODO
+  // audioRecorder_->connect(adapterNodeHostObject->adapterNode_);
   return jsi::Value::undefined();
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
index 8f54eac8a..8dea41b50 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
@@ -11,12 +11,14 @@
 namespace audioapi {
 
 AudioBufferBaseSourceNodeHostObject::AudioBufferBaseSourceNodeHostObject(
-    const std::shared_ptr<AudioBufferBaseSourceNode> &node,
+    const std::shared_ptr<utils::graph::Graph> &graph,
+    std::unique_ptr<AudioNode> node,
     const BaseAudioBufferSourceOptions &options)
-    : AudioScheduledSourceNodeHostObject(node, options),
+    : AudioScheduledSourceNodeHostObject(graph, std::move(node), options),
       onPositionChangedInterval_(options.onPositionChangedInterval),
       pitchCorrection_(options.pitchCorrection) {
-  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+  auto sourceNode =
+      static_cast<AudioBufferBaseSourceNode *>(node_->handle->audioNode->asAudioNode());
   detuneParam_ = std::make_shared<AudioParamHostObject>(sourceNode->getDetuneParam());
   playbackRateParam_ = std::make_shared<AudioParamHostObject>(sourceNode->getPlaybackRateParam());
 
@@ -59,11 +61,13 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferBaseSourceNodeHostObject, onPositionChanged)
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioBufferBaseSourceNodeHostObject, onPositionChangedInterval) {
-  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+  auto handle = node_->handle;
+  auto sourceNode = static_cast<AudioBufferBaseSourceNode *>(handle->audioNode->asAudioNode());
   auto interval = static_cast<int>(value.getNumber());
 
-  auto event = [sourceNode, interval](BaseAudioContext &) {
-    sourceNode->setOnPositionChangedInterval(interval);
+  auto event = [handle, interval](BaseAudioContext &) {
+    static_cast<AudioBufferBaseSourceNode *>(handle->audioNode->asAudioNode())
+        ->setOnPositionChangedInterval(interval);
   };
 
   sourceNode->scheduleAudioEvent(std::move(event));
@@ -79,10 +83,12 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferBaseSourceNodeHostObject, getOutputLatency) {
 }
 
 void AudioBufferBaseSourceNodeHostObject::setOnPositionChangedCallbackId(uint64_t callbackId) {
-  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+  auto handle = node_->handle;
+  auto sourceNode = static_cast<AudioBufferBaseSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [sourceNode, callbackId](BaseAudioContext &) {
-    sourceNode->setOnPositionChangedCallbackId(callbackId);
+  auto event = [handle, callbackId](BaseAudioContext &) {
+    static_cast<AudioBufferBaseSourceNode *>(handle->audioNode->asAudioNode())
+        ->setOnPositionChangedCallbackId(callbackId);
   };
 
   sourceNode->unregisterOnPositionChangedCallback(onPositionChangedCallbackId_);
@@ -91,19 +97,21 @@ void AudioBufferBaseSourceNodeHostObject::setOnPositionChangedCallbackId(uint64_
 }
 
 void AudioBufferBaseSourceNodeHostObject::initStretch(int channelCount, float sampleRate) {
-  auto sourceNode = std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+  auto handle = node_->handle;
+  auto sourceNode = static_cast<AudioBufferBaseSourceNode *>(handle->audioNode->asAudioNode());
   auto stretch = std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
   stretch->presetDefault(channelCount, sampleRate);
-  inputLatency_ =
-      std::max(dsp::sampleFrameToTime(stretch->inputLatency(), node_->getContextSampleRate()), 0.0);
+  inputLatency_ = std::max(
+      dsp::sampleFrameToTime(stretch->inputLatency(), sourceNode->getContextSampleRate()), 0.0);
   outputLatency_ = std::max(
-      dsp::sampleFrameToTime(stretch->outputLatency(), node_->getContextSampleRate()), 0.0);
+      dsp::sampleFrameToTime(stretch->outputLatency(), sourceNode->getContextSampleRate()), 0.0);
 
   auto playbackRateBuffer =
       std::make_shared<DSPAudioBuffer>(3 * RENDER_QUANTUM_SIZE, channelCount, sampleRate);
 
-  auto event = [sourceNode, stretch, playbackRateBuffer](BaseAudioContext &) {
-    sourceNode->initStretch(stretch, playbackRateBuffer);
+  auto event = [handle, stretch, playbackRateBuffer](BaseAudioContext &) {
+    static_cast<AudioBufferBaseSourceNode *>(handle->audioNode->asAudioNode())
+        ->initStretch(stretch, playbackRateBuffer);
   };
   sourceNode->scheduleAudioEvent(std::move(event));
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h
index 8f27cf2a6..cf1b7065e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.h
@@ -14,7 +14,8 @@ class AudioParamHostObject;
 class AudioBufferBaseSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
   explicit AudioBufferBaseSourceNodeHostObject(
-      const std::shared_ptr<AudioBufferBaseSourceNode> &node,
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      std::unique_ptr<AudioNode> node,
       const BaseAudioBufferSourceOptions &options);
 
   ~AudioBufferBaseSourceNodeHostObject() override;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp
index 57b071d8c..2db6df4df 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp
@@ -13,7 +13,10 @@ namespace audioapi {
 AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const BaseAudioBufferSourceOptions &options)
-    : AudioBufferBaseSourceNodeHostObject(context->createBufferQueueSource(options), options) {
+    : AudioBufferBaseSourceNodeHostObject(
+          context->getGraph(),
+          std::make_unique<AudioBufferQueueSourceNode>(context, options),
+          options) {
   functions_->erase("start");
 
   addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onBufferEnded));
@@ -39,23 +42,27 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferQueueSourceNodeHostObject, onBufferEnded) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, start) {
-  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
-
-  auto event = [audioBufferQueueSourceNode,
-                when = args[0].getNumber(),
-                offset = args[1].getNumber()](BaseAudioContext &) {
-    audioBufferQueueSourceNode->start(when, offset);
-  };
+  auto handle = node_->handle;
+  auto audioBufferQueueSourceNode =
+      static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode());
+
+  auto event =
+      [handle, when = args[0].getNumber(), offset = args[1].getNumber()](BaseAudioContext &) {
+        static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode())
+            ->start(when, offset);
+      };
   audioBufferQueueSourceNode->scheduleAudioEvent(std::move(event));
 
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, pause) {
-  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferQueueSourceNode =
+      static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioBufferQueueSourceNode](BaseAudioContext &) {
-    audioBufferQueueSourceNode->pause();
+  auto event = [handle](BaseAudioContext &) {
+    static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode())->pause();
   };
   audioBufferQueueSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -63,7 +70,9 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, pause) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, enqueueBuffer) {
-  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferQueueSourceNode =
+      static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode());
 
   auto audioBufferHostObject =
       args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
@@ -83,9 +92,9 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, enqueueBuffer) {
     stretchHasBeenInit_ = true;
   }
 
-  auto event = [audioBufferQueueSourceNode, copiedBuffer, bufferId = bufferId_, tailBuffer](
-                   BaseAudioContext &) {
-    audioBufferQueueSourceNode->enqueueBuffer(copiedBuffer, bufferId, tailBuffer);
+  auto event = [handle, copiedBuffer, bufferId = bufferId_, tailBuffer](BaseAudioContext &) {
+    static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode())
+        ->enqueueBuffer(copiedBuffer, bufferId, tailBuffer);
   };
   audioBufferQueueSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -93,11 +102,13 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, enqueueBuffer) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, dequeueBuffer) {
-  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferQueueSourceNode =
+      static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioBufferQueueSourceNode,
-                bufferId = static_cast<size_t>(args[0].getNumber())](BaseAudioContext &) {
-    audioBufferQueueSourceNode->dequeueBuffer(bufferId);
+  auto event = [handle, bufferId = static_cast<size_t>(args[0].getNumber())](BaseAudioContext &) {
+    static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode())
+        ->dequeueBuffer(bufferId);
   };
   audioBufferQueueSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -105,10 +116,12 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, dequeueBuffer) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, clearBuffers) {
-  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferQueueSourceNode =
+      static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioBufferQueueSourceNode](BaseAudioContext &) {
-    audioBufferQueueSourceNode->clearBuffers();
+  auto event = [handle](BaseAudioContext &) {
+    static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode())->clearBuffers();
   };
   audioBufferQueueSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -116,10 +129,13 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, clearBuffers) {
 }
 
 void AudioBufferQueueSourceNodeHostObject::setOnBufferEndedCallbackId(uint64_t callbackId) {
-  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferQueueSourceNode =
+      static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioBufferQueueSourceNode, callbackId](BaseAudioContext &) {
-    audioBufferQueueSourceNode->setOnBufferEndedCallbackId(callbackId);
+  auto event = [handle, callbackId](BaseAudioContext &) {
+    static_cast<AudioBufferQueueSourceNode *>(handle->audioNode->asAudioNode())
+        ->setOnBufferEndedCallbackId(callbackId);
   };
 
   audioBufferQueueSourceNode->unregisterOnBufferEndedCallback(onBufferEndedCallbackId_);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp
index 9a9bf10a4..f3f2c8c14 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp
@@ -14,7 +14,10 @@ namespace audioapi {
 AudioBufferSourceNodeHostObject::AudioBufferSourceNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const AudioBufferSourceOptions &options)
-    : AudioBufferBaseSourceNodeHostObject(context->createBufferSource(options), options),
+    : AudioBufferBaseSourceNodeHostObject(
+          context->getGraph(),
+          std::make_unique<AudioBufferSourceNode>(context, options),
+          options),
       loop_(options.loop),
       loopSkip_(options.loopSkip),
       loopStart_(options.loopStart),
@@ -68,11 +71,13 @@ JSI_PROPERTY_GETTER_IMPL(AudioBufferSourceNodeHostObject, loopEnd) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loop) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
   auto loop = value.getBool();
 
-  auto event = [audioBufferSourceNode, loop](BaseAudioContext &) {
-    audioBufferSourceNode->setLoop(loop);
+  auto event = [handle, loop](BaseAudioContext &) {
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())->setLoop(loop);
   };
 
   audioBufferSourceNode->scheduleAudioEvent(std::move(event));
@@ -80,11 +85,13 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loop) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopSkip) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
   auto loopSkip = value.getBool();
 
-  auto event = [audioBufferSourceNode, loopSkip](BaseAudioContext &) {
-    audioBufferSourceNode->setLoopSkip(loopSkip);
+  auto event = [handle, loopSkip](BaseAudioContext &) {
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())->setLoopSkip(loopSkip);
   };
 
   audioBufferSourceNode->scheduleAudioEvent(std::move(event));
@@ -92,11 +99,13 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopSkip) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopStart) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
   auto loopStart = value.getNumber();
 
-  auto event = [audioBufferSourceNode, loopStart](BaseAudioContext &) {
-    audioBufferSourceNode->setLoopStart(loopStart);
+  auto event = [handle, loopStart](BaseAudioContext &) {
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())->setLoopStart(loopStart);
   };
 
   audioBufferSourceNode->scheduleAudioEvent(std::move(event));
@@ -104,11 +113,13 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopStart) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, loopEnd) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
   auto loopEnd = value.getNumber();
 
-  auto event = [audioBufferSourceNode, loopEnd](BaseAudioContext &) {
-    audioBufferSourceNode->setLoopEnd(loopEnd);
+  auto event = [handle, loopEnd](BaseAudioContext &) {
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())->setLoopEnd(loopEnd);
   };
 
   audioBufferSourceNode->scheduleAudioEvent(std::move(event));
@@ -121,13 +132,16 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, onLoopEnded) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, start) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioBufferSourceNode,
+  auto event = [handle,
                 when = args[0].getNumber(),
                 offset = args[1].getNumber(),
                 duration = args[2].isUndefined() ? -1 : args[2].getNumber()](BaseAudioContext &) {
-    audioBufferSourceNode->start(when, offset, duration);
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())
+        ->start(when, offset, duration);
   };
   audioBufferSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -135,8 +149,6 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, start) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, setBuffer) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
-
   if (args[0].isNull()) {
     setBuffer(nullptr);
   } else {
@@ -151,10 +163,13 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, setBuffer) {
 }
 
 void AudioBufferSourceNodeHostObject::setOnLoopEndedCallbackId(uint64_t callbackId) {
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioBufferSourceNode, callbackId](BaseAudioContext &) {
-    audioBufferSourceNode->setOnLoopEndedCallbackId(callbackId);
+  auto event = [handle, callbackId](BaseAudioContext &) {
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())
+        ->setOnLoopEndedCallbackId(callbackId);
   };
 
   audioBufferSourceNode->unregisterOnLoopEndedCallback(onLoopEndedCallbackId_);
@@ -166,7 +181,9 @@ void AudioBufferSourceNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffe
   // TODO: add optimized memory management for buffer changes, e.g.
   //  when the same buffer is reused across threads and
   // buffer modification is not allowed on JS thread
-  auto audioBufferSourceNode = std::static_pointer_cast<AudioBufferSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioBufferSourceNode =
+      static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode());
 
   std::shared_ptr<AudioBuffer> copiedBuffer;
   std::shared_ptr<DSPAudioBuffer> audioBuffer;
@@ -195,8 +212,9 @@ void AudioBufferSourceNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffe
         audioBufferSourceNode->getContextSampleRate());
   }
 
-  auto event = [audioBufferSourceNode, copiedBuffer, audioBuffer](BaseAudioContext &) {
-    audioBufferSourceNode->setBuffer(copiedBuffer, audioBuffer);
+  auto event = [handle, copiedBuffer, audioBuffer](BaseAudioContext &) {
+    static_cast<AudioBufferSourceNode *>(handle->audioNode->asAudioNode())
+        ->setBuffer(copiedBuffer, audioBuffer);
   };
   audioBufferSourceNode->scheduleAudioEvent(std::move(event));
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp
index 099be5b6f..05bbc338d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp
@@ -8,9 +8,10 @@
 namespace audioapi {
 
 AudioScheduledSourceNodeHostObject::AudioScheduledSourceNodeHostObject(
-    const std::shared_ptr<AudioScheduledSourceNode> &node,
+    const std::shared_ptr<utils::graph::Graph> &graph,
+    std::unique_ptr<AudioNode> node,
     const AudioScheduledSourceNodeOptions &options)
-    : AudioNodeHostObject(node) {
+    : AudioNodeHostObject(graph, std::move(node), options) {
   addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioScheduledSourceNodeHostObject, onEnded));
 
   addFunctions(
@@ -31,10 +32,12 @@ JSI_PROPERTY_SETTER_IMPL(AudioScheduledSourceNodeHostObject, onEnded) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, start) {
-  auto audioScheduleSourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioScheduleSourceNode =
+      static_cast<AudioScheduledSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioScheduleSourceNode, when = args[0].getNumber()](BaseAudioContext &) {
-    audioScheduleSourceNode->start(when);
+  auto event = [handle, when = args[0].getNumber()](BaseAudioContext &) {
+    static_cast<AudioScheduledSourceNode *>(handle->audioNode->asAudioNode())->start(when);
   };
   audioScheduleSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -42,10 +45,12 @@ JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, start) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, stop) {
-  auto audioScheduleSourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto handle = node_->handle;
+  auto audioScheduleSourceNode =
+      static_cast<AudioScheduledSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [audioScheduleSourceNode, when = args[0].getNumber()](BaseAudioContext &) {
-    audioScheduleSourceNode->stop(when);
+  auto event = [handle, when = args[0].getNumber()](BaseAudioContext &) {
+    static_cast<AudioScheduledSourceNode *>(handle->audioNode->asAudioNode())->stop(when);
   };
   audioScheduleSourceNode->scheduleAudioEvent(std::move(event));
 
@@ -53,10 +58,12 @@ JSI_HOST_FUNCTION_IMPL(AudioScheduledSourceNodeHostObject, stop) {
 }
 
 void AudioScheduledSourceNodeHostObject::setOnEndedCallbackId(uint64_t callbackId) {
-  auto sourceNode = std::static_pointer_cast<AudioScheduledSourceNode>(node_);
+  auto handle = node_->handle;
+  auto sourceNode = static_cast<AudioScheduledSourceNode *>(handle->audioNode->asAudioNode());
 
-  auto event = [sourceNode, callbackId](BaseAudioContext &) {
-    sourceNode->setOnEndedCallbackId(callbackId);
+  auto event = [handle, callbackId](BaseAudioContext &) {
+    static_cast<AudioScheduledSourceNode *>(handle->audioNode->asAudioNode())
+        ->setOnEndedCallbackId(callbackId);
   };
 
   sourceNode->unregisterOnEndedCallback(onEndedCallbackId_);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h
index 717853115..c56db8119 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h
@@ -8,12 +8,11 @@
 namespace audioapi {
 using namespace facebook;
 
-class AudioScheduledSourceNode;
-
 class AudioScheduledSourceNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioScheduledSourceNodeHostObject(
-      const std::shared_ptr<AudioScheduledSourceNode> &node,
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      std::unique_ptr<AudioNode> node,
       const AudioScheduledSourceNodeOptions &options = AudioScheduledSourceNodeOptions());
 
   ~AudioScheduledSourceNodeHostObject() override;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp
index b4522932b..c194026c6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp
@@ -10,8 +10,12 @@ namespace audioapi {
 ConstantSourceNodeHostObject::ConstantSourceNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const ConstantSourceOptions &options)
-    : AudioScheduledSourceNodeHostObject(context->createConstantSource(options), options) {
-  auto constantSourceNode = std::static_pointer_cast<ConstantSourceNode>(node_);
+    : AudioScheduledSourceNodeHostObject(
+          context->getGraph(),
+          std::make_unique<ConstantSourceNode>(context, options),
+          options) {
+  auto constantSourceNode =
+      static_cast<ConstantSourceNode *>(node_->handle->audioNode->asAudioNode());
   offsetParam_ = std::make_shared<AudioParamHostObject>(constantSourceNode->getOffsetParam());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(ConstantSourceNodeHostObject, offset));
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
index c88189572..1ce8008fa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
@@ -14,9 +14,12 @@ namespace audioapi {
 OscillatorNodeHostObject::OscillatorNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const OscillatorOptions &options)
-    : AudioScheduledSourceNodeHostObject(context->createOscillator(options), options),
+    : AudioScheduledSourceNodeHostObject(
+          context->getGraph(),
+          std::make_unique<OscillatorNode>(context, options),
+          options),
       type_(options.type) {
-  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto oscillatorNode = static_cast<OscillatorNode *>(node_->handle->audioNode->asAudioNode());
   frequencyParam_ = std::make_shared<AudioParamHostObject>(oscillatorNode->getFrequencyParam());
   detuneParam_ = std::make_shared<AudioParamHostObject>(oscillatorNode->getDetuneParam());
 
@@ -43,11 +46,12 @@ JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, type) {
 }
 
 JSI_HOST_FUNCTION_IMPL(OscillatorNodeHostObject, setPeriodicWave) {
-  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto handle = node_->handle;
+  auto oscillatorNode = static_cast<OscillatorNode *>(handle->audioNode->asAudioNode());
   auto periodicWave = args[0].getObject(runtime).getHostObject<PeriodicWaveHostObject>(runtime);
 
-  auto event = [oscillatorNode, periodicWave = periodicWave->periodicWave_](BaseAudioContext &) {
-    oscillatorNode->setPeriodicWave(periodicWave);
+  auto event = [handle, periodicWave = periodicWave->periodicWave_](BaseAudioContext &) {
+    static_cast<OscillatorNode *>(handle->audioNode->asAudioNode())->setPeriodicWave(periodicWave);
   };
   oscillatorNode->scheduleAudioEvent(std::move(event));
 
@@ -55,11 +59,12 @@ JSI_HOST_FUNCTION_IMPL(OscillatorNodeHostObject, setPeriodicWave) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(OscillatorNodeHostObject, type) {
-  auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
+  auto handle = node_->handle;
+  auto oscillatorNode = static_cast<OscillatorNode *>(handle->audioNode->asAudioNode());
   auto type = js_enum_parser::oscillatorTypeFromString(value.asString(runtime).utf8(runtime));
 
-  auto event = [oscillatorNode, type](BaseAudioContext &) {
-    oscillatorNode->setType(type);
+  auto event = [handle, type](BaseAudioContext &) {
+    static_cast<OscillatorNode *>(handle->audioNode->asAudioNode())->setType(type);
   };
   type_ = type;
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h
index 8b257025b..a6b8fefe6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h
@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/utils/graph/Graph.hpp>
 
 #include <memory>
 
@@ -12,8 +13,13 @@ class AudioRecorderHostObject;
 
 class RecorderAdapterNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit RecorderAdapterNodeHostObject(const std::shared_ptr<RecorderAdapterNode> &node)
-      : AudioNodeHostObject(node) {}
+  explicit RecorderAdapterNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioScheduledSourceNodeOptions &options = AudioScheduledSourceNodeOptions())
+      : AudioNodeHostObject(
+            context->getGraph(),
+            std::make_unique<RecorderAdapterNode>(context),
+            options) {}
 
  private:
   friend class AudioRecorderHostObject;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h
index 38fb94a8d..d80710bf3 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h
@@ -18,7 +18,10 @@ class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
   explicit StreamerNodeHostObject(
       const std::shared_ptr<BaseAudioContext> &context,
       const StreamerOptions &options)
-      : AudioScheduledSourceNodeHostObject(context->createStreamer(options), options) {}
+      : AudioScheduledSourceNodeHostObject(
+            context->getGraph(),
+            std::make_unique<StreamerNode>(context, options),
+            options) {}
 
   [[nodiscard]] static inline size_t getSizeInBytes() {
     return SIZE;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h
index 648b53334..fb8616c56 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h
@@ -2,6 +2,8 @@
 
 #include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
 #include <audioapi/core/sources/WorkletSourceNode.h>
+#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/types/NodeOptions.h>
 
 #include <memory>
 
@@ -10,7 +12,18 @@ using namespace facebook;
 
 class WorkletSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
  public:
-  explicit WorkletSourceNodeHostObject(const std::shared_ptr<WorkletSourceNode> &node)
-      : AudioScheduledSourceNodeHostObject(node) {}
+  explicit WorkletSourceNodeHostObject(
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      const std::shared_ptr<BaseAudioContext> &context,
+      std::weak_ptr<worklets::WorkletRuntime> workletRuntime,
+      const std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
+      bool shouldLockRuntime,
+      const AudioScheduledSourceNodeOptions &options = AudioScheduledSourceNodeOptions())
+      : AudioScheduledSourceNodeHostObject(
+            graph,
+            std::make_unique<WorkletSourceNode>(
+                context,
+                WorkletsRunner(workletRuntime, shareableWorklet, shouldLockRuntime)),
+            options) {}
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 1f62ef555..671a15784 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -41,9 +41,11 @@ BaseAudioContext::BaseAudioContext(
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry),
       audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
+      graphManager_(std::make_unique<AudioGraphManager>(this)),
       disposer_(
-          std::make_unique<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>>(AUDIO_SCHEDULER_CAPACITY)),
-      graphManager_(std::make_unique<AudioGraphManager>(this)) {}
+          std::make_unique<utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize>>(
+              AUDIO_SCHEDULER_CAPACITY)),
+      graph_(std::make_shared<utils::graph::Graph>(AUDIO_SCHEDULER_CAPACITY, disposer_.get())) {}
 
 void BaseAudioContext::initialize() {
   destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
@@ -81,117 +83,6 @@ void BaseAudioContext::setState(audioapi::ContextState state) {
   state_.store(state, std::memory_order_release);
 }
 
-std::shared_ptr<WorkletSourceNode> BaseAudioContext::createWorkletSourceNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    bool shouldLockRuntime) {
-  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
-  auto workletSourceNode =
-      std::make_shared<WorkletSourceNode>(shared_from_this(), std::move(workletRunner));
-  graphManager_->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,
-    bool shouldLockRuntime) {
-  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
-  auto workletNode = std::make_shared<WorkletNode>(
-      shared_from_this(), bufferLength, inputChannelCount, std::move(workletRunner));
-  graphManager_->addProcessingNode(workletNode);
-  return workletNode;
-}
-
-std::shared_ptr<WorkletProcessingNode> BaseAudioContext::createWorkletProcessingNode(
-    std::shared_ptr<worklets::SerializableWorklet> &shareableWorklet,
-    std::weak_ptr<worklets::WorkletRuntime> runtime,
-    bool shouldLockRuntime) {
-  WorkletsRunner workletRunner(runtime, shareableWorklet, shouldLockRuntime);
-  auto workletProcessingNode =
-      std::make_shared<WorkletProcessingNode>(shared_from_this(), std::move(workletRunner));
-  graphManager_->addProcessingNode(workletProcessingNode);
-  return workletProcessingNode;
-}
-
-std::shared_ptr<RecorderAdapterNode> BaseAudioContext::createRecorderAdapter() {
-  auto recorderAdapter = std::make_shared<RecorderAdapterNode>(shared_from_this());
-  graphManager_->addProcessingNode(recorderAdapter);
-  return recorderAdapter;
-}
-
-std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator(
-    const OscillatorOptions &options) {
-  auto oscillator = std::make_shared<OscillatorNode>(shared_from_this(), options);
-  graphManager_->addSourceNode(oscillator);
-  return oscillator;
-}
-
-std::shared_ptr<ConstantSourceNode> BaseAudioContext::createConstantSource(
-    const ConstantSourceOptions &options) {
-  auto constantSource = std::make_shared<ConstantSourceNode>(shared_from_this(), options);
-  graphManager_->addSourceNode(constantSource);
-  return constantSource;
-}
-
-std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer(const StreamerOptions &options) {
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-  auto streamer = std::make_shared<StreamerNode>(shared_from_this(), options);
-  graphManager_->addSourceNode(streamer);
-  return streamer;
-#else
-  return nullptr;
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-}
-
-std::shared_ptr<GainNode> BaseAudioContext::createGain(const GainOptions &options) {
-  auto gain = std::make_shared<GainNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(gain);
-  return gain;
-}
-
-std::shared_ptr<StereoPannerNode> BaseAudioContext::createStereoPanner(
-    const StereoPannerOptions &options) {
-  auto stereoPanner = std::make_shared<StereoPannerNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(stereoPanner);
-  return stereoPanner;
-}
-
-std::shared_ptr<DelayNode> BaseAudioContext::createDelay(const DelayOptions &options) {
-  auto delay = std::make_shared<DelayNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(delay);
-  return delay;
-}
-
-std::shared_ptr<BiquadFilterNode> BaseAudioContext::createBiquadFilter(
-    const BiquadFilterOptions &options) {
-  auto biquadFilter = std::make_shared<BiquadFilterNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(biquadFilter);
-  return biquadFilter;
-}
-
-std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
-    const AudioBufferSourceOptions &options) {
-  auto bufferSource = std::make_shared<AudioBufferSourceNode>(shared_from_this(), options);
-  graphManager_->addSourceNode(bufferSource);
-  return bufferSource;
-}
-
-std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(const IIRFilterOptions &options) {
-  auto iirFilter = std::make_shared<IIRFilterNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(iirFilter);
-  return iirFilter;
-}
-
-std::shared_ptr<AudioBufferQueueSourceNode> BaseAudioContext::createBufferQueueSource(
-    const BaseAudioBufferSourceOptions &options) {
-  auto bufferSource = std::make_shared<AudioBufferQueueSourceNode>(shared_from_this(), options);
-  graphManager_->addSourceNode(bufferSource);
-  return bufferSource;
-}
-
 std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
     const std::vector<std::complex<float>> &complexData,
     bool disableNormalization,
@@ -199,25 +90,6 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
   return std::make_shared<PeriodicWave>(getSampleRate(), complexData, length, disableNormalization);
 }
 
-std::shared_ptr<AnalyserNode> BaseAudioContext::createAnalyser(const AnalyserOptions &options) {
-  auto analyser = std::make_shared<AnalyserNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(analyser);
-  return analyser;
-}
-
-std::shared_ptr<ConvolverNode> BaseAudioContext::createConvolver(const ConvolverOptions &options) {
-  auto convolver = std::make_shared<ConvolverNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(convolver);
-  return convolver;
-}
-
-std::shared_ptr<WaveShaperNode> BaseAudioContext::createWaveShaper(
-    const WaveShaperOptions &options) {
-  auto waveShaper = std::make_shared<WaveShaperNode>(shared_from_this(), options);
-  graphManager_->addProcessingNode(waveShaper);
-  return waveShaper;
-}
-
 std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType type) {
   switch (type) {
     case OscillatorType::SINE:
@@ -250,6 +122,10 @@ AudioGraphManager *BaseAudioContext::getGraphManager() const {
   return graphManager_.get();
 }
 
+std::shared_ptr<utils::graph::Graph> BaseAudioContext::getGraph() const {
+  return graph_;
+}
+
 std::shared_ptr<IAudioEventHandlerRegistry> BaseAudioContext::getAudioEventHandlerRegistry() const {
   return audioEventHandlerRegistry_;
 }
@@ -258,7 +134,8 @@ const RuntimeRegistry &BaseAudioContext::getRuntimeRegistry() const {
   return runtimeRegistry_;
 }
 
-utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *BaseAudioContext::getDisposer() const {
+utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *BaseAudioContext::getDisposer()
+    const {
   return disposer_.get();
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index b4c4a9f70..7c1fa6693 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -4,6 +4,7 @@
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Disposer.hpp>
+#include <audioapi/core/utils/graph/Graph.hpp>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
@@ -70,46 +71,17 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   void setState(ContextState state);
 
-  std::shared_ptr<RecorderAdapterNode> createRecorderAdapter();
-  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<DelayNode> createDelay(const DelayOptions &options);
-  std::shared_ptr<IIRFilterNode> createIIRFilter(const IIRFilterOptions &options);
-  std::shared_ptr<OscillatorNode> createOscillator(const OscillatorOptions &options);
-  std::shared_ptr<ConstantSourceNode> createConstantSource(const ConstantSourceOptions &options);
-  std::shared_ptr<StreamerNode> createStreamer(const StreamerOptions &options);
-  std::shared_ptr<GainNode> createGain(const GainOptions &options);
-  std::shared_ptr<StereoPannerNode> createStereoPanner(const StereoPannerOptions &options);
-  std::shared_ptr<BiquadFilterNode> createBiquadFilter(const BiquadFilterOptions &options);
-  std::shared_ptr<AudioBufferSourceNode> createBufferSource(
-      const AudioBufferSourceOptions &options);
-  std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(
-      const BaseAudioBufferSourceOptions &options);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
       const std::vector<std::complex<float>> &complexData,
       bool disableNormalization,
       int length) const;
-  std::shared_ptr<AnalyserNode> createAnalyser(const AnalyserOptions &options);
-  std::shared_ptr<ConvolverNode> createConvolver(const ConvolverOptions &options);
-  std::shared_ptr<WaveShaperNode> createWaveShaper(const WaveShaperOptions &options);
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   AudioGraphManager *getGraphManager() const;
+  std::shared_ptr<utils::graph::Graph> getGraph() const;
   std::shared_ptr<IAudioEventHandlerRegistry> getAudioEventHandlerRegistry() const;
   const RuntimeRegistry &getRuntimeRegistry() const;
-  utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *getDisposer() const;
+  utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *getDisposer() const;
 
   virtual void initialize();
 
@@ -144,9 +116,11 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
-  std::unique_ptr<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>> disposer_;
   std::unique_ptr<AudioGraphManager> graphManager_;
 
+  std::unique_ptr<utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize>> disposer_;
+  std::shared_ptr<utils::graph::Graph> graph_;
+
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
index 7b51eed0b..73d977bab 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/SpscChannel.hpp>
@@ -104,7 +103,7 @@ class AudioGraphManager {
   void cleanup();
 
  private:
-  utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *const disposer_;
+  utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *const disposer_;
 
   /// @brief Initial capacity for various node types for deletion
   /// @note Higher capacity decreases number of reallocations at runtime (can be easily adjusted to 128 if needed)
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
index 319e0067a..79a9a3f69 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
@@ -30,9 +30,6 @@ inline float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FL
 inline float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
 inline constexpr float PI = std::numbers::pi_v<float>;
 
-// disposer
-inline constexpr size_t DISPOSER_PAYLOAD_SIZE = 16;
-
 // buffer sizes
 inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;
 inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE = 32;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
index d1b2ff2a1..2f4ec6c2a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
@@ -40,8 +40,8 @@ class HostGraph {
     EDGE_ALREADY_EXISTS,
   };
 
-  /// Size of the Disposer payload (= sizeof(std::unique_ptr<T[]>)).
-  static constexpr size_t kDisposerPayloadSize = 8;
+  /// Size of the Disposer payload (= sizeof(std::shared_ptr<T[]>)).
+  static constexpr size_t kDisposerPayloadSize = 16;
 
   /// Event that modifies AudioGraph to keep it consistent with HostGraph.
   /// The second argument is the Disposer used to offload buffer deallocation.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
index 2b1b66e5a..2c29d2a8f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
@@ -17,10 +17,10 @@ namespace audioapi::utils::graph {
 ///
 /// Host objects that represent audio processing nodes should publicly inherit
 /// from HostNode and pass their payload (GraphObject-derived object) to the
-/// constructor. `connect` / `disconnect` provide edge management.
+/// constructor. `connectNode` / `disconnectNode` provide edge management.
 ///
 /// @note HostNode intentionally does NOT prevent cycles — callers must handle
-/// the error returned by `connect()`.
+/// the error returned by `connectNode()`.
 ///
 /// ## Example usage:
 /// ```cpp
@@ -32,7 +32,7 @@ namespace audioapi::utils::graph {
 /// };
 ///
 /// auto gain = std::make_unique<MyGainNode>(graph, std::move(gainImpl));
-/// gain->connect(*destination);
+/// gain->connectNode(*destination);
 /// gain.reset(); // destructor removes the node from the graph
 /// ```
 class HostNode {
@@ -93,13 +93,13 @@ class HostNode {
 
   /// @brief Connects this node's output to another node's input (this → other).
   /// @return Ok on success, Err on cycle / duplicate / not-found
-  Res connect(HostNode &other) {
+  Res connectNode(HostNode &other) {
     return graph_->addEdge(node_, other.node_);
   }
 
   /// @brief Disconnects this node's output from another node's input.
   /// @return Ok on success, Err on not-found
-  Res disconnect(HostNode &other) {
+  Res disconnectNode(HostNode &other) {
     return graph_->removeEdge(node_, other.node_);
   }
 

From 8efcef429a48c9bf789cf53ffd732d994babcdfc Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:56:08 +0100
Subject: [PATCH 08/38] test: fix tests to use std::make_shared instead of
 context factory methods

---
 .../common/cpp/test/src/core/effects/DelayTest.cpp            | 2 +-
 .../common/cpp/test/src/core/effects/GainTest.cpp             | 2 +-
 .../common/cpp/test/src/core/effects/IIRFilterTest.cpp        | 2 +-
 .../common/cpp/test/src/core/effects/StereoPannerTest.cpp     | 2 +-
 .../common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp   | 4 ++--
 .../common/cpp/test/src/core/sources/ConstantSourceTest.cpp   | 2 +-
 .../common/cpp/test/src/core/sources/OscillatorTest.cpp       | 2 +-
 7 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
index 095b90269..e57736c5b 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
@@ -41,7 +41,7 @@ class TestableDelayNode : public DelayNode {
 };
 
 TEST_F(DelayTest, DelayCanBeCreated) {
-  auto delay = context->createDelay(DelayOptions());
+  auto delay = std::make_shared<DelayNode>(context, DelayOptions());
   ASSERT_NE(delay, nullptr);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
index ebdfdcb5d..5e81f15fa 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
@@ -41,7 +41,7 @@ class TestableGainNode : public GainNode {
 };
 
 TEST_F(GainTest, GainCanBeCreated) {
-  auto gain = context->createGain(GainOptions());
+  auto gain = std::make_shared<GainNode>(context, GainOptions());
   ASSERT_NE(gain, nullptr);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/IIRFilterTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/IIRFilterTest.cpp
index e5212511c..746524376 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/IIRFilterTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/IIRFilterTest.cpp
@@ -91,7 +91,7 @@ class IIRFilterTest : public ::testing::Test {
 TEST_F(IIRFilterTest, IIRFilterCanBeCreated) {
   const std::vector<float> feedforward = {1.0};
   const std::vector<float> feedback = {1.0};
-  auto node = context->createIIRFilter(IIRFilterOptions(feedforward, feedback));
+  auto node = std::make_shared<IIRFilterNode>(context, IIRFilterOptions(feedforward, feedback));
   ASSERT_NE(node, nullptr);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
index 02b4b54ba..5d14af115 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
@@ -41,7 +41,7 @@ class TestableStereoPannerNode : public StereoPannerNode {
 };
 
 TEST_F(StereoPannerTest, StereoPannerCanBeCreated) {
-  auto panner = context->createStereoPanner(StereoPannerOptions());
+  auto panner = std::make_shared<StereoPannerNode>(context, StereoPannerOptions());
   ASSERT_NE(panner, nullptr);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
index 4ee9a53ea..c83134d39 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
@@ -45,12 +45,12 @@ class TestableWaveShaperNode : public WaveShaperNode {
 };
 
 TEST_F(WaveShaperNodeTest, WaveShaperNodeCanBeCreated) {
-  auto waveShaper = context->createWaveShaper(WaveShaperOptions());
+  auto waveShaper = std::make_shared<WaveShaperNode>(context, WaveShaperOptions());
   ASSERT_NE(waveShaper, nullptr);
 }
 
 TEST_F(WaveShaperNodeTest, NullCanBeAsignedToCurve) {
-  auto waveShaper = context->createWaveShaper(WaveShaperOptions());
+  auto waveShaper = std::make_shared<WaveShaperNode>(context, WaveShaperOptions());
   ASSERT_NO_THROW(waveShaper->setCurve(nullptr));
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
index 5e498c2bb..5d670f9b4 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
@@ -41,7 +41,7 @@ class TestableConstantSourceNode : public ConstantSourceNode {
 };
 
 TEST_F(ConstantSourceTest, ConstantSourceCanBeCreated) {
-  auto constantSource = context->createConstantSource(ConstantSourceOptions());
+  auto constantSource = std::make_shared<ConstantSourceNode>(context, ConstantSourceOptions());
   ASSERT_NE(constantSource, nullptr);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/OscillatorTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/OscillatorTest.cpp
index fbe9c67ac..5735f4ff5 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/OscillatorTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/OscillatorTest.cpp
@@ -22,6 +22,6 @@ class OscillatorTest : public ::testing::Test {
 };
 
 TEST_F(OscillatorTest, OscillatorCanBeCreated) {
-  auto osc = context->createOscillator(OscillatorOptions());
+  auto osc = std::make_shared<OscillatorNode>(context, OscillatorOptions());
   ASSERT_NE(osc, nullptr);
 }

From 7d2d876e01a7f74e79a00e5c24a76a74bff29ed5 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:59:02 +0100
Subject: [PATCH 09/38] refactor: nitpicks

---
 .../audioapi/core/sources/AudioScheduledSourceNode.cpp | 10 +++++-----
 .../audioapi/core/sources/AudioScheduledSourceNode.h   | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
index b98c5375f..178326881 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
@@ -41,23 +41,23 @@ void AudioScheduledSourceNode::stop(double when) {
   stopTime_ = when;
 }
 
-bool AudioScheduledSourceNode::isUnscheduled() {
+bool AudioScheduledSourceNode::isUnscheduled() const {
   return playbackState_ == PlaybackState::UNSCHEDULED;
 }
 
-bool AudioScheduledSourceNode::isScheduled() {
+bool AudioScheduledSourceNode::isScheduled() const {
   return playbackState_ == PlaybackState::SCHEDULED;
 }
 
-bool AudioScheduledSourceNode::isPlaying() {
+bool AudioScheduledSourceNode::isPlaying() const {
   return playbackState_ == PlaybackState::PLAYING;
 }
 
-bool AudioScheduledSourceNode::isFinished() {
+bool AudioScheduledSourceNode::isFinished() const {
   return playbackState_ == PlaybackState::FINISHED;
 }
 
-bool AudioScheduledSourceNode::isStopScheduled() {
+bool AudioScheduledSourceNode::isStopScheduled() const {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h
index fdabaf152..2b515e2c3 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h
@@ -27,19 +27,19 @@ class AudioScheduledSourceNode : public AudioNode {
   virtual void stop(double when);
 
   /// @note Audio Thread only
-  bool isUnscheduled();
+  bool isUnscheduled() const;
 
   /// @note Audio Thread only
-  bool isScheduled();
+  bool isScheduled() const;
 
   /// @note Audio Thread only
-  bool isPlaying();
+  bool isPlaying() const;
 
   /// @note Audio Thread only
-  bool isFinished();
+  bool isFinished() const;
 
   /// @note Audio Thread only
-  bool isStopScheduled();
+  bool isStopScheduled() const;
 
   /// @note Audio Thread only
   void setOnEndedCallbackId(uint64_t callbackId);

From 2a525b95aff16fc686c966408c48c2c563bea544 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Wed, 25 Mar 2026 18:20:18 +0100
Subject: [PATCH 10/38] refactor: first part of integration

---
 .../cpp/audioapi/android/core/AudioPlayer.cpp |  17 +-
 .../cpp/audioapi/android/core/AudioPlayer.h   |   8 +-
 .../HostObjects/AudioNodeHostObject.cpp       |  15 +-
 .../BaseAudioContextHostObject.cpp            |   6 +-
 .../AudioDestinationNodeHostObject.cpp        |  30 +++
 .../AudioDestinationNodeHostObject.h          |  25 +-
 .../effects/ConvolverNodeHostObject.cpp       |   4 +-
 .../common/cpp/audioapi/core/AudioContext.cpp |  21 +-
 .../common/cpp/audioapi/core/AudioContext.h   |   4 +-
 .../common/cpp/audioapi/core/AudioNode.cpp    | 253 ------------------
 .../common/cpp/audioapi/core/AudioNode.h      |  69 ++---
 .../common/cpp/audioapi/core/AudioParam.cpp   |  13 +-
 .../common/cpp/audioapi/core/AudioParam.h     |  15 +-
 .../cpp/audioapi/core/BaseAudioContext.cpp    |  54 ++--
 .../cpp/audioapi/core/BaseAudioContext.h      |  44 +--
 .../cpp/audioapi/core/OfflineAudioContext.cpp |   7 +-
 .../cpp/audioapi/core/OfflineAudioContext.h   |   1 -
 .../audioapi/core/analysis/AnalyserNode.cpp   |  10 +-
 .../cpp/audioapi/core/analysis/AnalyserNode.h |   4 +-
 .../destinations/AudioDestinationNode.cpp     |  36 +--
 .../core/destinations/AudioDestinationNode.h  |  22 +-
 .../core/effects/BiquadFilterNode.cpp         |  12 +-
 .../audioapi/core/effects/BiquadFilterNode.h  |   4 +-
 .../audioapi/core/effects/ConvolverNode.cpp   |  32 +--
 .../cpp/audioapi/core/effects/ConvolverNode.h |   9 +-
 .../cpp/audioapi/core/effects/DelayNode.cpp   |  31 +--
 .../cpp/audioapi/core/effects/DelayNode.h     |   5 +-
 .../cpp/audioapi/core/effects/GainNode.cpp    |  12 +-
 .../cpp/audioapi/core/effects/GainNode.h      |   4 +-
 .../audioapi/core/effects/IIRFilterNode.cpp   |   9 +-
 .../cpp/audioapi/core/effects/IIRFilterNode.h |   4 +-
 .../core/effects/StereoPannerNode.cpp         |  16 +-
 .../audioapi/core/effects/StereoPannerNode.h  |   4 +-
 .../audioapi/core/effects/WaveShaperNode.cpp  |  12 +-
 .../audioapi/core/effects/WaveShaperNode.h    |   4 +-
 .../cpp/audioapi/core/effects/WorkletNode.cpp |  10 +-
 .../cpp/audioapi/core/effects/WorkletNode.h   |  10 +-
 .../core/effects/WorkletProcessingNode.cpp    |  12 +-
 .../core/effects/WorkletProcessingNode.h      |  10 +-
 .../sources/AudioBufferBaseSourceNode.cpp     |  14 +-
 .../core/sources/AudioBufferBaseSourceNode.h  |   4 +-
 .../core/sources/AudioScheduledSourceNode.cpp |   1 -
 .../core/sources/ConstantSourceNode.cpp       |  21 +-
 .../core/sources/ConstantSourceNode.h         |   4 +-
 .../audioapi/core/sources/OscillatorNode.cpp  |  22 +-
 .../audioapi/core/sources/OscillatorNode.h    |   4 +-
 .../core/sources/RecorderAdapterNode.cpp      |  11 +-
 .../core/sources/RecorderAdapterNode.h        |   4 +-
 .../audioapi/core/sources/StreamerNode.cpp    |  20 +-
 .../cpp/audioapi/core/sources/StreamerNode.h  |   4 +-
 .../core/sources/WorkletSourceNode.cpp        |  30 +--
 .../audioapi/core/sources/WorkletSourceNode.h |  10 +-
 .../audioapi/core/utils/AudioGraphManager.cpp | 234 ----------------
 .../audioapi/core/utils/AudioGraphManager.h   | 209 ---------------
 .../utils/graph/DestinationGraphObject.hpp    |  29 ++
 .../cpp/test/src/core/effects/DelayTest.cpp   |  31 ++-
 .../cpp/test/src/core/effects/GainTest.cpp    |  23 +-
 .../src/core/effects/StereoPannerTest.cpp     |  27 +-
 .../src/core/effects/WaveShaperNodeTest.cpp   |  19 +-
 .../core/sources/AudioScheduledSourceTest.cpp |   7 +-
 .../src/core/sources/ConstantSourceTest.cpp   |  28 +-
 .../cpp/test/src/graph/TestGraphUtils.h       |   6 +-
 .../ios/audioapi/ios/core/IOSAudioPlayer.h    |   4 +-
 .../ios/audioapi/ios/core/IOSAudioPlayer.mm   |   4 +-
 64 files changed, 385 insertions(+), 1243 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp

diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp
index 547b734fa..71d18aea8 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp
@@ -12,14 +12,11 @@
 namespace audioapi {
 
 AudioPlayer::AudioPlayer(
-    const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
+    const std::function<void(DSPAudioBuffer *, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio),
-      sampleRate_(sampleRate),
-      channelCount_(channelCount),
-      isRunning_(false) {
-  isInitialized_ = openAudioStream();
+    : renderAudio_(renderAudio), sampleRate_(sampleRate), channelCount_(channelCount) {
+  isInitialized_.store(openAudioStream(), std::memory_order_release);
 }
 
 bool AudioPlayer::openAudioStream() {
@@ -85,7 +82,7 @@ void AudioPlayer::suspend() {
 }
 
 void AudioPlayer::cleanup() {
-  isInitialized_ = false;
+  isInitialized_.store(false, std::memory_order_release);
 
   if (mStream_ != nullptr) {
     mStream_->close();
@@ -100,7 +97,7 @@ bool AudioPlayer::isRunning() const {
 
 DataCallbackResult
 AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) {
-  if (!isInitialized_) {
+  if (!isInitialized_.load(std::memory_order_acquire)) {
     return DataCallbackResult::Continue;
   }
 
@@ -111,7 +108,7 @@ AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numF
     auto framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
 
     if (isRunning_.load(std::memory_order_acquire)) {
-      renderAudio_(buffer_, framesToProcess);
+      renderAudio_(buffer_.get(), framesToProcess);
     } else {
       buffer_->zero();
     }
@@ -129,7 +126,7 @@ void AudioPlayer::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result erro
   if (error == oboe::Result::ErrorDisconnected) {
     cleanup();
     if (openAudioStream()) {
-      isInitialized_ = true;
+      isInitialized_.store(true, std::memory_order_release);
       resume();
     }
   }
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.h
index 878ce7b14..b3c951a21 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.h
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioPlayer.h
@@ -17,7 +17,7 @@ class AudioContext;
 class AudioPlayer : public AudioStreamDataCallback, AudioStreamErrorCallback {
  public:
   AudioPlayer(
-      const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
+      const std::function<void(DSPAudioBuffer *, int)> &renderAudio,
       float sampleRate,
       int channelCount);
 
@@ -40,13 +40,13 @@ class AudioPlayer : public AudioStreamDataCallback, AudioStreamErrorCallback {
   void onErrorAfterClose(AudioStream * /* audioStream */, Result /* error */) override;
 
  private:
-  std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> renderAudio_;
+  std::function<void(DSPAudioBuffer *, int)> renderAudio_;
   std::shared_ptr<AudioStream> mStream_;
   std::shared_ptr<DSPAudioBuffer> buffer_;
-  bool isInitialized_ = false;
   float sampleRate_;
   int channelCount_;
-  std::atomic<bool> isRunning_;
+  std::atomic<bool> isInitialized_{false};
+  std::atomic<bool> isRunning_{false};
 
   bool openAudioStream();
 
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
index ccfb5fd34..d348f2e06 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -1,5 +1,6 @@
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <audioapi/core/AudioNode.h>
 
@@ -63,8 +64,10 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
     connectNode(*node);
-  }
-  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+  } else if (obj.isHostObject<AudioDestinationNodeHostObject>(runtime)) {
+    auto dest = obj.getHostObject<AudioDestinationNodeHostObject>(runtime);
+    graph_->addEdge(node_, dest->rawNode());
+  } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
     // TODO
     // connectParam(*param->owner_, param->param_.get());
@@ -82,13 +85,15 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
     disconnectNode(*node);
-  }
-
-  if (obj.isHostObject<AudioParamHostObject>(runtime)) {
+  } else if (obj.isHostObject<AudioDestinationNodeHostObject>(runtime)) {
+    auto dest = obj.getHostObject<AudioDestinationNodeHostObject>(runtime);
+    graph_->removeEdge(node_, dest->rawNode());
+  } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
     // TODO
     // disconnectParam(*param->owner_, param->param_.get());
   }
+
   return jsi::Value::undefined();
 }
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index 7c8f17a33..b9cee3e10 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -35,9 +35,9 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
     : context_(context),
       promiseVendor_(std::make_shared<PromiseVendor>(runtime, callInvoker)),
       callInvoker_(callInvoker) {
-  context_->initialize();
-  // TODO
-  // destination_ = std::make_shared<AudioDestinationNodeHostObject>(context_->getGraph(), context_->getDestination());
+  auto *destinationNode = context_->initialize();
+  destination_ =
+      std::make_shared<AudioDestinationNodeHostObject>(destinationNode, context_->getDestination());
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
new file mode 100644
index 000000000..ef0b0bf8b
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
@@ -0,0 +1,30 @@
+#include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+AudioDestinationNodeHostObject::AudioDestinationNodeHostObject(
+    utils::graph::HostGraph::Node *node,
+    std::shared_ptr<AudioDestinationNode> destination)
+    : node_(node), destination_(std::move(destination)) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfInputs) {
+  return {1};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfOutputs) {
+  return {0};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCount) {
+  return {static_cast<int>(destination_->getChannelCount())};
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
index 0cfc0e330..72cb548a1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
@@ -1,20 +1,31 @@
 #pragma once
 
-#include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/types/NodeOptions.h>
+#include <audioapi/core/utils/graph/HostGraph.hpp>
+#include <audioapi/jsi/JsiHostObject.h>
 
 #include <memory>
-#include <utility>
 
 namespace audioapi {
 using namespace facebook;
 
-class AudioDestinationNodeHostObject : public AudioNodeHostObject {
+class AudioDestinationNodeHostObject : public JsiHostObject {
  public:
   explicit AudioDestinationNodeHostObject(
-      const std::shared_ptr<utils::graph::Graph> &graph,
-      std::unique_ptr<AudioNode> node)
-      : AudioNodeHostObject(graph, std::move(node), AudioDestinationOptions()) {}
+      utils::graph::HostGraph::Node *node,
+      std::shared_ptr<AudioDestinationNode> destination);
+
+  [[nodiscard]] utils::graph::HostGraph::Node *rawNode() const {
+    return node_;
+  }
+
+  JSI_PROPERTY_GETTER_DECL(numberOfInputs);
+  JSI_PROPERTY_GETTER_DECL(numberOfOutputs);
+  JSI_PROPERTY_GETTER_DECL(channelCount);
+
+ private:
+  utils::graph::HostGraph::Node *node_; // borrowed from BaseAudioContext; never removed
+  std::shared_ptr<AudioDestinationNode> destination_;
 };
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
index f22cfa019..801315c29 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
@@ -74,13 +74,13 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
   std::vector<std::unique_ptr<Convolver>> convolvers;
   for (size_t i = 0; i < copiedBuffer->getNumberOfChannels(); ++i) {
     AudioArray channelData(*copiedBuffer->getChannel(i));
-    convolvers.emplace_back();
+    convolvers.emplace_back(std::make_unique<Convolver>());
     convolvers.back()->init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
   }
   if (copiedBuffer->getNumberOfChannels() == 1) {
     // add one more convolver, because right now input is always stereo
     AudioArray channelData(*copiedBuffer->getChannel(0));
-    convolvers.emplace_back();
+    convolvers.emplace_back(std::make_unique<Convolver>());
     convolvers.back()->init(RENDER_QUANTUM_SIZE, channelData, copiedBuffer->getSize());
   }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
index cc7497116..3cde417fc 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
@@ -6,7 +6,6 @@
 
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <memory>
 
 namespace audioapi {
@@ -23,15 +22,20 @@ AudioContext::~AudioContext() {
   }
 }
 
-void AudioContext::initialize() {
-  BaseAudioContext::initialize();
+utils::graph::HostGraph::Node *AudioContext::initialize() {
+  auto *destinationNode = BaseAudioContext::initialize();
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(
-      this->renderAudio(), getSampleRate(), destination_->getChannelCount());
+      [this](DSPAudioBuffer *buf, int n) { processGraph(buf, n); },
+      getSampleRate(),
+      destination_->getChannelCount());
 #else
   audioPlayer_ = std::make_shared<IOSAudioPlayer>(
-      this->renderAudio(), getSampleRate(), destination_->getChannelCount());
+      [this](DSPAudioBuffer *buf, int n) { processGraph(buf, n); },
+      getSampleRate(),
+      destination_->getChannelCount());
 #endif
+  return destinationNode;
 }
 
 void AudioContext::close() {
@@ -39,7 +43,6 @@ void AudioContext::close() {
 
   audioPlayer_->stop();
   audioPlayer_->cleanup();
-  getGraphManager()->cleanup();
 }
 
 bool AudioContext::resume() {
@@ -89,12 +92,6 @@ bool AudioContext::start() {
   return false;
 }
 
-std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> AudioContext::renderAudio() {
-  return [this](const std::shared_ptr<DSPAudioBuffer> &data, int frames) {
-    destination_->renderAudio(data, frames);
-  };
-}
-
 bool AudioContext::isDriverRunning() const {
   return audioPlayer_->isRunning();
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h
index 5b3defe4c..a5bd05034 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h
@@ -26,7 +26,7 @@ class AudioContext : public BaseAudioContext {
   bool resume();
   bool suspend();
   bool start();
-  void initialize() override;
+  utils::graph::HostGraph::Node *initialize() override;
 
  private:
 #ifdef ANDROID
@@ -37,8 +37,6 @@ class AudioContext : public BaseAudioContext {
   std::atomic<bool> isInitialized_{false};
 
   bool isDriverRunning() const override;
-
-  std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> renderAudio();
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
index 0e8c19565..b98b64194 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
@@ -1,7 +1,6 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
 
@@ -37,264 +36,12 @@ size_t AudioNode::getChannelCount() const {
   return channelCount_;
 }
 
-void AudioNode::connect(const std::shared_ptr<AudioNode> &node) {
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    context->getGraphManager()->addPendingNodeConnection(
-        shared_from_this(), node, AudioGraphManager::ConnectionType::CONNECT);
-  }
-}
-
-void AudioNode::connect(const std::shared_ptr<AudioParam> &param) {
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    context->getGraphManager()->addPendingParamConnection(
-        shared_from_this(), param, AudioGraphManager::ConnectionType::CONNECT);
-  }
-}
-
-void AudioNode::disconnect() {
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    context->getGraphManager()->addPendingNodeConnection(
-        shared_from_this(), nullptr, AudioGraphManager::ConnectionType::DISCONNECT_ALL);
-  }
-}
-
-void AudioNode::disconnect(const std::shared_ptr<AudioNode> &node) {
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    context->getGraphManager()->addPendingNodeConnection(
-        shared_from_this(), node, AudioGraphManager::ConnectionType::DISCONNECT);
-  }
-}
-
-void AudioNode::disconnect(const std::shared_ptr<AudioParam> &param) {
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    context->getGraphManager()->addPendingParamConnection(
-        shared_from_this(), param, AudioGraphManager::ConnectionType::DISCONNECT);
-  }
-}
-
-bool AudioNode::isEnabled() const {
-  return isEnabled_;
-}
-
 bool AudioNode::requiresTailProcessing() const {
   return requiresTailProcessing_;
 }
 
-void AudioNode::enable() {
-  if (isEnabled()) {
-    return;
-  }
-
-  isEnabled_ = true;
-
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
-    it->get()->onInputEnabled();
-  }
-}
-
-void AudioNode::disable() {
-  if (!isEnabled()) {
-    return;
-  }
-
-  isEnabled_ = false;
-
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
-    it->get()->onInputDisabled();
-  }
-}
-
-std::shared_ptr<DSPAudioBuffer> AudioNode::processAudio(
-    const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  if (!isInitialized_.load(std::memory_order_acquire)) {
-    return outputBuffer;
-  }
-
-  if (checkIsAlreadyProcessed && isAlreadyProcessed()) {
-    return audioBuffer_;
-  }
-
-  // Process inputs and return the buffer with the most channels.
-  auto processingBuffer = processInputs(outputBuffer, framesToProcess, checkIsAlreadyProcessed);
-
-  // Apply channel count mode.
-  processingBuffer = applyChannelCountMode(processingBuffer);
-
-  // Mix all input buffers into the processing buffer.
-  mixInputsBuffers(processingBuffer);
-
-  assert(processingBuffer != nullptr);
-
-  // Finally, process the node itself.
-  return processNode(processingBuffer, framesToProcess);
-}
-
-bool AudioNode::isAlreadyProcessed() {
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    std::size_t currentSampleFrame = context->getCurrentSampleFrame();
-
-    // check if the node has already been processed for this rendering quantum
-    if (currentSampleFrame == lastRenderedFrame_) {
-      return true;
-    }
-
-    // Update the last rendered frame before processing node and its inputs.
-    lastRenderedFrame_ = currentSampleFrame;
-
-    return false;
-  }
-
-  // If context is invalid, consider it as already processed to avoid processing
-  return true;
-}
-
-std::shared_ptr<DSPAudioBuffer> AudioNode::processInputs(
-    const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  auto processingBuffer = audioBuffer_;
-  processingBuffer->zero();
-
-  size_t maxNumberOfChannels = 0;
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end; ++it) {
-    auto inputNode = *it;
-    assert(inputNode != nullptr);
-
-    if (!inputNode->isEnabled()) {
-      continue;
-    }
-
-    auto inputBuffer =
-        inputNode->processAudio(outputBuffer, framesToProcess, checkIsAlreadyProcessed);
-    inputBuffers_.push_back(inputBuffer);
-
-    if (maxNumberOfChannels < inputBuffer->getNumberOfChannels()) {
-      maxNumberOfChannels = inputBuffer->getNumberOfChannels();
-      processingBuffer = inputBuffer;
-    }
-  }
-
-  return processingBuffer;
-}
-
-std::shared_ptr<DSPAudioBuffer> AudioNode::applyChannelCountMode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer) {
-  // If the channelCountMode is EXPLICIT, the node should output the number of
-  // channels specified by the channelCount.
-  if (channelCountMode_ == ChannelCountMode::EXPLICIT) {
-    return audioBuffer_;
-  }
-
-  // If the channelCountMode is CLAMPED_MAX, the node should output the maximum
-  // number of channels clamped to channelCount.
-  if (channelCountMode_ == ChannelCountMode::CLAMPED_MAX &&
-      processingBuffer->getNumberOfChannels() >= channelCount_) {
-    return audioBuffer_;
-  }
-
-  return processingBuffer;
-}
-
-void AudioNode::mixInputsBuffers(const std::shared_ptr<DSPAudioBuffer> &processingBuffer) {
-  assert(processingBuffer != nullptr);
-
-  for (auto it = inputBuffers_.begin(), end = inputBuffers_.end(); it != end; ++it) {
-    processingBuffer->sum(**it, channelInterpretation_);
-  }
-
-  inputBuffers_.clear();
-}
-
-void AudioNode::connectNode(const std::shared_ptr<AudioNode> &node) {
-  auto position = outputNodes_.find(node);
-
-  if (position == outputNodes_.end()) {
-    outputNodes_.insert(node);
-    node->onInputConnected(this);
-  }
-}
-
-void AudioNode::connectParam(const std::shared_ptr<AudioParam> &param) {
-  auto position = outputParams_.find(param);
-
-  if (position == outputParams_.end()) {
-    outputParams_.insert(param);
-    param->addInputNode(this);
-  }
-}
-
-void AudioNode::disconnectNode(const std::shared_ptr<AudioNode> &node) {
-  auto position = outputNodes_.find(node);
-
-  if (position != outputNodes_.end()) {
-    node->onInputDisconnected(this);
-    outputNodes_.erase(node);
-  }
-}
-
-void AudioNode::disconnectParam(const std::shared_ptr<AudioParam> &param) {
-  auto position = outputParams_.find(param);
-
-  if (position != outputParams_.end()) {
-    param->removeInputNode(this);
-    outputParams_.erase(param);
-  }
-}
-
-void AudioNode::onInputEnabled() {
-  numberOfEnabledInputNodes_ += 1;
-
-  if (!isEnabled()) {
-    enable();
-  }
-}
-
-void AudioNode::onInputDisabled() {
-  numberOfEnabledInputNodes_ -= 1;
-
-  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
-    disable();
-  }
-}
-
-void AudioNode::onInputConnected(AudioNode *node) {
-  if (!isInitialized_.load(std::memory_order_acquire)) {
-    return;
-  }
-
-  inputNodes_.insert(node);
-
-  if (node->isEnabled()) {
-    onInputEnabled();
-  }
-}
-
-void AudioNode::onInputDisconnected(AudioNode *node) {
-  if (!isInitialized_.load(std::memory_order_acquire)) {
-    return;
-  }
-
-  if (node->isEnabled()) {
-    onInputDisabled();
-  }
-
-  auto position = inputNodes_.find(node);
-
-  if (position != inputNodes_.end()) {
-    inputNodes_.erase(position);
-  }
-}
-
 void AudioNode::cleanup() {
   isInitialized_.store(false, std::memory_order_release);
-
-  for (auto it = outputNodes_.begin(), end = outputNodes_.end(); it != end; ++it) {
-    it->get()->onInputDisconnected(this);
-  }
-
-  outputNodes_.clear();
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 1346291f7..e5ae80439 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -27,15 +27,20 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   virtual ~AudioNode();
 
   size_t getChannelCount() const;
-  void connect(const std::shared_ptr<AudioNode> &node);
-  void connect(const std::shared_ptr<AudioParam> &param);
-  void disconnect();
-  void disconnect(const std::shared_ptr<AudioNode> &node);
-  void disconnect(const std::shared_ptr<AudioParam> &param);
-  virtual std::shared_ptr<DSPAudioBuffer> processAudio(
-      const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-      int framesToProcess,
-      bool checkIsAlreadyProcessed);
+
+  template <std::ranges::input_range R>
+    requires std::same_as<std::ranges::range_reference_t<R>, const GraphObject &>
+  void process(R &&inputs, int numFrames) {
+    audioBuffer_->zero();
+
+    for (const auto &input : inputs) {
+      if (const AudioNode *audioNode = input.asAudioNode()) {
+        audioBuffer_->sum(*audioNode->audioBuffer_, channelInterpretation_);
+      }
+    }
+
+    processNode(numFrames);
+  }
 
   float getContextSampleRate() const {
     if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
@@ -49,8 +54,10 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
     return getContextSampleRate() / 2.0f;
   }
 
-  /// @note JS Thread only
-  bool isEnabled() const;
+  std::shared_ptr<DSPAudioBuffer> getAudioBuffer() const {
+    return audioBuffer_;
+  }
+
   /// @note JS Thread only
   bool requiresTailProcessing() const;
 
@@ -74,7 +81,6 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   }
 
  protected:
-  friend class AudioGraphManager;
   friend class AudioDestinationNode;
   friend class ConvolverNode;
   friend class DelayNodeHostObject;
@@ -89,44 +95,15 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   const ChannelInterpretation channelInterpretation_ = ChannelInterpretation::SPEAKERS;
   const bool requiresTailProcessing_;
 
-  std::unordered_set<AudioNode *> inputNodes_ = {};
-  std::unordered_set<std::shared_ptr<AudioNode>> outputNodes_ = {};
-  std::unordered_set<std::shared_ptr<AudioParam>> outputParams_ = {};
-
-  int numberOfEnabledInputNodes_ = 0;
   std::atomic<bool> isInitialized_ = false;
 
   std::size_t lastRenderedFrame_{SIZE_MAX};
 
-  void enable();
-  virtual void disable();
-
- private:
-  bool isEnabled_ = true;
-  std::vector<std::shared_ptr<DSPAudioBuffer>> inputBuffers_ = {};
-
-  virtual std::shared_ptr<DSPAudioBuffer> processInputs(
-      const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-      int framesToProcess,
-      bool checkIsAlreadyProcessed);
-  virtual std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &,
-      int) = 0;
-
-  bool isAlreadyProcessed();
-  std::shared_ptr<DSPAudioBuffer> applyChannelCountMode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer);
-  void mixInputsBuffers(const std::shared_ptr<DSPAudioBuffer> &processingBuffer);
-
-  void connectNode(const std::shared_ptr<AudioNode> &node);
-  void disconnectNode(const std::shared_ptr<AudioNode> &node);
-  void connectParam(const std::shared_ptr<AudioParam> &param);
-  void disconnectParam(const std::shared_ptr<AudioParam> &param);
-
-  void onInputEnabled();
-  virtual void onInputDisabled();
-  void onInputConnected(AudioNode *node);
-  void onInputDisconnected(AudioNode *node);
+  virtual void disable() {
+    cleanup();
+  };
+
+  virtual void processNode(int) = 0;
 
   void cleanup();
 };
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
index 7aea46449..af7966ce1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
@@ -276,14 +276,15 @@ void AudioParam::processInputs(
     auto inputNode = *it;
     assert(inputNode != nullptr);
 
-    if (!inputNode->isEnabled()) {
-      continue;
-    }
+    // if (!inputNode->isEnabled()) {
+    //   continue;
+    // }
 
     // Process this input node and store its output buffer
-    auto inputBuffer =
-        inputNode->processAudio(outputBuffer, framesToProcess, checkIsAlreadyProcessed);
-    inputBuffers_.emplace_back(inputBuffer);
+    // TODO
+    // auto inputBuffer =
+    //     inputNode->processAudio(outputBuffer, framesToProcess, checkIsAlreadyProcessed);
+    // inputBuffers_.emplace_back(inputBuffer);
   }
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
index ebd875398..67484b3d8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
@@ -16,7 +16,7 @@
 
 namespace audioapi {
 
-class AudioParam : public utils::graph::GraphObject {
+class AudioParam {
  public:
   explicit AudioParam(
       float defaultValue,
@@ -80,19 +80,6 @@ class AudioParam : public utils::graph::GraphObject {
     return false;
   }
 
-  /// @brief Temporary lifecycle policy for GraphObject-based graph storage.
-  [[nodiscard]] bool canBeDestructed() const override {
-    return true;
-  }
-
-  [[nodiscard]] AudioParam *asAudioParam() override {
-    return this;
-  }
-
-  [[nodiscard]] const AudioParam *asAudioParam() const override {
-    return this;
-  }
-
   /// Audio-Thread only methods
   /// These methods are called only from the Audio rendering thread.
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 671a15784..7d848b81a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -1,27 +1,7 @@
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/effects/BiquadFilterNode.h>
-#include <audioapi/core/effects/ConvolverNode.h>
-#include <audioapi/core/effects/DelayNode.h>
-#include <audioapi/core/effects/GainNode.h>
-#include <audioapi/core/effects/IIRFilterNode.h>
-#include <audioapi/core/effects/StereoPannerNode.h>
-#include <audioapi/core/effects/WaveShaperNode.h>
-#include <audioapi/core/effects/WorkletNode.h>
-#include <audioapi/core/effects/WorkletProcessingNode.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/types/NodeOptions.h>
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-#include <audioapi/core/sources/StreamerNode.h>
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-#include <audioapi/core/sources/WorkletSourceNode.h>
+#include <audioapi/core/utils/graph/DestinationGraphObject.hpp>
 #include <audioapi/core/utils/AudioDecoder.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.hpp>
@@ -41,14 +21,14 @@ BaseAudioContext::BaseAudioContext(
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry),
       audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
-      graphManager_(std::make_unique<AudioGraphManager>(this)),
       disposer_(
           std::make_unique<utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize>>(
               AUDIO_SCHEDULER_CAPACITY)),
       graph_(std::make_shared<utils::graph::Graph>(AUDIO_SCHEDULER_CAPACITY, disposer_.get())) {}
 
-void BaseAudioContext::initialize() {
+utils::graph::HostGraph::Node *BaseAudioContext::initialize() {
   destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
+  return graph_->addNode(std::make_unique<DestinationGraphObject>(destination_.get()));
 }
 
 ContextState BaseAudioContext::getState() {
@@ -66,13 +46,11 @@ float BaseAudioContext::getSampleRate() const {
 }
 
 std::size_t BaseAudioContext::getCurrentSampleFrame() const {
-  assert(destination_ != nullptr);
-  return destination_->getCurrentSampleFrame();
+  return currentSampleFrame_.load(std::memory_order_acquire);
 }
 
 double BaseAudioContext::getCurrentTime() const {
-  assert(destination_ != nullptr);
-  return destination_->getCurrentTime();
+  return static_cast<double>(getCurrentSampleFrame()) / getSampleRate();
 }
 
 std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() const {
@@ -118,10 +96,6 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::getBasicWaveForm(OscillatorType
   }
 }
 
-AudioGraphManager *BaseAudioContext::getGraphManager() const {
-  return graphManager_.get();
-}
-
 std::shared_ptr<utils::graph::Graph> BaseAudioContext::getGraph() const {
   return graph_;
 }
@@ -139,4 +113,22 @@ utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *BaseAudioContext
   return disposer_.get();
 }
 
+void BaseAudioContext::processGraph(DSPAudioBuffer *buffer, int numFrames) {
+  graph_->processEvents();
+  graph_->process();
+  processAudioEvents();
+
+  for (auto &&[node, inputs] : graph_->iter()) {
+    auto audioNode = node.asAudioNode();
+    if (audioNode != nullptr) {
+      audioNode->process(inputs, numFrames);
+      if (audioNode == destination_.get()) {
+        buffer->copy(*audioNode->getAudioBuffer(), 0, 0, numFrames);
+      }
+    }
+  }
+
+  currentSampleFrame_.fetch_add(numFrames, std::memory_order_release);
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 7c1fa6693..f3b31c098 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -19,41 +19,10 @@
 
 namespace audioapi {
 
-class GainNode;
-class DelayNode;
-class PeriodicWave;
-class OscillatorNode;
-class ConstantSourceNode;
-class StereoPannerNode;
-class AudioGraphManager;
-class BiquadFilterNode;
-class IIRFilterNode;
-class AudioDestinationNode;
-class AudioBufferSourceNode;
-class AudioBufferQueueSourceNode;
-class AnalyserNode;
 class AudioEventHandlerRegistry;
-class ConvolverNode;
 class IAudioEventHandlerRegistry;
-class RecorderAdapterNode;
-class WaveShaperNode;
-class WorkletSourceNode;
-class WorkletNode;
-class WorkletProcessingNode;
-class StreamerNode;
-struct GainOptions;
-struct StereoPannerOptions;
-struct ConvolverOptions;
-struct ConstantSourceOptions;
-struct AnalyserOptions;
-struct BiquadFilterOptions;
-struct OscillatorOptions;
-struct BaseAudioBufferSourceOptions;
-struct AudioBufferSourceOptions;
-struct StreamerOptions;
-struct DelayOptions;
-struct IIRFilterOptions;
-struct WaveShaperOptions;
+class PeriodicWave;
+class AudioDestinationNode;
 
 class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
  public:
@@ -77,13 +46,14 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
       int length) const;
 
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
-  AudioGraphManager *getGraphManager() const;
   std::shared_ptr<utils::graph::Graph> getGraph() const;
   std::shared_ptr<IAudioEventHandlerRegistry> getAudioEventHandlerRegistry() const;
   const RuntimeRegistry &getRuntimeRegistry() const;
   utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *getDisposer() const;
 
-  virtual void initialize();
+  /// @brief Initializes audio destination and its corresponding graph node and adds it to graph. Must be called before using the context.
+  /// @return The graph node corresponding to the audio destination.
+  virtual utils::graph::HostGraph::Node *initialize();
 
   void inline processAudioEvents() {
     audioEventScheduler_.processAllEvents(*this);
@@ -100,7 +70,10 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
     return audioEventScheduler_.scheduleEvent(std::forward<F>(event));
   }
 
+  void processGraph(DSPAudioBuffer *buffer, int numFrames);
+
  protected:
+  std::atomic<std::size_t> currentSampleFrame_{0};
   std::shared_ptr<AudioDestinationNode> destination_;
 
  private:
@@ -116,7 +89,6 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
-  std::unique_ptr<AudioGraphManager> graphManager_;
 
   std::unique_ptr<utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize>> disposer_;
   std::shared_ptr<utils::graph::Graph> graph_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp
index d78479a01..84f78da29 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.cpp
@@ -2,7 +2,6 @@
 
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
 #include <audioapi/utils/AudioArray.hpp>
@@ -29,10 +28,6 @@ OfflineAudioContext::OfflineAudioContext(
           std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, numberOfChannels, sampleRate)),
       resultBuffer_(std::make_shared<AudioBuffer>(length, numberOfChannels, sampleRate)) {}
 
-OfflineAudioContext::~OfflineAudioContext() {
-  getGraphManager()->cleanup();
-}
-
 void OfflineAudioContext::resume() {
   Locker locker(mutex_);
 
@@ -70,7 +65,7 @@ void OfflineAudioContext::renderAudio() {
           std::min(static_cast<int>(length_ - currentSampleFrame_), RENDER_QUANTUM_SIZE);
 
       audioBuffer_->zero();
-      destination_->renderAudio(audioBuffer_, framesToProcess);
+      processGraph(audioBuffer_.get(), framesToProcess);
 
       resultBuffer_->copy(*audioBuffer_, 0, currentSampleFrame_, framesToProcess);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.h
index be9a3a546..581a44c3d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/OfflineAudioContext.h
@@ -21,7 +21,6 @@ class OfflineAudioContext : public BaseAudioContext {
       float sampleRate,
       const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const RuntimeRegistry &runtimeRegistry);
-  ~OfflineAudioContext() override;
 
   /// @note JS Thread only
   void resume();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
index c2fe1d96b..869536705 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
@@ -87,14 +87,12 @@ void AnalyserNode::getByteTimeDomainData(uint8_t *data, int length) {
   }
 }
 
-std::shared_ptr<DSPAudioBuffer> AnalyserNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void AnalyserNode::processNode(int framesToProcess) {
   // Analyser should behave like a sniffer node, it should not modify the
-  // processingBuffer but instead copy the data to its own input buffer.
+  // audioBuffer_ but instead copy the data to its own input buffer.
 
   // Down mix the input buffer to mono
-  downMixBuffer_->copy(*processingBuffer);
+  downMixBuffer_->copy(*audioBuffer_);
   // Copy the down mixed buffer to the input buffer (circular buffer)
   inputArray_->push_back(*downMixBuffer_->getChannel(0), framesToProcess, true);
 
@@ -105,8 +103,6 @@ std::shared_ptr<DSPAudioBuffer> AnalyserNode::processNode(
   frame->sequenceNumber = ++publishSequence_;
   inputArray_->pop_back(frame->timeDomain, fftSize, 0, true);
   analysisBuffer_.publish();
-
-  return processingBuffer;
 }
 
 void AnalyserNode::doFFTAnalysis() {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.h
index fd7ef326c..eb8ec876a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.h
@@ -75,9 +75,7 @@ class AnalyserNode : public AudioNode {
   void getByteTimeDomainData(uint8_t *data, int length);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   std::atomic<int> fftSize_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
index e7fcd1d40..a5da28694 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
@@ -1,7 +1,6 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/types/NodeOptions.h>
 
 #include <memory>
@@ -9,41 +8,8 @@
 namespace audioapi {
 
 AudioDestinationNode::AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context)
-    : AudioNode(context, AudioDestinationOptions()), currentSampleFrame_(0) {
+    : AudioNode(context, AudioDestinationOptions()) {
   isInitialized_.store(true, std::memory_order_release);
 }
 
-std::size_t AudioDestinationNode::getCurrentSampleFrame() const {
-  return currentSampleFrame_.load(std::memory_order_acquire);
-}
-
-double AudioDestinationNode::getCurrentTime() const {
-  return static_cast<double>(getCurrentSampleFrame()) / getContextSampleRate();
-}
-
-void AudioDestinationNode::renderAudio(
-    const std::shared_ptr<DSPAudioBuffer> &destinationBuffer,
-    int numFrames) {
-  if (numFrames < 0 || !destinationBuffer || !isInitialized_.load(std::memory_order_acquire)) {
-    return;
-  }
-
-  if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
-    context->processAudioEvents();
-    context->getGraphManager()->preProcessGraph();
-  }
-
-  destinationBuffer->zero();
-
-  auto processedBuffer = processAudio(destinationBuffer, numFrames, true);
-
-  if (processedBuffer && processedBuffer != destinationBuffer) {
-    destinationBuffer->copy(*processedBuffer);
-  }
-
-  destinationBuffer->normalize();
-
-  currentSampleFrame_.fetch_add(numFrames, std::memory_order_release);
-}
-
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
index 5135751da..b8ddc654b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
@@ -4,7 +4,6 @@
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
-#include <atomic>
 #include <cstddef>
 #include <memory>
 
@@ -16,26 +15,11 @@ class AudioDestinationNode : public AudioNode {
  public:
   explicit AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context);
 
-  /// @note Thread safe
-  std::size_t getCurrentSampleFrame() const;
-
-  /// @note Thread safe
-  double getCurrentTime() const;
-
-  /// @note Audio Thread only
-  void renderAudio(const std::shared_ptr<DSPAudioBuffer> &audioData, int numFrames);
-
  protected:
-  // DestinationNode is triggered by AudioContext using renderAudio
-  // processNode function is not necessary and is never called.
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int) final {
-    return processingBuffer;
+  // DestinationNode's processNode is never called; graph traversal skips it.
+  void processNode(int) final {
+    audioBuffer_->normalize();
   };
-
- private:
-  std::atomic<std::size_t> currentSampleFrame_;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
index 3988093e6..4074c0a66 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
@@ -380,9 +380,7 @@ BiquadFilterNode::FilterCoefficients BiquadFilterNode::applyFilter(
   return coeffs;
 }
 
-std::shared_ptr<DSPAudioBuffer> BiquadFilterNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void BiquadFilterNode::processNode(int framesToProcess) {
   if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
     auto currentTime = context->getCurrentTime();
     float frequency = frequencyParam_->processKRateParam(RENDER_QUANTUM_SIZE, currentTime);
@@ -394,10 +392,10 @@ std::shared_ptr<DSPAudioBuffer> BiquadFilterNode::processNode(
 
     float x1, x2, y1, y2;
 
-    auto numChannels = processingBuffer->getNumberOfChannels();
+    auto numChannels = audioBuffer_->getNumberOfChannels();
 
     for (size_t c = 0; c < numChannels; ++c) {
-      auto channel = processingBuffer->getChannel(c)->subSpan(framesToProcess);
+      auto channel = audioBuffer_->getChannel(c)->subSpan(framesToProcess);
 
       x1 = x1_[c];
       x2 = x2_[c];
@@ -428,10 +426,8 @@ std::shared_ptr<DSPAudioBuffer> BiquadFilterNode::processNode(
       y2_[c] = y2;
     }
   } else {
-    processingBuffer->zero();
+    audioBuffer_->zero();
   }
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h
index 47288f131..de45fa9f3 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h
@@ -68,9 +68,7 @@ class BiquadFilterNode : public AudioNode {
       BiquadFilterType type);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   const std::shared_ptr<AudioParam> frequencyParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index 58adf4441..0ddc4bd12 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -93,29 +93,8 @@ float ConvolverNode::calculateNormalizationScale(const std::shared_ptr<AudioBuff
   return scaleFactor;
 }
 
-void ConvolverNode::onInputDisabled() {
-  numberOfEnabledInputNodes_ -= 1;
-  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
-    signalledToStop_ = true;
-    remainingSegments_ = convolvers_.at(0)->getSegCount();
-  }
-}
-
-std::shared_ptr<DSPAudioBuffer> ConvolverNode::processInputs(
-    const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  if (internalBufferIndex_ < framesToProcess) {
-    return AudioNode::processInputs(outputBuffer, RENDER_QUANTUM_SIZE, false);
-  }
-  return AudioNode::processInputs(outputBuffer, 0, false);
-}
-
-// processing pipeline: processingBuffer -> intermediateBuffer_ -> audioBuffer_ (mixing
-// with intermediateBuffer_)
-std::shared_ptr<DSPAudioBuffer> ConvolverNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+// processing pipeline: audioBuffer_ (input) -> intermediateBuffer_ -> audioBuffer_ (output)
+void ConvolverNode::processNode(int framesToProcess) {
   if (signalledToStop_) {
     if (remainingSegments_ > 0) {
       remainingSegments_--;
@@ -123,11 +102,12 @@ std::shared_ptr<DSPAudioBuffer> ConvolverNode::processNode(
       disable();
       signalledToStop_ = false;
       internalBufferIndex_ = 0;
-      return processingBuffer;
+      return;
     }
   }
   if (internalBufferIndex_ < framesToProcess) {
-    performConvolution(processingBuffer); // result returned to intermediateBuffer_
+    performConvolution(audioBuffer_); // reads from audioBuffer_, result goes to intermediateBuffer_
+    audioBuffer_->zero();
     audioBuffer_->sum(*intermediateBuffer_);
 
     internalBuffer_->copy(*audioBuffer_, 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
@@ -147,8 +127,6 @@ std::shared_ptr<DSPAudioBuffer> ConvolverNode::processNode(
   for (int i = 0; i < audioBuffer_->getNumberOfChannels(); ++i) {
     audioBuffer_->getChannel(i)->scale(scaleFactor_);
   }
-
-  return audioBuffer_;
 }
 
 void ConvolverNode::performConvolution(const std::shared_ptr<DSPAudioBuffer> &processingBuffer) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
index 7f04e3d13..f25def0a4 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
@@ -36,16 +36,9 @@ class ConvolverNode : public AudioNode {
   float calculateNormalizationScale(const std::shared_ptr<AudioBuffer> &buffer);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
-  std::shared_ptr<DSPAudioBuffer> processInputs(
-      const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-      int framesToProcess,
-      bool checkIsAlreadyProcessed) override;
-  void onInputDisabled() override;
   const float gainCalibrationSampleRate_;
   size_t remainingSegments_;
   size_t internalBufferIndex_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
index d33e376a6..d21141762 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
@@ -26,14 +26,6 @@ std::shared_ptr<AudioParam> DelayNode::getDelayTimeParam() const {
   return delayTimeParam_;
 }
 
-void DelayNode::onInputDisabled() {
-  numberOfEnabledInputNodes_ -= 1;
-  if (isEnabled() && numberOfEnabledInputNodes_ == 0) {
-    signalledToStop_ = true;
-    remainingFrames_ = delayTimeParam_->getValue() * getContextSampleRate();
-  }
-}
-
 void DelayNode::delayBufferOperation(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     int framesToProcess,
@@ -75,39 +67,32 @@ void DelayNode::delayBufferOperation(
 // processing is split into two parts
 // 1. writing to delay buffer (mixing if needed) from processing buffer
 // 2. reading from delay buffer to processing buffer (mixing if needed) with delay
-std::shared_ptr<DSPAudioBuffer> DelayNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void DelayNode::processNode(int framesToProcess) {
   // handling tail processing
   if (signalledToStop_) {
     if (remainingFrames_ <= 0) {
       disable();
       signalledToStop_ = false;
-      return processingBuffer;
+      return;
     }
 
-    delayBufferOperation(
-        processingBuffer, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
+    delayBufferOperation(audioBuffer_, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
     remainingFrames_ -= framesToProcess;
-    return processingBuffer;
+    return;
   }
 
   // normal processing
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context->getCurrentTime());
   size_t writeIndex = static_cast<size_t>(readIndex_ + delayTime * context->getSampleRate()) %
       delayBuffer_->getSize();
-  delayBufferOperation(
-      processingBuffer, framesToProcess, writeIndex, DelayNode::BufferAction::WRITE);
-  delayBufferOperation(
-      processingBuffer, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
-
-  return processingBuffer;
+  delayBufferOperation(audioBuffer_, framesToProcess, writeIndex, DelayNode::BufferAction::WRITE);
+  delayBufferOperation(audioBuffer_, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
index 38d1efe9f..4c06518aa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
@@ -17,12 +17,9 @@ class DelayNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
-  void onInputDisabled() override;
   enum class BufferAction { READ, WRITE };
   void delayBufferOperation(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp
index b14938f8d..5851d2a9e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp
@@ -23,22 +23,18 @@ std::shared_ptr<AudioParam> GainNode::getGainParam() const {
   return gainParam_;
 }
 
-std::shared_ptr<DSPAudioBuffer> GainNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void GainNode::processNode(int framesToProcess) {
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr)
-    return processingBuffer;
+    return;
   double time = context->getCurrentTime();
   auto gainParamValues = gainParam_->processARateParam(framesToProcess, time);
   auto gainValues = gainParamValues->getChannel(0);
 
-  for (size_t i = 0; i < processingBuffer->getNumberOfChannels(); i++) {
-    auto channel = processingBuffer->getChannel(i);
+  for (size_t i = 0; i < audioBuffer_->getNumberOfChannels(); i++) {
+    auto channel = audioBuffer_->getChannel(i);
     channel->multiply(*gainValues, framesToProcess);
   }
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.h
index 797a44c5a..37df303c3 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.h
@@ -17,9 +17,7 @@ class GainNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   const std::shared_ptr<AudioParam> gainParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp
index 16e4b7b78..d023cb4bc 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp
@@ -97,10 +97,8 @@ void IIRFilterNode::getFrequencyResponse(
 
 // TODO: tail
 
-std::shared_ptr<DSPAudioBuffer> IIRFilterNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
-  int numChannels = processingBuffer->getNumberOfChannels();
+void IIRFilterNode::processNode(int framesToProcess) {
+  int numChannels = audioBuffer_->getNumberOfChannels();
 
   size_t feedforwardLength = feedforward_.getSize();
   size_t feedbackLength = feedback_.getSize();
@@ -109,7 +107,7 @@ std::shared_ptr<DSPAudioBuffer> IIRFilterNode::processNode(
   int mask = bufferLength - 1;
 
   for (int c = 0; c < numChannels; ++c) {
-    auto channel = processingBuffer->getChannel(c)->subSpan(framesToProcess);
+    auto channel = audioBuffer_->getChannel(c)->subSpan(framesToProcess);
 
     auto &x = xBuffers_[c];
     auto &y = yBuffers_[c];
@@ -146,7 +144,6 @@ std::shared_ptr<DSPAudioBuffer> IIRFilterNode::processNode(
     }
     bufferIndices_[c] = bufferIndex;
   }
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.h
index dfffbe62b..a74cba7ae 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.h
@@ -52,9 +52,7 @@ class IIRFilterNode : public AudioNode {
       size_t length) const;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   static constexpr size_t bufferLength = 32;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
index b47f05c4d..9529b0ddc 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
@@ -22,12 +22,10 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
   return panParam_;
 }
 
-std::shared_ptr<DSPAudioBuffer> StereoPannerNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void StereoPannerNode::processNode(int framesToProcess) {
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr)
-    return processingBuffer;
+    return;
   double time = context->getCurrentTime();
   double deltaTime = 1.0 / context->getSampleRate();
 
@@ -37,8 +35,8 @@ std::shared_ptr<DSPAudioBuffer> StereoPannerNode::processNode(
   auto outputRight = audioBuffer_->getChannelByType(AudioBuffer::ChannelRight)->span();
 
   // Input is mono
-  if (processingBuffer->getNumberOfChannels() == 1) {
-    auto inputLeft = processingBuffer->getChannelByType(AudioBuffer::ChannelMono)->span();
+  if (audioBuffer_->getNumberOfChannels() == 1) {
+    auto inputLeft = audioBuffer_->getChannelByType(AudioBuffer::ChannelMono)->span();
 
     for (int i = 0; i < framesToProcess; i++) {
       const auto pan = std::clamp(panParamValues[i], -1.0f, 1.0f);
@@ -51,8 +49,8 @@ std::shared_ptr<DSPAudioBuffer> StereoPannerNode::processNode(
       time += deltaTime;
     }
   } else { // Input is stereo
-    auto inputLeft = processingBuffer->getChannelByType(AudioBuffer::ChannelLeft)->span();
-    auto inputRight = processingBuffer->getChannelByType(AudioBuffer::ChannelRight)->span();
+    auto inputLeft = audioBuffer_->getChannelByType(AudioBuffer::ChannelLeft)->span();
+    auto inputRight = audioBuffer_->getChannelByType(AudioBuffer::ChannelRight)->span();
 
     for (int i = 0; i < framesToProcess; i++) {
       const auto pan = std::clamp(panParamValues[i], -1.0f, 1.0f);
@@ -73,8 +71,6 @@ std::shared_ptr<DSPAudioBuffer> StereoPannerNode::processNode(
       time += deltaTime;
     }
   }
-
-  return audioBuffer_;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
index f54f26682..95c6dd410 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
@@ -20,9 +20,7 @@ class StereoPannerNode : public AudioNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   const std::shared_ptr<AudioParam> panParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
index a2b8c776f..118f40730 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
@@ -36,20 +36,16 @@ void WaveShaperNode::setCurve(const std::shared_ptr<AudioArray> &curve) {
   }
 }
 
-std::shared_ptr<DSPAudioBuffer> WaveShaperNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void WaveShaperNode::processNode(int framesToProcess) {
   if (curve_ == nullptr) {
-    return processingBuffer;
+    return;
   }
 
-  for (size_t channel = 0; channel < processingBuffer->getNumberOfChannels(); channel++) {
-    auto channelData = processingBuffer->getChannel(channel);
+  for (size_t channel = 0; channel < audioBuffer_->getNumberOfChannels(); channel++) {
+    auto channelData = audioBuffer_->getChannel(channel);
 
     waveShapers_[channel]->process(*channelData, framesToProcess);
   }
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h
index f47bb9ab5..97a2bea62 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.h
@@ -26,9 +26,7 @@ class WaveShaperNode : public AudioNode {
   void setCurve(const std::shared_ptr<AudioArray> &curve);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   OverSampleType oversample_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp
index 3c772bbbe..611052125 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp
@@ -20,12 +20,10 @@ WorkletNode::WorkletNode(
   isInitialized_.store(true, std::memory_order_release);
 }
 
-std::shared_ptr<DSPAudioBuffer> WorkletNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void WorkletNode::processNode(int framesToProcess) {
   size_t processed = 0;
   size_t channelCount_ =
-      std::min(inputChannelCount_, static_cast<size_t>(processingBuffer->getNumberOfChannels()));
+      std::min(inputChannelCount_, static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
   while (processed < framesToProcess) {
     size_t framesToWorkletInvoke = bufferLength_ - curBuffIndex_;
     size_t needsToProcess = framesToProcess - processed;
@@ -34,7 +32,7 @@ std::shared_ptr<DSPAudioBuffer> WorkletNode::processNode(
     /// here we copy
     /// to [curBuffIndex_, curBuffIndex_ + shouldProcess]
     /// from [processed, processed + shouldProcess]
-    buffer_->copy(*processingBuffer, processed, curBuffIndex_, shouldProcess);
+    buffer_->copy(*audioBuffer_, processed, curBuffIndex_, shouldProcess);
 
     processed += shouldProcess;
     curBuffIndex_ += shouldProcess;
@@ -66,8 +64,6 @@ std::shared_ptr<DSPAudioBuffer> WorkletNode::processNode(
       return jsi::Value::undefined();
     });
   }
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.h
index 8d8d3b6e1..dcc8b8752 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.h
@@ -23,11 +23,7 @@ class WorkletNode : public AudioNode {
       : AudioNode(context) {}
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return processingBuffer;
-  }
+  void processNode(int framesToProcess) override {}
 };
 #else
 
@@ -44,9 +40,7 @@ class WorkletNode : public AudioNode {
   ~WorkletNode() override = default;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   WorkletsRunner workletRunner_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
index 2095ce87c..2bac2ec6e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
@@ -22,16 +22,14 @@ WorkletProcessingNode::WorkletProcessingNode(
   isInitialized_.store(true, std::memory_order_release);
 }
 
-std::shared_ptr<DSPAudioBuffer> WorkletProcessingNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void WorkletProcessingNode::processNode(int framesToProcess) {
   size_t channelCount = std::min(
       static_cast<size_t>(2), // Fixed to stereo for now
-      static_cast<size_t>(processingBuffer->getNumberOfChannels()));
+      static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
 
   // Copy input data to pre-allocated input buffers
   for (size_t ch = 0; ch < channelCount; ch++) {
-    inputBuffsHandles_[ch]->copy(*processingBuffer->getChannel(ch), 0, 0, framesToProcess);
+    inputBuffsHandles_[ch]->copy(*audioBuffer_->getChannel(ch), 0, 0, framesToProcess);
   }
 
   // Execute the worklet
@@ -66,7 +64,7 @@ std::shared_ptr<DSPAudioBuffer> WorkletProcessingNode::processNode(
 
   // Copy processed output data back to the processing buffer or zero on failure
   for (size_t ch = 0; ch < channelCount; ch++) {
-    auto channelData = processingBuffer->getChannel(ch);
+    auto channelData = audioBuffer_->getChannel(ch);
 
     if (result.has_value()) {
       // Copy processed output data
@@ -76,8 +74,6 @@ std::shared_ptr<DSPAudioBuffer> WorkletProcessingNode::processNode(
       channelData->zero(0, framesToProcess);
     }
   }
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.h
index ffd7473a3..6e917c7c9 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.h
@@ -22,11 +22,7 @@ class WorkletProcessingNode : public AudioNode {
       : AudioNode(context) {}
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return processingBuffer;
-  }
+  void processNode(int framesToProcess) override {}
 };
 #else
 
@@ -39,9 +35,7 @@ class WorkletProcessingNode : public AudioNode {
       WorkletsRunner &&workletRunner);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   WorkletsRunner workletRunner_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp
index b5ba27a7d..b879b821f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp
@@ -72,23 +72,19 @@ void AudioBufferBaseSourceNode::unregisterOnPositionChangedCallback(uint64_t cal
   audioEventHandlerRegistry_->unregisterHandler(AudioEvent::POSITION_CHANGED, callbackId);
 }
 
-std::shared_ptr<DSPAudioBuffer> AudioBufferBaseSourceNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void AudioBufferBaseSourceNode::processNode(int framesToProcess) {
   if (isEmpty()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   if (!pitchCorrection_) {
-    processWithoutPitchCorrection(processingBuffer, framesToProcess);
+    processWithoutPitchCorrection(audioBuffer_, framesToProcess);
   } else {
-    processWithPitchCorrection(processingBuffer, framesToProcess);
+    processWithPitchCorrection(audioBuffer_, framesToProcess);
   }
 
   handleStopScheduled();
-
-  return processingBuffer;
 }
 
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h
index 621c44e5c..ed8ed6e83 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h
@@ -37,9 +37,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
   // internal helper
   double vReadIndex_;
 
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) final;
+  void processNode(int framesToProcess) final;
 
   virtual double getCurrentPosition() const = 0;
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
index 178326881..ccf820377 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
@@ -1,6 +1,5 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/dsp/AudioUtils.hpp>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.hpp>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp
index a31ee464a..d52bf9c37 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp
@@ -24,20 +24,18 @@ std::shared_ptr<AudioParam> ConstantSourceNode::getOffsetParam() const {
   return offsetParam_;
 }
 
-std::shared_ptr<DSPAudioBuffer> ConstantSourceNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void ConstantSourceNode::processNode(int framesToProcess) {
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   updatePlaybackInfo(
-      processingBuffer,
+      audioBuffer_,
       framesToProcess,
       startOffset,
       offsetLength,
@@ -45,22 +43,19 @@ std::shared_ptr<DSPAudioBuffer> ConstantSourceNode::processNode(
       context->getCurrentSampleFrame());
 
   if (!isPlaying() && !isStopScheduled()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   auto offsetChannel =
       offsetParam_->processARateParam(framesToProcess, context->getCurrentTime())->getChannel(0);
 
-  for (size_t channel = 0; channel < processingBuffer->getNumberOfChannels(); ++channel) {
-    processingBuffer->getChannel(channel)->copy(
-        *offsetChannel, startOffset, startOffset, offsetLength);
+  for (size_t channel = 0; channel < audioBuffer_->getNumberOfChannels(); ++channel) {
+    audioBuffer_->getChannel(channel)->copy(*offsetChannel, startOffset, startOffset, offsetLength);
   }
 
   if (isStopScheduled()) {
     handleStopScheduled();
   }
-
-  return processingBuffer;
 }
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.h
index 33b50d35c..f2c5d1f4c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.h
@@ -19,9 +19,7 @@ class ConstantSourceNode : public AudioScheduledSourceNode {
   [[nodiscard]] std::shared_ptr<AudioParam> getOffsetParam() const;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   const std::shared_ptr<AudioParam> offsetParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
index 8916495ba..8acbd634b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
@@ -50,20 +50,18 @@ void OscillatorNode::setPeriodicWave(const std::shared_ptr<PeriodicWave> &period
   type_ = OscillatorType::CUSTOM;
 }
 
-std::shared_ptr<DSPAudioBuffer> OscillatorNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void OscillatorNode::processNode(int framesToProcess) {
   size_t startOffset = 0;
   size_t offsetLength = 0;
 
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   updatePlaybackInfo(
-      processingBuffer,
+      audioBuffer_,
       framesToProcess,
       startOffset,
       offsetLength,
@@ -71,8 +69,8 @@ std::shared_ptr<DSPAudioBuffer> OscillatorNode::processNode(
       context->getCurrentSampleFrame());
 
   if (!isPlaying() && !isStopScheduled()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   auto time =
@@ -82,9 +80,9 @@ std::shared_ptr<DSPAudioBuffer> OscillatorNode::processNode(
 
   const auto tableSize = static_cast<float>(periodicWave_->getPeriodicWaveSize());
   const auto tableScale = periodicWave_->getScale();
-  const auto numChannels = processingBuffer->getNumberOfChannels();
+  const auto numChannels = audioBuffer_->getNumberOfChannels();
 
-  auto channelSpan = processingBuffer->getChannel(0)->span();
+  auto channelSpan = audioBuffer_->getChannel(0)->span();
   float currentPhase = phase_;
 
   for (size_t i = startOffset; i < offsetLength; i += 1) {
@@ -106,11 +104,9 @@ std::shared_ptr<DSPAudioBuffer> OscillatorNode::processNode(
   phase_ = currentPhase;
 
   for (size_t ch = 1; ch < numChannels; ch += 1) {
-    processingBuffer->getChannel(ch)->copy(*processingBuffer->getChannel(0));
+    audioBuffer_->getChannel(ch)->copy(*audioBuffer_->getChannel(0));
   }
   handleStopScheduled();
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.h
index 73d41c25e..7244994e2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.h
@@ -27,9 +27,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp
index 7b99755e8..40f69c002 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.cpp
@@ -67,12 +67,10 @@ void RecorderAdapterNode::cleanup() {
   isInitialized_.store(false, std::memory_order_release);
 }
 
-std::shared_ptr<DSPAudioBuffer> RecorderAdapterNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void RecorderAdapterNode::processNode(int framesToProcess) {
   if (!isInitialized_.load(std::memory_order_acquire)) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   if (needsResampling_) {
@@ -81,8 +79,7 @@ std::shared_ptr<DSPAudioBuffer> RecorderAdapterNode::processNode(
     readFrames(*adapterOutputBuffer_, framesToProcess);
   }
 
-  processingBuffer->sum(*adapterOutputBuffer_, ChannelInterpretation::SPEAKERS);
-  return processingBuffer;
+  audioBuffer_->sum(*adapterOutputBuffer_, ChannelInterpretation::SPEAKERS);
 }
 
 void RecorderAdapterNode::processResampled(int framesToProcess) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h
index 7b58de462..f518e0f76 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h
@@ -33,9 +33,7 @@ class RecorderAdapterNode : public AudioNode {
   std::vector<std::shared_ptr<CircularOverflowableAudioArray>> buff_;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
   std::shared_ptr<AudioBuffer> adapterOutputBuffer_;
 
  private:
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
index 197cc92a4..e1c5e91d2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
@@ -56,19 +56,17 @@ StreamerNode::~StreamerNode() {
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 }
 
-std::shared_ptr<DSPAudioBuffer> StreamerNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void StreamerNode::processNode(int framesToProcess) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
   size_t startOffset = 0;
   size_t offsetLength = 0;
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
   updatePlaybackInfo(
-      processingBuffer,
+      audioBuffer_,
       framesToProcess,
       startOffset,
       offsetLength,
@@ -77,15 +75,15 @@ std::shared_ptr<DSPAudioBuffer> StreamerNode::processNode(
   isNodeFinished_.store(isFinished(), std::memory_order_release);
 
   if (!isPlaying() && !isStopScheduled()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   auto bufferRemaining = static_cast<int>(bufferedAudioData_.size - processedSamples_);
   int alreadyProcessed = 0;
   if (bufferRemaining < framesToProcess) {
     if (hasBufferedAudioData_) {
-      processingBuffer->copy(bufferedAudioData_.buffer, processedSamples_, 0, bufferRemaining);
+      audioBuffer_->copy(bufferedAudioData_.buffer, processedSamples_, 0, bufferRemaining);
       framesToProcess -= bufferRemaining;
       alreadyProcessed += bufferRemaining;
     }
@@ -99,13 +97,11 @@ std::shared_ptr<DSPAudioBuffer> StreamerNode::processNode(
     }
   }
   if (hasBufferedAudioData_ && framesToProcess > 0) {
-    processingBuffer->copy(
+    audioBuffer_->copy(
         bufferedAudioData_.buffer, processedSamples_, alreadyProcessed, framesToProcess);
     processedSamples_ += framesToProcess;
   }
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
-
-  return processingBuffer;
 }
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h
index 70ae44973..a576d943b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h
@@ -68,9 +68,7 @@ class StreamerNode : public AudioScheduledSourceNode {
   ~StreamerNode() override;
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   std::string streamPath_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp
index 7f700c74a..c39bf0fd1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp
@@ -19,12 +19,10 @@ WorkletSourceNode::WorkletSourceNode(
   isInitialized_.store(true, std::memory_order_release);
 }
 
-std::shared_ptr<DSPAudioBuffer> WorkletSourceNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
-  if (isUnscheduled() || isFinished() || !isEnabled()) {
-    processingBuffer->zero();
-    return processingBuffer;
+void WorkletSourceNode::processNode(int framesToProcess) {
+  if (isUnscheduled() || isFinished()) {
+    audioBuffer_->zero();
+    return;
   }
 
   size_t startOffset = 0;
@@ -32,11 +30,11 @@ std::shared_ptr<DSPAudioBuffer> WorkletSourceNode::processNode(
 
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
   updatePlaybackInfo(
-      processingBuffer,
+      audioBuffer_,
       framesToProcess,
       startOffset,
       nonSilentFramesToProcess,
@@ -44,11 +42,11 @@ std::shared_ptr<DSPAudioBuffer> WorkletSourceNode::processNode(
       context->getCurrentSampleFrame());
 
   if (nonSilentFramesToProcess == 0) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
-  size_t outputChannelCount = processingBuffer->getNumberOfChannels();
+  size_t outputChannelCount = audioBuffer_->getNumberOfChannels();
 
   auto result = workletRunner_.executeOnRuntimeSync(
       [this, nonSilentFramesToProcess, startOffset, time = context->getCurrentTime()](
@@ -72,19 +70,17 @@ std::shared_ptr<DSPAudioBuffer> WorkletSourceNode::processNode(
   // If the worklet execution failed, zero the output
   // It might happen if the runtime is not available
   if (!result.has_value()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   // Copy the processed data back to the AudioBuffer
   for (size_t i = 0; i < outputChannelCount; ++i) {
-    processingBuffer->getChannel(i)->copy(
+    audioBuffer_->getChannel(i)->copy(
         *outputBuffsHandles_[i], 0, startOffset, nonSilentFramesToProcess);
   }
 
   handleStopScheduled();
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.h
index 39ba4d00b..c22d28ad2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.h
@@ -22,11 +22,7 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
       : AudioScheduledSourceNode(context) {}
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return processingBuffer;
-  }
+  void processNode(int framesToProcess) override {}
 };
 #else
 
@@ -37,9 +33,7 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
       WorkletsRunner &&workletRunner);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   WorkletsRunner workletRunner_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
deleted file mode 100644
index 453171738..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-#include <audioapi/core/AudioNode.h>
-#include <audioapi/core/AudioParam.h>
-#include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/effects/ConvolverNode.h>
-#include <audioapi/core/effects/DelayNode.h>
-#include <audioapi/core/sources/AudioScheduledSourceNode.h>
-#include <audioapi/core/utils/AudioGraphManager.h>
-#include <audioapi/core/utils/Locker.h>
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-namespace audioapi {
-
-AudioGraphManager::Event::Event(Event &&other) noexcept {
-  *this = std::move(other);
-}
-
-AudioGraphManager::Event &AudioGraphManager::Event::operator=(Event &&other) noexcept {
-  if (this != &other) {
-    // Clean up current resources
-    this->~Event();
-
-    // Move resources from the other event
-    type = other.type;
-    payloadType = other.payloadType;
-    switch (payloadType) {
-      case EventPayloadType::NODES:
-        payload.nodes.from = std::move(other.payload.nodes.from);
-        payload.nodes.to = std::move(other.payload.nodes.to);
-        break;
-      case EventPayloadType::PARAMS:
-        payload.params.from = std::move(other.payload.params.from);
-        payload.params.to = std::move(other.payload.params.to);
-        break;
-      case EventPayloadType::SOURCE_NODE:
-        payload.sourceNode = std::move(other.payload.sourceNode);
-        break;
-      case EventPayloadType::AUDIO_PARAM:
-        payload.audioParam = std::move(other.payload.audioParam);
-        break;
-      case EventPayloadType::NODE:
-        payload.node = std::move(other.payload.node);
-        break;
-
-      default:
-        break;
-    }
-  }
-  return *this;
-}
-
-AudioGraphManager::Event::~Event() {
-  switch (payloadType) {
-    case EventPayloadType::NODES:
-      payload.nodes.from.~shared_ptr();
-      payload.nodes.to.~shared_ptr();
-      break;
-    case EventPayloadType::PARAMS:
-      payload.params.from.~shared_ptr();
-      payload.params.to.~shared_ptr();
-      break;
-    case EventPayloadType::SOURCE_NODE:
-      payload.sourceNode.~shared_ptr();
-      break;
-    case EventPayloadType::AUDIO_PARAM:
-      payload.audioParam.~shared_ptr();
-      break;
-    case EventPayloadType::NODE:
-      payload.node.~shared_ptr();
-      break;
-  }
-}
-
-AudioGraphManager::AudioGraphManager(BaseAudioContext *context)
-    : disposer_(context->getDisposer()) {
-  sourceNodes_.reserve(kInitialCapacity);
-  processingNodes_.reserve(kInitialCapacity);
-  audioParams_.reserve(kInitialCapacity);
-
-  auto channel_pair = channels::spsc::channel<
-      std::unique_ptr<Event>,
-      channels::spsc::OverflowStrategy::WAIT_ON_FULL,
-      channels::spsc::WaitStrategy::BUSY_LOOP>(kChannelCapacity);
-
-  sender_ = std::move(channel_pair.first);
-  receiver_ = std::move(channel_pair.second);
-}
-
-AudioGraphManager::~AudioGraphManager() {
-  cleanup();
-}
-
-void AudioGraphManager::addPendingNodeConnection(
-    const std::shared_ptr<AudioNode> &from,
-    const std::shared_ptr<AudioNode> &to,
-    ConnectionType type) {
-  auto event = std::make_unique<Event>();
-  event->type = type;
-  event->payloadType = EventPayloadType::NODES;
-  event->payload.nodes.from = from;
-  event->payload.nodes.to = to;
-
-  sender_.send(std::move(event));
-}
-
-void AudioGraphManager::addPendingParamConnection(
-    const std::shared_ptr<AudioNode> &from,
-    const std::shared_ptr<AudioParam> &to,
-    ConnectionType type) {
-  auto event = std::make_unique<Event>();
-  event->type = type;
-  event->payloadType = EventPayloadType::PARAMS;
-  event->payload.params.from = from;
-  event->payload.params.to = to;
-
-  sender_.send(std::move(event));
-}
-
-void AudioGraphManager::preProcessGraph() {
-  settlePendingConnections();
-  prepareForDestruction(sourceNodes_);
-  prepareForDestruction(processingNodes_);
-}
-
-void AudioGraphManager::addProcessingNode(const std::shared_ptr<AudioNode> &node) {
-  auto event = std::make_unique<Event>();
-  event->type = ConnectionType::ADD;
-  event->payloadType = EventPayloadType::NODE;
-  event->payload.node = node;
-
-  sender_.send(std::move(event));
-}
-
-void AudioGraphManager::addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node) {
-  auto event = std::make_unique<Event>();
-  event->type = ConnectionType::ADD;
-  event->payloadType = EventPayloadType::SOURCE_NODE;
-  event->payload.sourceNode = node;
-
-  sender_.send(std::move(event));
-}
-
-void AudioGraphManager::addAudioParam(const std::shared_ptr<AudioParam> &param) {
-  auto event = std::make_unique<Event>();
-  event->type = ConnectionType::ADD;
-  event->payloadType = EventPayloadType::AUDIO_PARAM;
-  event->payload.audioParam = param;
-
-  sender_.send(std::move(event));
-}
-
-void AudioGraphManager::settlePendingConnections() {
-  std::unique_ptr<Event> value;
-  while (receiver_.try_receive(value) != channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
-    switch (value->type) {
-      case ConnectionType::CONNECT:
-        handleConnectEvent(std::move(value));
-        break;
-      case ConnectionType::DISCONNECT:
-        handleDisconnectEvent(std::move(value));
-        break;
-      case ConnectionType::DISCONNECT_ALL:
-        handleDisconnectAllEvent(std::move(value));
-        break;
-      case ConnectionType::ADD:
-        handleAddToDeconstructionEvent(std::move(value));
-        break;
-    }
-  }
-}
-
-void AudioGraphManager::handleConnectEvent(std::unique_ptr<Event> event) {
-  if (event->payloadType == EventPayloadType::NODES) {
-    event->payload.nodes.from->connectNode(event->payload.nodes.to);
-  } else if (event->payloadType == EventPayloadType::PARAMS) {
-    event->payload.params.from->connectParam(event->payload.params.to);
-  } else {
-    assert(false && "Invalid payload type for connect event");
-  }
-}
-
-void AudioGraphManager::handleDisconnectEvent(std::unique_ptr<Event> event) {
-  if (event->payloadType == EventPayloadType::NODES) {
-    event->payload.nodes.from->disconnectNode(event->payload.nodes.to);
-  } else if (event->payloadType == EventPayloadType::PARAMS) {
-    event->payload.params.from->disconnectParam(event->payload.params.to);
-  } else {
-    assert(false && "Invalid payload type for disconnect event");
-  }
-}
-
-void AudioGraphManager::handleDisconnectAllEvent(std::unique_ptr<Event> event) {
-  assert(event->payloadType == EventPayloadType::NODES);
-  for (auto it = event->payload.nodes.from->outputNodes_.begin();
-       it != event->payload.nodes.from->outputNodes_.end();) {
-    auto next = std::next(it);
-    event->payload.nodes.from->disconnectNode(*it);
-    it = next;
-  }
-}
-
-void AudioGraphManager::handleAddToDeconstructionEvent(std::unique_ptr<Event> event) {
-  switch (event->payloadType) {
-    case EventPayloadType::NODE:
-      processingNodes_.push_back(event->payload.node);
-      break;
-    case EventPayloadType::SOURCE_NODE:
-      sourceNodes_.push_back(event->payload.sourceNode);
-      break;
-    case EventPayloadType::AUDIO_PARAM:
-      audioParams_.push_back(event->payload.audioParam);
-      break;
-    default:
-      assert(false && "Unknown event payload type");
-  }
-}
-
-void AudioGraphManager::cleanup() {
-  for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end; ++it) {
-    it->get()->cleanup();
-  }
-
-  for (auto it = processingNodes_.begin(), end = processingNodes_.end(); it != end; ++it) {
-    it->get()->cleanup();
-  }
-
-  sourceNodes_.clear();
-  processingNodes_.clear();
-  audioParams_.clear();
-}
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
deleted file mode 100644
index 73d977bab..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioGraphManager.h
+++ /dev/null
@@ -1,209 +0,0 @@
-#pragma once
-
-#include <audioapi/core/utils/Disposer.hpp>
-#include <audioapi/utils/AudioBuffer.hpp>
-#include <audioapi/utils/SpscChannel.hpp>
-
-#include <concepts>
-#include <memory>
-#include <utility>
-#include <vector>
-
-namespace audioapi {
-
-class AudioNode;
-class AudioScheduledSourceNode;
-class AudioParam;
-class BaseAudioContext;
-
-#define AUDIO_GRAPH_MANAGER_SPSC_OPTIONS \
-  std::unique_ptr<Event>, channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
-      channels::spsc::WaitStrategy::BUSY_LOOP
-
-template <typename T>
-concept HasCleanupMethod = requires(T t) {
-  { t.cleanup() };
-};
-
-class AudioGraphManager {
- public:
-  enum class ConnectionType { CONNECT, DISCONNECT, DISCONNECT_ALL, ADD };
-  typedef ConnectionType EventType; // for backwards compatibility
-  enum class EventPayloadType { NODES, PARAMS, SOURCE_NODE, AUDIO_PARAM, NODE };
-  union EventPayload {
-    struct {
-      std::shared_ptr<AudioNode> from;
-      std::shared_ptr<AudioNode> to;
-    } nodes;
-    struct {
-      std::shared_ptr<AudioNode> from;
-      std::shared_ptr<AudioParam> to;
-    } params;
-    std::shared_ptr<AudioScheduledSourceNode> sourceNode;
-    std::shared_ptr<AudioParam> audioParam;
-    std::shared_ptr<AudioNode> node;
-
-    // Default constructor that initializes the first member
-    EventPayload() : nodes{} {}
-
-    // Destructor - we'll handle cleanup explicitly in Event destructor
-    ~EventPayload() {}
-  };
-  struct Event {
-    EventType type;
-    EventPayloadType payloadType;
-    EventPayload payload;
-
-    Event(Event &&other) noexcept;
-    Event &operator=(Event &&other) noexcept;
-    Event() : type(ConnectionType::CONNECT), payloadType(EventPayloadType::NODES), payload() {}
-    ~Event();
-  };
-
-  explicit AudioGraphManager(BaseAudioContext *context);
-  ~AudioGraphManager();
-
-  void preProcessGraph();
-
-  /// @brief Adds a pending connection between two audio nodes.
-  /// @param from The source audio node.
-  /// @param to The destination audio node.
-  /// @param type The type of connection (connect/disconnect).
-  /// @note Should be only used from JavaScript/HostObjects thread
-  void addPendingNodeConnection(
-      const std::shared_ptr<AudioNode> &from,
-      const std::shared_ptr<AudioNode> &to,
-      ConnectionType type);
-
-  /// @brief Adds a pending connection between an audio node and an audio parameter.
-  /// @param from The source audio node.
-  /// @param to The destination audio parameter.
-  /// @param type The type of connection (connect/disconnect).
-  /// @note Should be only used from JavaScript/HostObjects thread
-  void addPendingParamConnection(
-      const std::shared_ptr<AudioNode> &from,
-      const std::shared_ptr<AudioParam> &to,
-      ConnectionType type);
-
-  /// @brief Adds a processing node to the manager.
-  /// @param node The processing node to add.
-  /// @note Should be only used from JavaScript/HostObjects thread
-  void addProcessingNode(const std::shared_ptr<AudioNode> &node);
-
-  /// @brief Adds a source node to the manager.
-  /// @param node The source node to add.
-  /// @note Should be only used from JavaScript/HostObjects thread
-  void addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node);
-
-  /// @brief Adds an audio parameter to the manager.
-  /// @param param The audio parameter to add.
-  /// @note Should be only used from JavaScript/HostObjects thread
-  void addAudioParam(const std::shared_ptr<AudioParam> &param);
-
-  void cleanup();
-
- private:
-  utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *const disposer_;
-
-  /// @brief Initial capacity for various node types for deletion
-  /// @note Higher capacity decreases number of reallocations at runtime (can be easily adjusted to 128 if needed)
-  static constexpr size_t kInitialCapacity = 32;
-
-  /// @brief Initial capacity for event passing channel
-  /// @note High value reduces wait time for sender (JavaScript/HostObjects thread here)
-  static constexpr size_t kChannelCapacity = 1024;
-
-  std::vector<std::shared_ptr<AudioScheduledSourceNode>> sourceNodes_;
-  std::vector<std::shared_ptr<AudioNode>> processingNodes_;
-  std::vector<std::shared_ptr<AudioParam>> audioParams_;
-
-  channels::spsc::Receiver<AUDIO_GRAPH_MANAGER_SPSC_OPTIONS> receiver_;
-  channels::spsc::Sender<AUDIO_GRAPH_MANAGER_SPSC_OPTIONS> sender_;
-
-  void settlePendingConnections();
-  void handleConnectEvent(std::unique_ptr<Event> event);
-  void handleDisconnectEvent(std::unique_ptr<Event> event);
-  void handleDisconnectAllEvent(std::unique_ptr<Event> event);
-  void handleAddToDeconstructionEvent(std::unique_ptr<Event> event);
-
-  template <typename U>
-  inline static bool canBeDestructed(const std::shared_ptr<U> &object) {
-    return object.use_count() == 1;
-  }
-
-  template <typename U>
-    requires std::derived_from<U, AudioNode>
-  inline static bool canBeDestructed(std::shared_ptr<U> const &node) {
-    // If the node is an AudioScheduledSourceNode, we need to check if it is
-    // playing
-    if constexpr (std::is_base_of_v<AudioScheduledSourceNode, U>) {
-      return node.use_count() == 1 && (node->isUnscheduled() || node->isFinished());
-    }
-
-    if (node->requiresTailProcessing()) {
-      // if the node requires tail processing, its own implementation handles disabling it at the right time
-      return node.use_count() == 1 && !node->isEnabled();
-    }
-
-    return node.use_count() == 1;
-  }
-
-  template <typename T>
-  void prepareForDestruction(std::vector<std::shared_ptr<T>> &vec) {
-    if (vec.empty()) {
-      return;
-    }
-    /// An example of input-output
-    /// for simplicity we will be considering vector where each value represents
-    /// use_count() of an element vec = [1, 2, 1, 3, 1] our end result will be vec
-    /// = [2, 3, 1, 1, 1] After this operation all nodes with use_count() == 1
-    /// will be at the end and we will try to send them. After sending, we will
-    /// only keep audio objects with use_count() > 1 or which failed vec = [2, 3, failed,
-    /// sent, sent] failed will be always before sents vec = [2, 3, failed] and
-    /// we resize
-    /// @note if there are no nodes with use_count() == 1 `begin` will be equal to
-    /// vec.size()
-    /// @note if all audio objects have use_count() == 1 `begin` will be 0
-
-    int begin = 0;
-    int end = vec.size() - 1; // can be -1 (edge case)
-
-    // Moves all audio objects with use_count() == 1 to the end
-    // nodes in range [begin, vec.size()) should be deleted
-    // so new size of the vector will be `begin`
-    while (begin <= end) {
-      while (begin < end && AudioGraphManager::canBeDestructed(vec[end])) {
-        end--;
-      }
-      if (AudioGraphManager::canBeDestructed(vec[begin])) {
-        std::swap(vec[begin], vec[end]);
-        end--;
-      }
-      begin++;
-    }
-
-    for (int i = begin; i < vec.size(); i++) {
-      if constexpr (HasCleanupMethod<T>) {
-        if (vec[i]) {
-          vec[i]->cleanup();
-        }
-      }
-
-      /// If we fail to add we can't safely remove the node from the vector
-      /// so we swap it and advance begin cursor
-      /// @note vec[i] does NOT get moved out if it is not successfully added.
-      if (!disposer_->dispose(std::move(vec[i]))) {
-        std::swap(vec[i], vec[begin]);
-        begin++;
-      }
-    }
-    if (begin < vec.size()) {
-      // it does not reallocate if newer size is < current size
-      vec.resize(begin);
-    }
-  }
-};
-
-#undef AUDIO_GRAPH_MANAGER_SPSC_OPTIONS
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp
new file mode 100644
index 000000000..26a717f3d
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/utils/graph/GraphObject.hpp>
+
+namespace audioapi {
+
+class DestinationGraphObject final : public utils::graph::GraphObject {
+ public:
+  explicit DestinationGraphObject(AudioDestinationNode *destination) : destination_(destination) {}
+
+  AudioNode *asAudioNode() override {
+    return destination_;
+  }
+
+  const AudioNode *asAudioNode() const override {
+    return destination_;
+  }
+
+  // Context never removes the destination from the graph.
+  bool canBeDestructed() const override {
+    return false;
+  }
+
+ private:
+  AudioDestinationNode *destination_; // non-owning; lifetime guaranteed by BaseAudioContext
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
index e57736c5b..bf16620fa 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
@@ -33,10 +33,17 @@ class TestableDelayNode : public DelayNode {
     getDelayTimeParam()->setValue(value);
   }
 
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return DelayNode::processNode(processingBuffer, framesToProcess);
+  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
+    size_t copyChannels = std::min(
+        static_cast<size_t>(input->getNumberOfChannels()),
+        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
+    for (size_t ch = 0; ch < copyChannels; ch++) {
+      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
+    }
+  }
+
+  void processNode(int framesToProcess) override {
+    DelayNode::processNode(framesToProcess);
   }
 };
 
@@ -58,7 +65,9 @@ TEST_F(DelayTest, DelayWithZeroDelayOutputsInputSignal) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  auto resultBuffer = delayNode.processNode(buffer, FRAMES_TO_PROCESS);
+  delayNode.setInput(buffer);
+  delayNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = delayNode.getAudioBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], static_cast<float>(i + 1));
   }
@@ -77,7 +86,9 @@ TEST_F(DelayTest, DelayAppliesTimeShiftCorrectly) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  auto resultBuffer = delayNode.processNode(buffer, FRAMES_TO_PROCESS);
+  delayNode.setInput(buffer);
+  delayNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = delayNode.getAudioBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be zero due to delay
       EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 0.0f);
@@ -103,8 +114,12 @@ TEST_F(DelayTest, DelayHandlesTailCorrectly) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  delayNode.processNode(buffer, FRAMES_TO_PROCESS);
-  auto resultBuffer = delayNode.processNode(buffer, FRAMES_TO_PROCESS);
+  delayNode.setInput(buffer);
+  delayNode.processNode(FRAMES_TO_PROCESS);
+  // Second call uses the result of the first call as input (same as old behavior
+  // where the same buffer object was passed to both calls)
+  delayNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = delayNode.getAudioBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be 2nd part of buffer
       EXPECT_FLOAT_EQ(
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
index 5e81f15fa..4e6b32ed8 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
@@ -33,10 +33,17 @@ class TestableGainNode : public GainNode {
     getGainParam()->setValue(value);
   }
 
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return GainNode::processNode(processingBuffer, framesToProcess);
+  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
+    size_t copyChannels = std::min(
+        static_cast<size_t>(input->getNumberOfChannels()),
+        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
+    for (size_t ch = 0; ch < copyChannels; ch++) {
+      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
+    }
+  }
+
+  void processNode(int framesToProcess) override {
+    GainNode::processNode(framesToProcess);
   }
 };
 
@@ -56,7 +63,9 @@ TEST_F(GainTest, GainModulatesVolumeCorrectly) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  auto resultBuffer = gainNode.processNode(buffer, FRAMES_TO_PROCESS);
+  gainNode.setInput(buffer);
+  gainNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = gainNode.getAudioBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], (i + 1) * GAIN_VALUE);
   }
@@ -74,7 +83,9 @@ TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
     (*buffer->getChannel(1))[i] = -i - 1;
   }
 
-  auto resultBuffer = gainNode.processNode(buffer, FRAMES_TO_PROCESS);
+  gainNode.setInput(buffer);
+  gainNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = gainNode.getAudioBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], (i + 1) * GAIN_VALUE);
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(1))[i], (-i - 1) * GAIN_VALUE);
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
index 5d14af115..60c58dbf7 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
@@ -33,10 +33,17 @@ class TestableStereoPannerNode : public StereoPannerNode {
     getPanParam()->setValue(value);
   }
 
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return StereoPannerNode::processNode(processingBuffer, framesToProcess);
+  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
+    size_t copyChannels = std::min(
+        static_cast<size_t>(input->getNumberOfChannels()),
+        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
+    for (size_t ch = 0; ch < copyChannels; ch++) {
+      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
+    }
+  }
+
+  void processNode(int framesToProcess) override {
+    StereoPannerNode::processNode(framesToProcess);
   }
 };
 
@@ -56,7 +63,9 @@ TEST_F(StereoPannerTest, PanModulatesInputMonoCorrectly) {
     (*buffer->getChannelByType(AudioBuffer::ChannelLeft))[i] = i + 1;
   }
 
-  auto resultBuffer = panNode.processNode(buffer, FRAMES_TO_PROCESS);
+  panNode.setInput(buffer);
+  panNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = panNode.getAudioBuffer();
   // x = (0.5 + 1) / 2 = 0.75
   // gainL = cos(x * (π / 2)) = cos(0.75 * (π / 2)) = 0.38268343236508984
   // gainR = sin(x * (π / 2)) = sin(0.75 * (π / 2)) = 0.9238795325112867
@@ -84,7 +93,9 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
     (*buffer->getChannelByType(AudioBuffer::ChannelRight))[i] = i + 1;
   }
 
-  auto resultBuffer = panNode.processNode(buffer, FRAMES_TO_PROCESS);
+  panNode.setInput(buffer);
+  panNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = panNode.getAudioBuffer();
   // x = -0.5 + 1 = 0.5
   // gainL = cos(x * (π / 2)) = cos(0.5 * (π / 2)) = 0.7071067811865476
   // gainR = sin(x * (π / 2)) = sin(0.5 * (π / 2)) = 0.7071067811865476
@@ -112,7 +123,9 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithPositivePan) {
     (*buffer->getChannelByType(AudioBuffer::ChannelRight))[i] = i + 1;
   }
 
-  auto resultBuffer = panNode.processNode(buffer, FRAMES_TO_PROCESS);
+  panNode.setInput(buffer);
+  panNode.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = panNode.getAudioBuffer();
   // x = 0.75
   // gainL = cos(x * (π / 2)) = cos(0.75 * (π / 2)) = 0.38268343236508984
   // gainR = sin(x * (π / 2)) = sin(0.75 * (π / 2)) = 0.9238795325112867
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
index c83134d39..3d3c79b73 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
@@ -35,10 +35,17 @@ class TestableWaveShaperNode : public WaveShaperNode {
     data[2] = 2.0f;
   }
 
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return WaveShaperNode::processNode(processingBuffer, framesToProcess);
+  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
+    size_t copyChannels = std::min(
+        static_cast<size_t>(input->getNumberOfChannels()),
+        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
+    for (size_t ch = 0; ch < copyChannels; ch++) {
+      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
+    }
+  }
+
+  void processNode(int framesToProcess) override {
+    WaveShaperNode::processNode(framesToProcess);
   }
 
   std::shared_ptr<AudioArray> testCurve_;
@@ -65,7 +72,9 @@ TEST_F(WaveShaperNodeTest, NoneOverSamplingProcessesCorrectly) {
     (*buffer->getChannel(0))[i] = -1.0f + i * 0.5f;
   }
 
-  auto resultBuffer = waveShaper->processNode(buffer, FRAMES_TO_PROCESS);
+  waveShaper->setInput(buffer);
+  waveShaper->processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = waveShaper->getAudioBuffer();
   auto curveData = waveShaper->testCurve_->span();
   auto resultData = resultBuffer->getChannel(0)->span();
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
index 1f08b82b0..9ad9a6be1 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
@@ -48,10 +48,7 @@ class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
         currentSampleFrame);
   }
 
-  std::shared_ptr<DSPAudioBuffer> processNode(const std::shared_ptr<DSPAudioBuffer> &, int)
-      override {
-    return nullptr;
-  }
+  void processNode(int) override {}
 
   PlaybackState getPlaybackState() const {
     return playbackState_;
@@ -70,7 +67,7 @@ class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
           nonSilentFramesToProcess,
           context->getSampleRate(),
           context->getCurrentSampleFrame());
-      context->getDestination()->renderAudio(processingBuffer, frames);
+      context->processGraph(processingBuffer.get(), frames);
     }
   }
 };
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
index 5d670f9b4..e0f6ae037 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
@@ -33,10 +33,8 @@ class TestableConstantSourceNode : public ConstantSourceNode {
     getOffsetParam()->setValue(value);
   }
 
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override {
-    return ConstantSourceNode::processNode(processingBuffer, framesToProcess);
+  void processNode(int framesToProcess) override {
+    ConstantSourceNode::processNode(framesToProcess);
   }
 };
 
@@ -50,16 +48,18 @@ TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
 
   auto buffer = std::make_shared<audioapi::DSPAudioBuffer>(FRAMES_TO_PROCESS, 1, sampleRate);
   auto constantSource = TestableConstantSourceNode(context);
-  // constantSource.start(context->getCurrentTime());
-  // auto resultBuffer = constantSource.processNode(buffer, FRAMES_TO_PROCESS);
+  constantSource.start(context->getCurrentTime());
+  constantSource.processNode(FRAMES_TO_PROCESS);
+  auto resultBuffer = constantSource.getAudioBuffer();
 
-  // for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
-  //   EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 1.0f);
-  // }
+  for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 1.0f);
+  }
 
-  // constantSource.setOffsetParam(0.5f);
-  // resultBuffer = constantSource.processNode(buffer, FRAMES_TO_PROCESS);
-  // for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
-  //   EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 0.5f);
-  // }
+  constantSource.setOffsetParam(0.5f);
+  constantSource.processNode(FRAMES_TO_PROCESS);
+  resultBuffer = constantSource.getAudioBuffer();
+  for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 0.5f);
+  }
 }
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
index ded44520d..3d801db7a 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
@@ -50,11 +50,7 @@ struct MockNode : AudioNode {
   }
 
  private:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBus,
-      int) override {
-    return processingBus;
-  }
+  void processNode(int) override {}
 
   std::atomic<bool> destructible_;
 };
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h
index b15c69af2..30515dba4 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h
@@ -16,7 +16,7 @@ class AudioContext;
 class IOSAudioPlayer {
  public:
   IOSAudioPlayer(
-      const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
+      const std::function<void(DSPAudioBuffer *, int)> &renderAudio,
       float sampleRate,
       int channelCount);
   ~IOSAudioPlayer();
@@ -32,7 +32,7 @@ class IOSAudioPlayer {
  protected:
   std::shared_ptr<DSPAudioBuffer> audioBuffer_;
   NativeAudioPlayer *audioPlayer_;
-  std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> renderAudio_;
+  std::function<void(DSPAudioBuffer *, int)> renderAudio_;
   int channelCount_;
   std::atomic<bool> isRunning_;
 };
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
index 500d58f3a..84b80890e 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
@@ -10,7 +10,7 @@
 namespace audioapi {
 
 IOSAudioPlayer::IOSAudioPlayer(
-    const std::function<void(std::shared_ptr<DSPAudioBuffer>, int)> &renderAudio,
+    const std::function<void(DSPAudioBuffer *, int)> &renderAudio,
     float sampleRate,
     int channelCount)
     : renderAudio_(renderAudio), channelCount_(channelCount), audioBuffer_(0), isRunning_(false)
@@ -22,7 +22,7 @@
       int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
 
       if (isRunning_.load(std::memory_order_acquire)) {
-        renderAudio_(audioBuffer_, framesToProcess);
+        renderAudio_(audioBuffer_.get(), framesToProcess);
       } else {
         audioBuffer_->zero();
       }

From 98e76f2c13292e02a9e6cf8b8c69e6d2fb1f2154 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Wed, 25 Mar 2026 18:20:43 +0100
Subject: [PATCH 11/38] ci: yarn format

---
 .../common/cpp/audioapi/core/BaseAudioContext.cpp               | 2 +-
 .../common/cpp/audioapi/core/utils/graph/NodeHandle.hpp         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 7d848b81a..c56e36b14 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -1,7 +1,7 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/graph/DestinationGraphObject.hpp>
 #include <audioapi/core/utils/AudioDecoder.h>
+#include <audioapi/core/utils/graph/DestinationGraphObject.hpp>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.hpp>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
index 5c5fc1a1e..d2146a420 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
@@ -27,7 +27,7 @@ struct NodeHandle {
   std::uint32_t index;                    // current position in AudioGraph::nodes
 
   NodeHandle(std::uint32_t index, std::unique_ptr<GraphObject> audioNode)
-      : index(index), audioNode(std::move(audioNode)) {}
+      : audioNode(std::move(audioNode)), index(index) {}
 };
 
 } // namespace audioapi::utils::graph

From 08a5ee25ef218ab4dc418b22dea493c407bd08c4 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 09:38:36 +0100
Subject: [PATCH 12/38] refactor: added separate input and output buffers
 getters to satisfy StereoPannerNode constraints

---
 .../common/cpp/audioapi/core/AudioNode.cpp    |  6 ----
 .../common/cpp/audioapi/core/AudioNode.h      | 29 ++++++++++++-------
 .../cpp/audioapi/core/BaseAudioContext.cpp    |  2 +-
 .../audioapi/core/effects/ConvolverNode.cpp   |  2 ++
 .../core/effects/StereoPannerNode.cpp         | 15 ++++++++--
 .../audioapi/core/effects/StereoPannerNode.h  |  3 ++
 .../core/sources/AudioBufferSourceNode.cpp    |  4 ---
 .../core/sources/AudioBufferSourceNode.h      |  3 --
 .../cpp/test/src/core/effects/DelayTest.cpp   | 21 +++++---------
 .../cpp/test/src/core/effects/GainTest.cpp    | 17 ++++-------
 .../src/core/effects/StereoPannerTest.cpp     | 21 +++++---------
 .../src/core/effects/WaveShaperNodeTest.cpp   | 13 +++------
 .../src/core/sources/ConstantSourceTest.cpp   |  4 +--
 13 files changed, 64 insertions(+), 76 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
index b98b64194..6439faf71 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
@@ -22,12 +22,6 @@ AudioNode::AudioNode(
       RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 }
 
-AudioNode::~AudioNode() {
-  if (isInitialized_.load(std::memory_order_acquire)) {
-    cleanup();
-  }
-}
-
 bool AudioNode::canBeDestructed() const {
   return true;
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index e5ae80439..197988c25 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -11,9 +11,7 @@
 #include <cassert>
 #include <cstddef>
 #include <memory>
-#include <unordered_set>
 #include <utility>
-#include <vector>
 
 namespace audioapi {
 
@@ -24,18 +22,17 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   explicit AudioNode(
       const std::shared_ptr<BaseAudioContext> &context,
       const AudioNodeOptions &options = AudioNodeOptions());
-  virtual ~AudioNode();
 
   size_t getChannelCount() const;
 
   template <std::ranges::input_range R>
     requires std::same_as<std::ranges::range_reference_t<R>, const GraphObject &>
   void process(R &&inputs, int numFrames) {
-    audioBuffer_->zero();
+    getInputBuffer()->zero();
 
     for (const auto &input : inputs) {
       if (const AudioNode *audioNode = input.asAudioNode()) {
-        audioBuffer_->sum(*audioNode->audioBuffer_, channelInterpretation_);
+        getInputBuffer()->sum(*audioNode->getOutputBuffer(), channelInterpretation_);
       }
     }
 
@@ -54,7 +51,21 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
     return getContextSampleRate() / 2.0f;
   }
 
-  std::shared_ptr<DSPAudioBuffer> getAudioBuffer() const {
+  /// @brief Returns the input buffer for this node. By default, this is the same as the output buffer.
+  /// @note Audio Thread only.
+  /// @note For StereoPannerNode and PannerNode due to channel limitations -
+  /// https://webaudio.github.io/web-audio-api/#StereoPanner-channel-limitations
+  /// the input buffer is negotiate with inputs, but output buffer is always stereo.
+  std::shared_ptr<DSPAudioBuffer> getInputBuffer() const {
+    return audioBuffer_;
+  }
+
+  /// @brief Returns the output buffer for this node. By default, this is the same as the input buffer.
+  /// @note Audio Thread only.
+  /// @note For StereoPannerNode and PannerNode due to channel limitations -
+  /// https://webaudio.github.io/web-audio-api/#StereoPanner-channel-limitations
+  /// the input buffer is negotiate with inputs, but output buffer is always stereo.
+  virtual std::shared_ptr<DSPAudioBuffer> getOutputBuffer() const {
     return audioBuffer_;
   }
 
@@ -81,8 +92,7 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   }
 
  protected:
-  friend class AudioDestinationNode;
-  friend class ConvolverNode;
+  //  friend class ConvolverNode;
   friend class DelayNodeHostObject;
 
   std::weak_ptr<BaseAudioContext> context_;
@@ -97,14 +107,11 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
 
   std::atomic<bool> isInitialized_ = false;
 
-  std::size_t lastRenderedFrame_{SIZE_MAX};
-
   virtual void disable() {
     cleanup();
   };
 
   virtual void processNode(int) = 0;
-
   void cleanup();
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index c56e36b14..e575c5bf4 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -123,7 +123,7 @@ void BaseAudioContext::processGraph(DSPAudioBuffer *buffer, int numFrames) {
     if (audioNode != nullptr) {
       audioNode->process(inputs, numFrames);
       if (audioNode == destination_.get()) {
-        buffer->copy(*audioNode->getAudioBuffer(), 0, 0, numFrames);
+        buffer->copy(*audioNode->getOutputBuffer(), 0, 0, numFrames);
       }
     }
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index 0ddc4bd12..2deab7259 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -105,6 +105,7 @@ void ConvolverNode::processNode(int framesToProcess) {
       return;
     }
   }
+
   if (internalBufferIndex_ < framesToProcess) {
     performConvolution(audioBuffer_); // reads from audioBuffer_, result goes to intermediateBuffer_
     audioBuffer_->zero();
@@ -113,6 +114,7 @@ void ConvolverNode::processNode(int framesToProcess) {
     internalBuffer_->copy(*audioBuffer_, 0, internalBufferIndex_, RENDER_QUANTUM_SIZE);
     internalBufferIndex_ += RENDER_QUANTUM_SIZE;
   }
+
   audioBuffer_->zero();
   audioBuffer_->copy(*internalBuffer_, 0, 0, framesToProcess);
   int remainingFrames = internalBufferIndex_ - framesToProcess;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
index 9529b0ddc..4f5e5bc8d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
@@ -14,7 +14,12 @@ StereoPannerNode::StereoPannerNode(
     const std::shared_ptr<BaseAudioContext> &context,
     const StereoPannerOptions &options)
     : AudioNode(context, options),
-      panParam_(std::make_shared<AudioParam>(options.pan, -1.0f, 1.0f, context)) {
+      panParam_(std::make_shared<AudioParam>(options.pan, -1.0f, 1.0f, context)),
+      outputBuffer_(
+          std::make_shared<DSPAudioBuffer>(
+              RENDER_QUANTUM_SIZE,
+              channelCount_,
+              context->getSampleRate())) {
   isInitialized_.store(true, std::memory_order_release);
 }
 
@@ -22,6 +27,10 @@ std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
   return panParam_;
 }
 
+std::shared_ptr<DSPAudioBuffer> StereoPannerNode::getOutputBuffer() const {
+  return outputBuffer_;
+}
+
 void StereoPannerNode::processNode(int framesToProcess) {
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr)
@@ -31,8 +40,8 @@ void StereoPannerNode::processNode(int framesToProcess) {
 
   auto panParamValues = panParam_->processARateParam(framesToProcess, time)->getChannel(0)->span();
 
-  auto outputLeft = audioBuffer_->getChannelByType(AudioBuffer::ChannelLeft)->span();
-  auto outputRight = audioBuffer_->getChannelByType(AudioBuffer::ChannelRight)->span();
+  auto outputLeft = outputBuffer_->getChannelByType(AudioBuffer::ChannelLeft)->span();
+  auto outputRight = outputBuffer_->getChannelByType(AudioBuffer::ChannelRight)->span();
 
   // Input is mono
   if (audioBuffer_->getNumberOfChannels() == 1) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
index 95c6dd410..5dd328f24 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
@@ -19,11 +19,14 @@ class StereoPannerNode : public AudioNode {
 
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
 
+  std::shared_ptr<DSPAudioBuffer> getOutputBuffer() const override;
+
  protected:
   void processNode(int framesToProcess) override;
 
  private:
   const std::shared_ptr<AudioParam> panParam_;
+  const std::shared_ptr<DSPAudioBuffer> outputBuffer_;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index 422435474..1db142c09 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -95,10 +95,6 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
   vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
 }
 
-void AudioBufferSourceNode::disable() {
-  AudioScheduledSourceNode::disable();
-}
-
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
   onLoopEndedCallbackId_ = callbackId;
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h
index af8bd4812..00a3643c7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h
@@ -39,9 +39,6 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   /// @note Audio Thread only
   void start(double when, double offset, double duration = -1);
 
-  /// @note Audio Thread only
-  void disable() override;
-
   /// @note Audio Thread only
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
index bf16620fa..185264b17 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
@@ -33,13 +33,8 @@ class TestableDelayNode : public DelayNode {
     getDelayTimeParam()->setValue(value);
   }
 
-  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
-    size_t copyChannels = std::min(
-        static_cast<size_t>(input->getNumberOfChannels()),
-        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
-    for (size_t ch = 0; ch < copyChannels; ch++) {
-      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
-    }
+  void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
+    audioBuffer_ = input;
   }
 
   void processNode(int framesToProcess) override {
@@ -65,9 +60,9 @@ TEST_F(DelayTest, DelayWithZeroDelayOutputsInputSignal) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  delayNode.setInput(buffer);
+  delayNode.setInputBuffer(buffer);
   delayNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = delayNode.getAudioBuffer();
+  auto resultBuffer = delayNode.getOutputBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], static_cast<float>(i + 1));
   }
@@ -86,9 +81,9 @@ TEST_F(DelayTest, DelayAppliesTimeShiftCorrectly) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  delayNode.setInput(buffer);
+  delayNode.setInputBuffer(buffer);
   delayNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = delayNode.getAudioBuffer();
+  auto resultBuffer = delayNode.getOutputBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be zero due to delay
       EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 0.0f);
@@ -114,12 +109,12 @@ TEST_F(DelayTest, DelayHandlesTailCorrectly) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  delayNode.setInput(buffer);
+  delayNode.setInputBuffer(buffer);
   delayNode.processNode(FRAMES_TO_PROCESS);
   // Second call uses the result of the first call as input (same as old behavior
   // where the same buffer object was passed to both calls)
   delayNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = delayNode.getAudioBuffer();
+  auto resultBuffer = delayNode.getOutputBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be 2nd part of buffer
       EXPECT_FLOAT_EQ(
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
index 4e6b32ed8..0b9c3b04e 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
@@ -33,13 +33,8 @@ class TestableGainNode : public GainNode {
     getGainParam()->setValue(value);
   }
 
-  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
-    size_t copyChannels = std::min(
-        static_cast<size_t>(input->getNumberOfChannels()),
-        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
-    for (size_t ch = 0; ch < copyChannels; ch++) {
-      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
-    }
+  void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
+    audioBuffer_ = input;
   }
 
   void processNode(int framesToProcess) override {
@@ -63,9 +58,9 @@ TEST_F(GainTest, GainModulatesVolumeCorrectly) {
     (*buffer->getChannel(0))[i] = i + 1;
   }
 
-  gainNode.setInput(buffer);
+  gainNode.setInputBuffer(buffer);
   gainNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = gainNode.getAudioBuffer();
+  auto resultBuffer = gainNode.getOutputBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], (i + 1) * GAIN_VALUE);
   }
@@ -83,9 +78,9 @@ TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
     (*buffer->getChannel(1))[i] = -i - 1;
   }
 
-  gainNode.setInput(buffer);
+  gainNode.setInputBuffer(buffer);
   gainNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = gainNode.getAudioBuffer();
+  auto resultBuffer = gainNode.getOutputBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], (i + 1) * GAIN_VALUE);
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(1))[i], (-i - 1) * GAIN_VALUE);
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
index 60c58dbf7..7c108422e 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
@@ -33,13 +33,8 @@ class TestableStereoPannerNode : public StereoPannerNode {
     getPanParam()->setValue(value);
   }
 
-  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
-    size_t copyChannels = std::min(
-        static_cast<size_t>(input->getNumberOfChannels()),
-        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
-    for (size_t ch = 0; ch < copyChannels; ch++) {
-      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
-    }
+  void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
+    audioBuffer_ = input;
   }
 
   void processNode(int framesToProcess) override {
@@ -63,9 +58,9 @@ TEST_F(StereoPannerTest, PanModulatesInputMonoCorrectly) {
     (*buffer->getChannelByType(AudioBuffer::ChannelLeft))[i] = i + 1;
   }
 
-  panNode.setInput(buffer);
+  panNode.setInputBuffer(buffer);
   panNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = panNode.getAudioBuffer();
+  auto resultBuffer = panNode.getOutputBuffer();
   // x = (0.5 + 1) / 2 = 0.75
   // gainL = cos(x * (π / 2)) = cos(0.75 * (π / 2)) = 0.38268343236508984
   // gainR = sin(x * (π / 2)) = sin(0.75 * (π / 2)) = 0.9238795325112867
@@ -93,9 +88,9 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithNegativePan) {
     (*buffer->getChannelByType(AudioBuffer::ChannelRight))[i] = i + 1;
   }
 
-  panNode.setInput(buffer);
+  panNode.setInputBuffer(buffer);
   panNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = panNode.getAudioBuffer();
+  auto resultBuffer = panNode.getOutputBuffer();
   // x = -0.5 + 1 = 0.5
   // gainL = cos(x * (π / 2)) = cos(0.5 * (π / 2)) = 0.7071067811865476
   // gainR = sin(x * (π / 2)) = sin(0.5 * (π / 2)) = 0.7071067811865476
@@ -123,9 +118,9 @@ TEST_F(StereoPannerTest, PanModulatesInputStereoCorrectlyWithPositivePan) {
     (*buffer->getChannelByType(AudioBuffer::ChannelRight))[i] = i + 1;
   }
 
-  panNode.setInput(buffer);
+  panNode.setInputBuffer(buffer);
   panNode.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = panNode.getAudioBuffer();
+  auto resultBuffer = panNode.getOutputBuffer();
   // x = 0.75
   // gainL = cos(x * (π / 2)) = cos(0.75 * (π / 2)) = 0.38268343236508984
   // gainR = sin(x * (π / 2)) = sin(0.75 * (π / 2)) = 0.9238795325112867
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
index 3d3c79b73..7f5766065 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/WaveShaperNodeTest.cpp
@@ -35,13 +35,8 @@ class TestableWaveShaperNode : public WaveShaperNode {
     data[2] = 2.0f;
   }
 
-  void setInput(const std::shared_ptr<DSPAudioBuffer> &input) {
-    size_t copyChannels = std::min(
-        static_cast<size_t>(input->getNumberOfChannels()),
-        static_cast<size_t>(audioBuffer_->getNumberOfChannels()));
-    for (size_t ch = 0; ch < copyChannels; ch++) {
-      audioBuffer_->getChannel(ch)->copy(*input->getChannel(ch), 0, 0, input->getSize());
-    }
+  void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
+    audioBuffer_ = input;
   }
 
   void processNode(int framesToProcess) override {
@@ -72,9 +67,9 @@ TEST_F(WaveShaperNodeTest, NoneOverSamplingProcessesCorrectly) {
     (*buffer->getChannel(0))[i] = -1.0f + i * 0.5f;
   }
 
-  waveShaper->setInput(buffer);
+  waveShaper->setInputBuffer(buffer);
   waveShaper->processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = waveShaper->getAudioBuffer();
+  auto resultBuffer = waveShaper->getOutputBuffer();
   auto curveData = waveShaper->testCurve_->span();
   auto resultData = resultBuffer->getChannel(0)->span();
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
index e0f6ae037..532b19e9b 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
@@ -50,7 +50,7 @@ TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
   auto constantSource = TestableConstantSourceNode(context);
   constantSource.start(context->getCurrentTime());
   constantSource.processNode(FRAMES_TO_PROCESS);
-  auto resultBuffer = constantSource.getAudioBuffer();
+  auto resultBuffer = constantSource.getOutputBuffer();
 
   for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 1.0f);
@@ -58,7 +58,7 @@ TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
 
   constantSource.setOffsetParam(0.5f);
   constantSource.processNode(FRAMES_TO_PROCESS);
-  resultBuffer = constantSource.getAudioBuffer();
+  resultBuffer = constantSource.getOutputBuffer();
   for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
     EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i], 0.5f);
   }

From 3265b234443cc3e58451b674395ab417d054e913 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 10:26:38 +0100
Subject: [PATCH 13/38] refactor: destination ownership and connection logic

---
 .../HostObjects/AudioNodeHostObject.cpp       |  1 +
 .../AudioDestinationNodeHostObject.cpp        | 51 +++++++++++++++----
 .../AudioDestinationNodeHostObject.h          | 23 ++++++++-
 .../src/core/AudioNode.ts                     | 14 ++++-
 4 files changed, 76 insertions(+), 13 deletions(-)

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
index d348f2e06..43a7dfb0f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -81,6 +81,7 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
     // node_->disconnect();
     return jsi::Value::undefined();
   }
+
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
index ef0b0bf8b..2cabc5962 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
@@ -1,4 +1,5 @@
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 
 #include <memory>
 #include <utility>
@@ -7,24 +8,56 @@ namespace audioapi {
 
 AudioDestinationNodeHostObject::AudioDestinationNodeHostObject(
     utils::graph::HostGraph::Node *node,
-    std::shared_ptr<AudioDestinationNode> destination)
-    : node_(node), destination_(std::move(destination)) {
-  addGetters(
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount));
+    std::shared_ptr<AudioDestinationNode> destination,
+    const AudioDestinationOptions &options)
+    : node_(node), destination_(std::move(destination)),
+      numberOfInputs_(options.numberOfInputs),
+      numberOfOutputs_(options.numberOfOutputs),
+      channelCount_(options.channelCount),
+      channelCountMode_(options.channelCountMode),
+      channelInterpretation_(options.channelInterpretation) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCountMode),
+        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelInterpretation));
+
+    addFunctions(
+        JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, connect),
+        JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, disconnect));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfInputs) {
-  return {1};
+  return {numberOfInputs_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfOutputs) {
-  return {0};
+  return {numberOfOutputs_};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCount) {
-  return {static_cast<int>(destination_->getChannelCount())};
+    return {static_cast<int>(channelCount_)};
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCountMode) {
+    return jsi::String::createFromUtf8(
+            runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelInterpretation) {
+    return jsi::String::createFromUtf8(
+            runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
+}
+
+/// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op
+JSI_HOST_FUNCTION_IMPL(AudioDestinationNodeHostObject, connect) {
+  return jsi::Value::undefined();
+}
+
+/// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op
+JSI_HOST_FUNCTION_IMPL(AudioDestinationNodeHostObject, disconnect) {
+  return jsi::Value::undefined();
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
index 72cb548a1..a7057993b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
@@ -3,17 +3,22 @@
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/types/NodeOptions.h>
 
 #include <memory>
 
 namespace audioapi {
 using namespace facebook;
 
+/// HostObject for AudiodestinationNode, which is the end point of the audio graph.
+/// It is treated differently than other AudioNodes, because it shares ownership of underlying AudioDestinationNode with BaseAudioContext.
+/// Hence all AudioNodeHostObject methods and proprties has to be implemented duplicated.
 class AudioDestinationNodeHostObject : public JsiHostObject {
  public:
   explicit AudioDestinationNodeHostObject(
       utils::graph::HostGraph::Node *node,
-      std::shared_ptr<AudioDestinationNode> destination);
+      std::shared_ptr<AudioDestinationNode> destination,
+      const AudioDestinationOptions &options = AudioDestinationOptions());
 
   [[nodiscard]] utils::graph::HostGraph::Node *rawNode() const {
     return node_;
@@ -22,10 +27,24 @@ class AudioDestinationNodeHostObject : public JsiHostObject {
   JSI_PROPERTY_GETTER_DECL(numberOfInputs);
   JSI_PROPERTY_GETTER_DECL(numberOfOutputs);
   JSI_PROPERTY_GETTER_DECL(channelCount);
+  JSI_PROPERTY_GETTER_DECL(channelCountMode);
+  JSI_PROPERTY_GETTER_DECL(channelInterpretation);
+
+  JSI_HOST_FUNCTION_DECL(connect);
+  JSI_HOST_FUNCTION_DECL(disconnect);
 
  private:
-  utils::graph::HostGraph::Node *node_; // borrowed from BaseAudioContext; never removed
+  // borrowed from BaseAudioContext's graph - non-owning
+  // no risk of dangling pointer here since destination node in TS holds ref to context =>
+  // destination HO will not outlive context HO => graph is owned by context HO
+  utils::graph::HostGraph::Node *node_; // borrowed from BaseAudioContext's graph - non-owning
   std::shared_ptr<AudioDestinationNode> destination_;
+
+  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/src/core/AudioNode.ts b/packages/react-native-audio-api/src/core/AudioNode.ts
index 7990f4ce3..2733e4673 100644
--- a/packages/react-native-audio-api/src/core/AudioNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioNode.ts
@@ -2,7 +2,7 @@ import { IAudioNode } from '../interfaces';
 import AudioParam from './AudioParam';
 import { ChannelCountMode, ChannelInterpretation } from '../types';
 import BaseAudioContext from './BaseAudioContext';
-import { InvalidAccessError } from '../errors';
+import { IndexSizeError } from '../errors';
 
 export default class AudioNode {
   readonly context: BaseAudioContext;
@@ -27,14 +27,24 @@ export default class AudioNode {
   public connect(destination: AudioParam): void;
   public connect(destination: AudioNode | AudioParam): AudioNode | void {
     if (this.context !== destination.context) {
-      throw new InvalidAccessError(
+      throw new IndexSizeError(
         'Source and destination are from different BaseAudioContexts'
       );
     }
 
+    if (this.numberOfOutputs === 0) {
+      throw new IndexSizeError('Faild to connect: AudioNode has no output');
+    }
+
     if (destination instanceof AudioParam) {
       this.node.connect(destination.audioParam);
     } else {
+      if (destination.numberOfInputs === 0) {
+        throw new IndexSizeError(
+          'Failed to connect: destination AudioNode has no input'
+        );
+      }
+
       this.node.connect(destination.node);
       return destination;
     }

From f151efa610abf90fa29dcecb0c187d585641bc9b Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 10:27:08 +0100
Subject: [PATCH 14/38] ci: yarn format

---
 .../AudioDestinationNodeHostObject.cpp        | 31 ++++++++++---------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
index 2cabc5962..50f383911 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
@@ -10,22 +10,23 @@ AudioDestinationNodeHostObject::AudioDestinationNodeHostObject(
     utils::graph::HostGraph::Node *node,
     std::shared_ptr<AudioDestinationNode> destination,
     const AudioDestinationOptions &options)
-    : node_(node), destination_(std::move(destination)),
+    : node_(node),
+      destination_(std::move(destination)),
       numberOfInputs_(options.numberOfInputs),
       numberOfOutputs_(options.numberOfOutputs),
       channelCount_(options.channelCount),
       channelCountMode_(options.channelCountMode),
       channelInterpretation_(options.channelInterpretation) {
-    addGetters(
-        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
-        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
-        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount),
-        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCountMode),
-        JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelInterpretation));
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount),
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCountMode),
+      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelInterpretation));
 
-    addFunctions(
-        JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, connect),
-        JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, disconnect));
+  addFunctions(
+      JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, connect),
+      JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, disconnect));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfInputs) {
@@ -37,17 +38,17 @@ JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfOutputs) {
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCount) {
-    return {static_cast<int>(channelCount_)};
+  return {static_cast<int>(channelCount_)};
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCountMode) {
-    return jsi::String::createFromUtf8(
-            runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
+  return jsi::String::createFromUtf8(
+      runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelInterpretation) {
-    return jsi::String::createFromUtf8(
-            runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
+  return jsi::String::createFromUtf8(
+      runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
 }
 
 /// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op

From bc8c6285c5b1af0583dd07b98d4e8a93f7151f1a Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 10:54:44 +0100
Subject: [PATCH 15/38] refactor: disconnect all outputs from a node

---
 .../HostObjects/AudioNodeHostObject.cpp       |  7 ++---
 .../HostObjects/AudioNodeHostObject.h         |  3 ++
 .../cpp/audioapi/core/utils/graph/Graph.hpp   |  9 ++++++
 .../audioapi/core/utils/graph/HostGraph.hpp   | 30 +++++++++++++++++++
 .../audioapi/core/utils/graph/HostNode.hpp    | 10 +++++--
 5 files changed, 53 insertions(+), 6 deletions(-)

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
index 43a7dfb0f..18eed7295 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -63,7 +63,7 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    connectNode(*node);
+    connect(*node);
   } else if (obj.isHostObject<AudioDestinationNodeHostObject>(runtime)) {
     auto dest = obj.getHostObject<AudioDestinationNodeHostObject>(runtime);
     graph_->addEdge(node_, dest->rawNode());
@@ -77,15 +77,14 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
   if (args[0].isUndefined()) {
-    // TODO
-    // node_->disconnect();
+    disconnect();
     return jsi::Value::undefined();
   }
 
   auto obj = args[0].getObject(runtime);
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
-    disconnectNode(*node);
+    disconnect(*node);
   } else if (obj.isHostObject<AudioDestinationNodeHostObject>(runtime)) {
     auto dest = obj.getHostObject<AudioDestinationNodeHostObject>(runtime);
     graph_->removeEdge(node_, dest->rawNode());
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
index b1841021a..60118a384 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
@@ -29,6 +29,9 @@ class AudioNodeHostObject : public JsiHostObject, public utils::graph::HostNode
   JSI_PROPERTY_GETTER_DECL(channelCountMode);
   JSI_PROPERTY_GETTER_DECL(channelInterpretation);
 
+  using utils::graph::HostNode::connect;
+  using utils::graph::HostNode::disconnect;
+
   JSI_HOST_FUNCTION_DECL(connect);
   JSI_HOST_FUNCTION_DECL(disconnect);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 2f945d6c0..cd7bf1893 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -173,6 +173,15 @@ class Graph {
     });
   }
 
+  /// @brief Removes all outgoing edges from `from`.
+  Res removeAllEdges(HNode *from) {
+    hostGraph.collectDisposedNodes();
+    return hostGraph.removeAllEdges(from).map([&](AGEvent event) {
+      eventSender_.send(std::move(event));
+      return NoneType{};
+    });
+  }
+
   // ── Param bridge API ───────────────────────────────────────────────────
 
   /// @brief Creates a bridge node representing: source → bridge → owner.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
index 2f4ec6c2a..0a3fcdfce 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
@@ -103,6 +103,10 @@ class HostGraph {
   /// @return AGEvent that removes the input on the AudioGraph side.
   Res removeEdge(Node *from, Node *to);
 
+  /// @brief Removes all outgoing edges from `from`.
+  /// @return single AGEvent that removes all inputs on the AudioGraph side, or NODE_NOT_FOUND.
+  Res removeAllEdges(Node *from);
+
   /// @brief Current number of live (non-ghost) edges.
   [[nodiscard]] size_t edgeCount() const;
 
@@ -258,6 +262,32 @@ inline auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
   });
 }
 
+inline auto HostGraph::removeAllEdges(Node *from) -> Res {
+  if (std::find(nodes.begin(), nodes.end(), from) == nodes.end() || from->ghost) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+
+  auto pairs = std::make_shared<std::vector<std::pair<std::uint32_t, std::uint32_t>>>();
+  pairs->reserve(from->outputs.size());
+
+  for (Node *to : from->outputs) {
+    auto itIn = std::find(to->inputs.begin(), to->inputs.end(), from);
+    if (itIn != to->inputs.end()) {
+      to->inputs.erase(itIn);
+    }
+    edgeCount_--;
+    pairs->emplace_back(from->handle->index, to->handle->index);
+  }
+  from->outputs.clear();
+
+  return Res::Ok([pairs = std::move(pairs)](AudioGraph &graph, auto &) {
+    for (auto &[fromIdx, toIdx] : *pairs) {
+      graph.pool().remove(graph[toIdx].input_head, fromIdx);
+    }
+    graph.markDirty();
+  });
+}
+
 inline bool HostGraph::hasPath(Node *start, Node *end) {
   if (start == end) {
     return true;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
index 2c29d2a8f..e778e0b88 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
@@ -93,13 +93,13 @@ class HostNode {
 
   /// @brief Connects this node's output to another node's input (this → other).
   /// @return Ok on success, Err on cycle / duplicate / not-found
-  Res connectNode(HostNode &other) {
+  Res connect(HostNode &other) {
     return graph_->addEdge(node_, other.node_);
   }
 
   /// @brief Disconnects this node's output from another node's input.
   /// @return Ok on success, Err on not-found
-  Res disconnectNode(HostNode &other) {
+  Res disconnect(HostNode &other) {
     return graph_->removeEdge(node_, other.node_);
   }
 
@@ -115,6 +115,12 @@ class HostNode {
     return graph_->disconnectParam(node_, owner.node_, param);
   }
 
+  /// @brief Disconnects all this node's outputs.
+  /// @return Ok on success, Err on not-found
+  Res disconnect() {
+    return graph_->removeAllEdges(node_);
+  }
+
   /// @brief Returns the raw HostGraph::Node pointer (for advanced usage / testing).
   [[nodiscard]] HNode *rawNode() const {
     return node_;

From ebffe07f2937df3e21708f79e50a1009b1ec906b Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 15:19:31 +0100
Subject: [PATCH 16/38] refactor: destination node initialization and ownership

---
 .../BaseAudioContextHostObject.cpp            |  3 +-
 .../AudioDestinationNodeHostObject.cpp        | 64 -------------------
 .../AudioDestinationNodeHostObject.h          | 44 +++----------
 .../common/cpp/audioapi/core/AudioContext.cpp |  5 +-
 .../common/cpp/audioapi/core/AudioContext.h   |  7 +-
 .../cpp/audioapi/core/BaseAudioContext.cpp    | 13 +---
 .../cpp/audioapi/core/BaseAudioContext.h      | 10 +--
 .../utils/graph/DestinationGraphObject.hpp    | 29 ---------
 .../cpp/test/src/core/effects/DelayTest.cpp   |  5 +-
 .../cpp/test/src/core/effects/GainTest.cpp    |  5 +-
 .../src/core/effects/StereoPannerTest.cpp     |  5 +-
 .../core/sources/AudioScheduledSourceTest.cpp |  7 +-
 .../src/core/sources/ConstantSourceTest.cpp   |  5 +-
 .../cpp/test/src/graph/TestGraphUtils.h       |  2 +-
 14 files changed, 47 insertions(+), 157 deletions(-)
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index b9cee3e10..c8604a784 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -35,9 +35,8 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
     : context_(context),
       promiseVendor_(std::make_shared<PromiseVendor>(runtime, callInvoker)),
       callInvoker_(callInvoker) {
-  auto *destinationNode = context_->initialize();
   destination_ =
-      std::make_shared<AudioDestinationNodeHostObject>(destinationNode, context_->getDestination());
+      std::make_shared<AudioDestinationNodeHostObject>(context_);
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
deleted file mode 100644
index 50f383911..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
-#include <audioapi/HostObjects/utils/JsEnumParser.h>
-
-#include <memory>
-#include <utility>
-
-namespace audioapi {
-
-AudioDestinationNodeHostObject::AudioDestinationNodeHostObject(
-    utils::graph::HostGraph::Node *node,
-    std::shared_ptr<AudioDestinationNode> destination,
-    const AudioDestinationOptions &options)
-    : node_(node),
-      destination_(std::move(destination)),
-      numberOfInputs_(options.numberOfInputs),
-      numberOfOutputs_(options.numberOfOutputs),
-      channelCount_(options.channelCount),
-      channelCountMode_(options.channelCountMode),
-      channelInterpretation_(options.channelInterpretation) {
-  addGetters(
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfInputs),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, numberOfOutputs),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCount),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelCountMode),
-      JSI_EXPORT_PROPERTY_GETTER(AudioDestinationNodeHostObject, channelInterpretation));
-
-  addFunctions(
-      JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, connect),
-      JSI_EXPORT_FUNCTION(AudioDestinationNodeHostObject, disconnect));
-}
-
-JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfInputs) {
-  return {numberOfInputs_};
-}
-
-JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, numberOfOutputs) {
-  return {numberOfOutputs_};
-}
-
-JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCount) {
-  return {static_cast<int>(channelCount_)};
-}
-
-JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelCountMode) {
-  return jsi::String::createFromUtf8(
-      runtime, js_enum_parser::channelCountModeToString(channelCountMode_));
-}
-
-JSI_PROPERTY_GETTER_IMPL(AudioDestinationNodeHostObject, channelInterpretation) {
-  return jsi::String::createFromUtf8(
-      runtime, js_enum_parser::channelInterpretationToString(channelInterpretation_));
-}
-
-/// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op
-JSI_HOST_FUNCTION_IMPL(AudioDestinationNodeHostObject, connect) {
-  return jsi::Value::undefined();
-}
-
-/// AudioDestinationNode is the end point of the audio graph, it cannot connect to any other node, so connect and disconnect are no-op
-JSI_HOST_FUNCTION_IMPL(AudioDestinationNodeHostObject, disconnect) {
-  return jsi::Value::undefined();
-}
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
index a7057993b..17f9b8322 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
@@ -1,8 +1,7 @@
 #pragma once
 
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/graph/HostGraph.hpp>
-#include <audioapi/jsi/JsiHostObject.h>
 #include <audioapi/types/NodeOptions.h>
 
 #include <memory>
@@ -10,41 +9,16 @@
 namespace audioapi {
 using namespace facebook;
 
-/// HostObject for AudiodestinationNode, which is the end point of the audio graph.
-/// It is treated differently than other AudioNodes, because it shares ownership of underlying AudioDestinationNode with BaseAudioContext.
-/// Hence all AudioNodeHostObject methods and proprties has to be implemented duplicated.
-class AudioDestinationNodeHostObject : public JsiHostObject {
+class AudioDestinationNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AudioDestinationNodeHostObject(
-      utils::graph::HostGraph::Node *node,
-      std::shared_ptr<AudioDestinationNode> destination,
-      const AudioDestinationOptions &options = AudioDestinationOptions());
-
-  [[nodiscard]] utils::graph::HostGraph::Node *rawNode() const {
-    return node_;
-  }
-
-  JSI_PROPERTY_GETTER_DECL(numberOfInputs);
-  JSI_PROPERTY_GETTER_DECL(numberOfOutputs);
-  JSI_PROPERTY_GETTER_DECL(channelCount);
-  JSI_PROPERTY_GETTER_DECL(channelCountMode);
-  JSI_PROPERTY_GETTER_DECL(channelInterpretation);
-
-  JSI_HOST_FUNCTION_DECL(connect);
-  JSI_HOST_FUNCTION_DECL(disconnect);
-
- private:
-  // borrowed from BaseAudioContext's graph - non-owning
-  // no risk of dangling pointer here since destination node in TS holds ref to context =>
-  // destination HO will not outlive context HO => graph is owned by context HO
-  utils::graph::HostGraph::Node *node_; // borrowed from BaseAudioContext's graph - non-owning
-  std::shared_ptr<AudioDestinationNode> destination_;
-
-  const int numberOfInputs_;
-  const int numberOfOutputs_;
-  size_t channelCount_;
-  const ChannelCountMode channelCountMode_;
-  const ChannelInterpretation channelInterpretation_;
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioDestinationOptions &options = AudioDestinationOptions())
+      : AudioNodeHostObject(context->getGraph(),
+                            std::make_unique<AudioDestinationNode>(context),
+                            options) {
+        context->initialize(static_cast<AudioDestinationNode*>(node_->handle->audioNode.get()));
+      }
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
index 3cde417fc..4c20dc556 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
@@ -22,8 +22,8 @@ AudioContext::~AudioContext() {
   }
 }
 
-utils::graph::HostGraph::Node *AudioContext::initialize() {
-  auto *destinationNode = BaseAudioContext::initialize();
+void AudioContext::initialize(const AudioDestinationNode *destination) {
+  BaseAudioContext::initialize(destination);
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(
       [this](DSPAudioBuffer *buf, int n) { processGraph(buf, n); },
@@ -35,7 +35,6 @@ utils::graph::HostGraph::Node *AudioContext::initialize() {
       getSampleRate(),
       destination_->getChannelCount());
 #endif
-  return destinationNode;
 }
 
 void AudioContext::close() {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h
index a5bd05034..994f355ee 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.h
@@ -4,7 +4,6 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
-#include <functional>
 #include <memory>
 
 namespace audioapi {
@@ -26,7 +25,11 @@ class AudioContext : public BaseAudioContext {
   bool resume();
   bool suspend();
   bool start();
-  utils::graph::HostGraph::Node *initialize() override;
+
+  /// @brief Initializes native audio player and assigns the audio destination node to the context.
+  /// @param destination The audio destination node to be associated with the context.
+  /// @note This method must be called before the audio context can be used for processing audio.
+  void initialize(const AudioDestinationNode *destination) final;
 
  private:
 #ifdef ANDROID
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index e575c5bf4..dee452c3a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -1,13 +1,11 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/AudioDecoder.h>
-#include <audioapi/core/utils/graph/DestinationGraphObject.hpp>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.hpp>
 #include <audioapi/utils/CircularArray.hpp>
 #include <memory>
-#include <utility>
 #include <vector>
 
 namespace audioapi {
@@ -26,9 +24,8 @@ BaseAudioContext::BaseAudioContext(
               AUDIO_SCHEDULER_CAPACITY)),
       graph_(std::make_shared<utils::graph::Graph>(AUDIO_SCHEDULER_CAPACITY, disposer_.get())) {}
 
-utils::graph::HostGraph::Node *BaseAudioContext::initialize() {
-  destination_ = std::make_shared<AudioDestinationNode>(shared_from_this());
-  return graph_->addNode(std::make_unique<DestinationGraphObject>(destination_.get()));
+void BaseAudioContext::initialize(const AudioDestinationNode *destination) {
+  destination_ = destination;
 }
 
 ContextState BaseAudioContext::getState() {
@@ -53,10 +50,6 @@ double BaseAudioContext::getCurrentTime() const {
   return static_cast<double>(getCurrentSampleFrame()) / getSampleRate();
 }
 
-std::shared_ptr<AudioDestinationNode> BaseAudioContext::getDestination() const {
-  return destination_;
-}
-
 void BaseAudioContext::setState(audioapi::ContextState state) {
   state_.store(state, std::memory_order_release);
 }
@@ -122,7 +115,7 @@ void BaseAudioContext::processGraph(DSPAudioBuffer *buffer, int numFrames) {
     auto audioNode = node.asAudioNode();
     if (audioNode != nullptr) {
       audioNode->process(inputs, numFrames);
-      if (audioNode == destination_.get()) {
+      if (audioNode == destination_) {
         buffer->copy(*audioNode->getOutputBuffer(), 0, 0, numFrames);
       }
     }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index f3b31c098..6276fc1cd 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -36,7 +36,6 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   [[nodiscard]] float getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
-  std::shared_ptr<AudioDestinationNode> getDestination() const;
 
   void setState(ContextState state);
 
@@ -51,9 +50,10 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   const RuntimeRegistry &getRuntimeRegistry() const;
   utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *getDisposer() const;
 
-  /// @brief Initializes audio destination and its corresponding graph node and adds it to graph. Must be called before using the context.
-  /// @return The graph node corresponding to the audio destination.
-  virtual utils::graph::HostGraph::Node *initialize();
+  /// @brief Assigns the audio destination node to the context.
+  /// @param destination The audio destination node to be associated with the context.
+  /// @note This method must be called before the audio context can be used for processing audio.
+  virtual void initialize(const AudioDestinationNode *destination);
 
   void inline processAudioEvents() {
     audioEventScheduler_.processAllEvents(*this);
@@ -74,7 +74,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
 
  protected:
   std::atomic<std::size_t> currentSampleFrame_{0};
-  std::shared_ptr<AudioDestinationNode> destination_;
+  const AudioDestinationNode *destination_;
 
  private:
   std::atomic<ContextState> state_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp
deleted file mode 100644
index 26a717f3d..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/DestinationGraphObject.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/graph/GraphObject.hpp>
-
-namespace audioapi {
-
-class DestinationGraphObject final : public utils::graph::GraphObject {
- public:
-  explicit DestinationGraphObject(AudioDestinationNode *destination) : destination_(destination) {}
-
-  AudioNode *asAudioNode() override {
-    return destination_;
-  }
-
-  const AudioNode *asAudioNode() const override {
-    return destination_;
-  }
-
-  // Context never removes the destination from the graph.
-  bool canBeDestructed() const override {
-    return false;
-  }
-
- private:
-  AudioDestinationNode *destination_; // non-owning; lifetime guaranteed by BaseAudioContext
-};
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
index 185264b17..535a368f4 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
@@ -1,4 +1,5 @@
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/DelayNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/types/NodeOptions.h>
@@ -14,13 +15,15 @@ class DelayTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
-    context->initialize();
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
   }
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
index 0b9c3b04e..68a1a38a3 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/GainTest.cpp
@@ -1,4 +1,5 @@
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/types/NodeOptions.h>
@@ -14,13 +15,15 @@ class GainTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
-    context->initialize();
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
   }
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
index 7c108422e..01c50a065 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/StereoPannerTest.cpp
@@ -1,4 +1,5 @@
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/types/NodeOptions.h>
@@ -14,13 +15,15 @@ class StereoPannerTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
-    context->initialize();
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
   }
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
index 9ad9a6be1..804529b38 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
@@ -16,12 +16,15 @@ class AudioScheduledSourceTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
+  static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_shared<OfflineAudioContext>(
-        2, 5 * SAMPLE_RATE, SAMPLE_RATE, eventRegistry, RuntimeRegistry{});
-    context->initialize();
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
   }
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
index 532b19e9b..bc733ca9b 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/ConstantSourceTest.cpp
@@ -1,4 +1,5 @@
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/types/NodeOptions.h>
@@ -14,13 +15,15 @@ class ConstantSourceTest : public ::testing::Test {
  protected:
   std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
   std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     context = std::make_shared<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
-    context->initialize();
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
   }
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
index 3d801db7a..5adc29544 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
@@ -7,6 +7,7 @@
 
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
 #include <audioapi/core/utils/graph/BridgeNode.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
@@ -30,7 +31,6 @@ inline std::shared_ptr<BaseAudioContext> getGraphTestContext() {
     auto eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
     auto ctx =
         std::make_shared<OfflineAudioContext>(2, 1024, 44100.0f, eventRegistry, RuntimeRegistry{});
-    ctx->initialize();
     return ctx;
   }();
   return context;

From bd4637c7c6937eb84d135e14e73fdc9481545b79 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 15:23:13 +0100
Subject: [PATCH 17/38] ci: yarn format

---
 .../cpp/audioapi/HostObjects/AudioNodeHostObject.cpp  |  6 ------
 .../HostObjects/BaseAudioContextHostObject.cpp        |  3 +--
 .../destinations/AudioDestinationNodeHostObject.h     | 11 ++++++-----
 3 files changed, 7 insertions(+), 13 deletions(-)

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
index 18eed7295..7d6bdbb03 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -64,9 +64,6 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
     connect(*node);
-  } else if (obj.isHostObject<AudioDestinationNodeHostObject>(runtime)) {
-    auto dest = obj.getHostObject<AudioDestinationNodeHostObject>(runtime);
-    graph_->addEdge(node_, dest->rawNode());
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
     // TODO
@@ -85,9 +82,6 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
     disconnect(*node);
-  } else if (obj.isHostObject<AudioDestinationNodeHostObject>(runtime)) {
-    auto dest = obj.getHostObject<AudioDestinationNodeHostObject>(runtime);
-    graph_->removeEdge(node_, dest->rawNode());
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
     // TODO
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index c8604a784..d602f991a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -35,8 +35,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
     : context_(context),
       promiseVendor_(std::make_shared<PromiseVendor>(runtime, callInvoker)),
       callInvoker_(callInvoker) {
-  destination_ =
-      std::make_shared<AudioDestinationNodeHostObject>(context_);
+  destination_ = std::make_shared<AudioDestinationNodeHostObject>(context_);
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
index 17f9b8322..e89cb1082 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h
@@ -14,11 +14,12 @@ class AudioDestinationNodeHostObject : public AudioNodeHostObject {
   explicit AudioDestinationNodeHostObject(
       const std::shared_ptr<BaseAudioContext> &context,
       const AudioDestinationOptions &options = AudioDestinationOptions())
-      : AudioNodeHostObject(context->getGraph(),
-                            std::make_unique<AudioDestinationNode>(context),
-                            options) {
-        context->initialize(static_cast<AudioDestinationNode*>(node_->handle->audioNode.get()));
-      }
+      : AudioNodeHostObject(
+            context->getGraph(),
+            std::make_unique<AudioDestinationNode>(context),
+            options) {
+    context->initialize(static_cast<AudioDestinationNode *>(node_->handle->audioNode.get()));
+  }
 };
 
 } // namespace audioapi

From c9cfa782d2d9809e293ed2cea772d945981f3d7f Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 16:04:45 +0100
Subject: [PATCH 18/38] refactor: added param owner node

---
 .../cpp/audioapi/HostObjects/AudioNodeHostObject.cpp |  8 ++++----
 .../src/core/AudioBufferBaseSourceNode.ts            |  4 ++--
 .../react-native-audio-api/src/core/AudioNode.ts     |  8 +++++---
 .../react-native-audio-api/src/core/AudioParam.ts    | 12 ++++++++++--
 .../src/core/BiquadFilterNode.ts                     |  8 ++++----
 .../src/core/ConstantSourceNode.ts                   |  2 +-
 .../react-native-audio-api/src/core/DelayNode.ts     |  2 +-
 packages/react-native-audio-api/src/core/GainNode.ts |  2 +-
 .../src/core/OscillatorNode.ts                       |  4 ++--
 .../src/core/StereoPannerNode.ts                     |  2 +-
 packages/react-native-audio-api/src/interfaces.ts    |  7 +++++--
 .../src/web-core/AudioParam.tsx                      |  3 +--
 12 files changed, 37 insertions(+), 25 deletions(-)

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
index 7d6bdbb03..ab1b8b5aa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -66,8 +66,8 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
     connect(*node);
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    // TODO
-    // connectParam(*param->owner_, param->param_.get());
+    auto owner = args[1].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
+    connectParam(*owner, param->param_.get());
   }
   return jsi::Value::undefined();
 }
@@ -84,8 +84,8 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
     disconnect(*node);
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    // TODO
-    // disconnectParam(*param->owner_, param->param_.get());
+    auto owner = args[1].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
+    disconnectParam(*owner, param->param_.get());
   }
 
   return jsi::Value::undefined();
diff --git a/packages/react-native-audio-api/src/core/AudioBufferBaseSourceNode.ts b/packages/react-native-audio-api/src/core/AudioBufferBaseSourceNode.ts
index aacf1c71c..c30f4bd4c 100644
--- a/packages/react-native-audio-api/src/core/AudioBufferBaseSourceNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioBufferBaseSourceNode.ts
@@ -14,8 +14,8 @@ export default class AudioBufferBaseSourceNode extends AudioScheduledSourceNode
   constructor(context: BaseAudioContext, node: IAudioBufferBaseSourceNode) {
     super(context, node);
 
-    this.detune = new AudioParam(node.detune, context);
-    this.playbackRate = new AudioParam(node.playbackRate, context);
+    this.detune = new AudioParam(node.detune, context, this);
+    this.playbackRate = new AudioParam(node.playbackRate, context, this);
   }
 
   public get onPositionChanged():
diff --git a/packages/react-native-audio-api/src/core/AudioNode.ts b/packages/react-native-audio-api/src/core/AudioNode.ts
index 2733e4673..164ecf20c 100644
--- a/packages/react-native-audio-api/src/core/AudioNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioNode.ts
@@ -37,7 +37,7 @@ export default class AudioNode {
     }
 
     if (destination instanceof AudioParam) {
-      this.node.connect(destination.audioParam);
+      this.node.connect(destination.audioParam, destination.owner.node);
     } else {
       if (destination.numberOfInputs === 0) {
         throw new IndexSizeError(
@@ -52,9 +52,11 @@ export default class AudioNode {
 
   public disconnect(destination?: AudioNode | AudioParam): void {
     if (destination instanceof AudioParam) {
-      this.node.disconnect(destination.audioParam);
+      this.node.disconnect(destination.audioParam, destination.owner.node);
+    } else if (destination) {
+      this.node.disconnect(destination.node);
     } else {
-      this.node.disconnect(destination?.node);
+      this.node.disconnect();
     }
   }
 }
diff --git a/packages/react-native-audio-api/src/core/AudioParam.ts b/packages/react-native-audio-api/src/core/AudioParam.ts
index e74f192d1..04176bd33 100644
--- a/packages/react-native-audio-api/src/core/AudioParam.ts
+++ b/packages/react-native-audio-api/src/core/AudioParam.ts
@@ -1,6 +1,7 @@
 import { IAudioParam } from '../interfaces';
 import { RangeError, InvalidStateError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
 
 export default class AudioParam {
   readonly defaultValue: number;
@@ -8,14 +9,21 @@ export default class AudioParam {
   readonly maxValue: number;
   readonly audioParam: IAudioParam;
   readonly context: BaseAudioContext;
-
-  constructor(audioParam: IAudioParam, context: BaseAudioContext) {
+  /** @internal */
+  public readonly owner: AudioNode;
+
+  constructor(
+    audioParam: IAudioParam,
+    context: BaseAudioContext,
+    owner: AudioNode
+  ) {
     this.audioParam = audioParam;
     this.value = audioParam.value;
     this.defaultValue = audioParam.defaultValue;
     this.minValue = audioParam.minValue;
     this.maxValue = audioParam.maxValue;
     this.context = context;
+    this.owner = owner;
   }
 
   public get value(): number {
diff --git a/packages/react-native-audio-api/src/core/BiquadFilterNode.ts b/packages/react-native-audio-api/src/core/BiquadFilterNode.ts
index dbad4da44..bf75c71fc 100644
--- a/packages/react-native-audio-api/src/core/BiquadFilterNode.ts
+++ b/packages/react-native-audio-api/src/core/BiquadFilterNode.ts
@@ -16,10 +16,10 @@ export default class BiquadFilterNode extends AudioNode {
       options || {}
     );
     super(context, biquadFilter);
-    this.frequency = new AudioParam(biquadFilter.frequency, context);
-    this.detune = new AudioParam(biquadFilter.detune, context);
-    this.Q = new AudioParam(biquadFilter.Q, context);
-    this.gain = new AudioParam(biquadFilter.gain, context);
+    this.frequency = new AudioParam(biquadFilter.frequency, context, this);
+    this.detune = new AudioParam(biquadFilter.detune, context, this);
+    this.Q = new AudioParam(biquadFilter.Q, context, this);
+    this.gain = new AudioParam(biquadFilter.gain, context, this);
   }
 
   public get type(): BiquadFilterType {
diff --git a/packages/react-native-audio-api/src/core/ConstantSourceNode.ts b/packages/react-native-audio-api/src/core/ConstantSourceNode.ts
index 3a92a27af..69baa0643 100644
--- a/packages/react-native-audio-api/src/core/ConstantSourceNode.ts
+++ b/packages/react-native-audio-api/src/core/ConstantSourceNode.ts
@@ -12,6 +12,6 @@ export default class ConstantSourceNode extends AudioScheduledSourceNode {
       options || {}
     );
     super(context, node);
-    this.offset = new AudioParam(node.offset, context);
+    this.offset = new AudioParam(node.offset, context, this);
   }
 }
diff --git a/packages/react-native-audio-api/src/core/DelayNode.ts b/packages/react-native-audio-api/src/core/DelayNode.ts
index d4ee33300..20ba52452 100644
--- a/packages/react-native-audio-api/src/core/DelayNode.ts
+++ b/packages/react-native-audio-api/src/core/DelayNode.ts
@@ -9,6 +9,6 @@ export default class DelayNode extends AudioNode {
   constructor(context: BaseAudioContext, options?: DelayOptions) {
     const delay = context.context.createDelay(options || {});
     super(context, delay);
-    this.delayTime = new AudioParam(delay.delayTime, context);
+    this.delayTime = new AudioParam(delay.delayTime, context, this);
   }
 }
diff --git a/packages/react-native-audio-api/src/core/GainNode.ts b/packages/react-native-audio-api/src/core/GainNode.ts
index 21f35b416..fadd3a318 100644
--- a/packages/react-native-audio-api/src/core/GainNode.ts
+++ b/packages/react-native-audio-api/src/core/GainNode.ts
@@ -10,6 +10,6 @@ export default class GainNode extends AudioNode {
   constructor(context: BaseAudioContext, options?: GainOptions) {
     const gainNode: IGainNode = context.context.createGain(options || {});
     super(context, gainNode);
-    this.gain = new AudioParam(gainNode.gain, context);
+    this.gain = new AudioParam(gainNode.gain, context, this);
   }
 }
diff --git a/packages/react-native-audio-api/src/core/OscillatorNode.ts b/packages/react-native-audio-api/src/core/OscillatorNode.ts
index db5e80182..0176ec5ef 100644
--- a/packages/react-native-audio-api/src/core/OscillatorNode.ts
+++ b/packages/react-native-audio-api/src/core/OscillatorNode.ts
@@ -17,8 +17,8 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
 
     const node = context.context.createOscillator(options || {});
     super(context, node);
-    this.frequency = new AudioParam(node.frequency, context);
-    this.detune = new AudioParam(node.detune, context);
+    this.frequency = new AudioParam(node.frequency, context, this);
+    this.detune = new AudioParam(node.detune, context, this);
     this.type = node.type;
   }
 
diff --git a/packages/react-native-audio-api/src/core/StereoPannerNode.ts b/packages/react-native-audio-api/src/core/StereoPannerNode.ts
index c66faef53..30f9e75a0 100644
--- a/packages/react-native-audio-api/src/core/StereoPannerNode.ts
+++ b/packages/react-native-audio-api/src/core/StereoPannerNode.ts
@@ -12,6 +12,6 @@ export default class StereoPannerNode extends AudioNode {
       options || {}
     );
     super(context, pan);
-    this.pan = new AudioParam(pan.pan, context);
+    this.pan = new AudioParam(pan.pan, context, this);
   }
 }
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index bc3ff0481..fe0d4f59a 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -124,8 +124,11 @@ export interface IAudioNode {
   readonly channelCountMode: ChannelCountMode;
   readonly channelInterpretation: ChannelInterpretation;
 
-  connect: (destination: IAudioNode | IAudioParam) => void;
-  disconnect: (destination?: IAudioNode | IAudioParam) => void;
+  connect(destination: IAudioNode): void;
+  connect(destination: IAudioParam, owner: IAudioNode): void;
+  disconnect(): void;
+  disconnect(destination: IAudioNode): void;
+  disconnect(destination: IAudioParam, owner: IAudioNode): void;
 }
 
 export interface IDelayNode extends IAudioNode {
diff --git a/packages/react-native-audio-api/src/web-core/AudioParam.tsx b/packages/react-native-audio-api/src/web-core/AudioParam.tsx
index 341f59e55..306bb7bcc 100644
--- a/packages/react-native-audio-api/src/web-core/AudioParam.tsx
+++ b/packages/react-native-audio-api/src/web-core/AudioParam.tsx
@@ -5,9 +5,8 @@ export default class AudioParam {
   readonly defaultValue: number;
   readonly minValue: number;
   readonly maxValue: number;
-  readonly context: BaseAudioContext;
-
   readonly param: globalThis.AudioParam;
+  readonly context: BaseAudioContext;
 
   constructor(param: globalThis.AudioParam, context: BaseAudioContext) {
     this.param = param;

From 9b984c5405a11ee1f53ee6e98ea53db74834066a Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 16:51:25 +0100
Subject: [PATCH 19/38] fix: fixed my processor node implementation in the
 guide and template

---
 .../docs/guides/create-your-own-effect.mdx        | 15 +++++----------
 .../templates/basic/shared/MyProcessorNode.cpp    |  8 ++------
 .../templates/basic/shared/MyProcessorNode.h      |  4 +---
 3 files changed, 8 insertions(+), 19 deletions(-)

diff --git a/packages/audiodocs/docs/guides/create-your-own-effect.mdx b/packages/audiodocs/docs/guides/create-your-own-effect.mdx
index 1ca972150..434f9ae39 100644
--- a/packages/audiodocs/docs/guides/create-your-own-effect.mdx
+++ b/packages/audiodocs/docs/guides/create-your-own-effect.mdx
@@ -49,12 +49,10 @@ namespace audioapi {
 
 class MyProcessorNode : public AudioNode {
 public:
-  explicit MyProcessorNode(const std::shared_ptr<BaseAudioContext> &context, );
+  explicit MyProcessorNode(const std::shared_ptr<BaseAudioContext> &context);
 
 protected:
-  std::shared_ptr<DSPAudioBuffer>
-  processNode(const std::shared_ptr<DSPAudioBuffer> &buffer,
-              int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
 // highlight-start
 private:
@@ -76,14 +74,11 @@ private:
 namespace audioapi {
     MyProcessorNode::MyProcessorNode(const std::shared_ptr<BaseAudioContext> &context)
         //highlight-next-line
-        : AudioNode(context), gain(0.5) {
-        isInitialized_.store(true, std::memory_order_release);
-    }
+        : AudioNode(context), gain(0.5) {}
 
-    std::shared_ptr<DSPAudioBuffer> MyProcessorNode::processNode(const std::shared_ptr<DSPAudioBuffer> &buffer,
-                                    int framesToProcess) {
+    void MyProcessorNode::processNode(int framesToProcess) {
       // highlight-start
-      for (int channel = 0; channel < buffer->getNumberOfChannels(); ++channel) {
+      for (int channel = 0; channel < audioBuffer_->getNumberOfChannels(); ++channel) {
         auto *audioArray = bus->getChannel(channel);
         for (size_t i = 0; i < framesToProcess; ++i) {
           // Apply gain to each sample in the audio array
diff --git a/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.cpp b/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.cpp
index f47c58cf9..a21571872 100644
--- a/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.cpp
+++ b/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.cpp
@@ -3,13 +3,9 @@
 namespace audioapi {
 MyProcessorNode::MyProcessorNode(
     const std::shared_ptr<BaseAudioContext> &context)
-    : AudioNode(context) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+    : AudioNode(context) {}
 
-std::shared_ptr<DSPAudioBuffer>
-MyProcessorNode::processNode(const std::shared_ptr<DSPAudioBuffer> &buffer,
-                             int framesToProcess) {
+void MyProcessorNode::processNode(int framesToProcess) {
   // put your processing logic here
 }
 } // namespace audioapi
diff --git a/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.h b/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.h
index 076ea9ab4..063807c0a 100644
--- a/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.h
+++ b/packages/custom-node-generator/templates/basic/shared/MyProcessorNode.h
@@ -10,8 +10,6 @@ class MyProcessorNode : public AudioNode {
   explicit MyProcessorNode(const std::shared_ptr<BaseAudioContext> &context);
 
 protected:
-  std::shared_ptr<DSPAudioBuffer>
-  processNode(const std::shared_ptr<DSPAudioBuffer> &buffer,
-              int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 };
 } // namespace audioapi

From b6adf6ce7c54f9ca97bac60d537924eea40f8beb Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Thu, 26 Mar 2026 17:26:34 +0100
Subject: [PATCH 20/38] refactor: removed isInitialized and added overrides for
 canBeDestructed

---
 .../common/cpp/audioapi/core/AudioNode.cpp        |  4 ----
 .../common/cpp/audioapi/core/AudioNode.h          |  7 -------
 .../cpp/audioapi/core/analysis/AnalyserNode.cpp   |  1 -
 .../core/destinations/AudioDestinationNode.cpp    | 15 ---------------
 .../core/destinations/AudioDestinationNode.h      |  8 ++++++--
 .../audioapi/core/effects/BiquadFilterNode.cpp    |  4 +---
 .../cpp/audioapi/core/effects/ConvolverNode.cpp   |  5 +----
 .../cpp/audioapi/core/effects/DelayNode.cpp       |  5 +----
 .../common/cpp/audioapi/core/effects/GainNode.cpp |  4 +---
 .../cpp/audioapi/core/effects/IIRFilterNode.cpp   |  4 +---
 .../audioapi/core/effects/StereoPannerNode.cpp    |  4 +---
 .../cpp/audioapi/core/effects/WaveShaperNode.cpp  |  1 -
 .../cpp/audioapi/core/effects/WorkletNode.cpp     |  4 +---
 .../core/effects/WorkletProcessingNode.cpp        |  2 --
 .../core/sources/AudioBufferQueueSourceNode.cpp   |  2 --
 .../core/sources/AudioBufferSourceNode.cpp        |  4 +---
 .../core/sources/AudioScheduledSourceNode.cpp     |  6 ++++--
 .../core/sources/AudioScheduledSourceNode.h       |  4 +++-
 .../audioapi/core/sources/ConstantSourceNode.cpp  |  4 +---
 .../cpp/audioapi/core/sources/OscillatorNode.cpp  |  2 --
 .../audioapi/core/sources/RecorderAdapterNode.h   |  2 ++
 .../cpp/audioapi/core/sources/StreamerNode.cpp    |  6 ------
 .../audioapi/core/sources/WorkletSourceNode.cpp   |  4 +---
 .../src/core/sources/AudioScheduledSourceTest.cpp |  4 +---
 24 files changed, 26 insertions(+), 80 deletions(-)
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
index 6439faf71..0b2134e05 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
@@ -34,8 +34,4 @@ bool AudioNode::requiresTailProcessing() const {
   return requiresTailProcessing_;
 }
 
-void AudioNode::cleanup() {
-  isInitialized_.store(false, std::memory_order_release);
-}
-
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 197988c25..972e49b97 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -105,14 +105,7 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   const ChannelInterpretation channelInterpretation_ = ChannelInterpretation::SPEAKERS;
   const bool requiresTailProcessing_;
 
-  std::atomic<bool> isInitialized_ = false;
-
-  virtual void disable() {
-    cleanup();
-  };
-
   virtual void processNode(int) = 0;
-  void cleanup();
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
index 869536705..bd4605d0e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
@@ -21,7 +21,6 @@ AnalyserNode::AnalyserNode(
       maxDecibels_(options.maxDecibels),
       smoothingTimeConstant_(options.smoothingTimeConstant) {
   setFFTSize(options.fftSize);
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 void AnalyserNode::setFFTSize(int fftSize) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
deleted file mode 100644
index a5da28694..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <audioapi/core/AudioNode.h>
-#include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/types/NodeOptions.h>
-
-#include <memory>
-
-namespace audioapi {
-
-AudioDestinationNode::AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context)
-    : AudioNode(context, AudioDestinationOptions()) {
-  isInitialized_.store(true, std::memory_order_release);
-}
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
index b8ddc654b..57ea2a975 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
@@ -13,10 +13,14 @@ class BaseAudioContext;
 
 class AudioDestinationNode : public AudioNode {
  public:
-  explicit AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context);
+  explicit AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context)
+      : AudioNode(context, AudioDestinationOptions()) {}
+
+  bool canBeDestructed() const override {
+    return false;
+  }
 
  protected:
-  // DestinationNode's processNode is never called; graph traversal skips it.
   void processNode(int) final {
     audioBuffer_->normalize();
   };
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
index 4074c0a66..f7c950455 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
@@ -67,9 +67,7 @@ BiquadFilterNode::BiquadFilterNode(
       x1_(MAX_CHANNEL_COUNT),
       x2_(MAX_CHANNEL_COUNT),
       y1_(MAX_CHANNEL_COUNT),
-      y2_(MAX_CHANNEL_COUNT) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+      y2_(MAX_CHANNEL_COUNT) {}
 
 void BiquadFilterNode::setType(BiquadFilterType type) {
   type_ = type;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index 2deab7259..2342beced 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -20,9 +20,7 @@ ConvolverNode::ConvolverNode(
       scaleFactor_(1.0f),
       intermediateBuffer_(nullptr),
       buffer_(nullptr),
-      internalBuffer_(nullptr) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+      internalBuffer_(nullptr) {}
 
 void ConvolverNode::setBuffer(
     const std::shared_ptr<AudioBuffer> &buffer,
@@ -99,7 +97,6 @@ void ConvolverNode::processNode(int framesToProcess) {
     if (remainingSegments_ > 0) {
       remainingSegments_--;
     } else {
-      disable();
       signalledToStop_ = false;
       internalBufferIndex_ = 0;
       return;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
index d21141762..f6cf525d2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
@@ -18,9 +18,7 @@ DelayNode::DelayNode(const std::shared_ptr<BaseAudioContext> &context, const Del
                   options.maxDelayTime * context->getSampleRate() +
                   1), // +1 to enable delayTime equal to maxDelayTime
               channelCount_,
-              context->getSampleRate())) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+              context->getSampleRate())) {}
 
 std::shared_ptr<AudioParam> DelayNode::getDelayTimeParam() const {
   return delayTimeParam_;
@@ -71,7 +69,6 @@ void DelayNode::processNode(int framesToProcess) {
   // handling tail processing
   if (signalledToStop_) {
     if (remainingFrames_ <= 0) {
-      disable();
       signalledToStop_ = false;
       return;
     }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp
index 5851d2a9e..4605604b8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/GainNode.cpp
@@ -15,9 +15,7 @@ GainNode::GainNode(const std::shared_ptr<BaseAudioContext> &context, const GainO
               options.gain,
               MOST_NEGATIVE_SINGLE_FLOAT,
               MOST_POSITIVE_SINGLE_FLOAT,
-              context)) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+              context)) {}
 
 std::shared_ptr<AudioParam> GainNode::getGainParam() const {
   return gainParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp
index d023cb4bc..4e26da459 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/IIRFilterNode.cpp
@@ -42,9 +42,7 @@ IIRFilterNode::IIRFilterNode(
       feedback_(createNormalizedArray(options.feedback, options.feedback[0])),
       xBuffers_(bufferLength, MAX_CHANNEL_COUNT, context->getSampleRate()),
       yBuffers_(bufferLength, MAX_CHANNEL_COUNT, context->getSampleRate()),
-      bufferIndices_(bufferLength) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+      bufferIndices_(bufferLength) {}
 
 // Compute Z-transform of the filter
 //
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
index 4f5e5bc8d..9cff53b27 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
@@ -19,9 +19,7 @@ StereoPannerNode::StereoPannerNode(
           std::make_shared<DSPAudioBuffer>(
               RENDER_QUANTUM_SIZE,
               channelCount_,
-              context->getSampleRate())) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+              context->getSampleRate())) {}
 
 std::shared_ptr<AudioParam> StereoPannerNode::getPanParam() const {
   return panParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
index 118f40730..2271c4068 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WaveShaperNode.cpp
@@ -17,7 +17,6 @@ WaveShaperNode::WaveShaperNode(
     waveShapers_.emplace_back(std::make_unique<WaveShaper>(nullptr, context->getSampleRate()));
   }
   setCurve(options.curve);
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 void WaveShaperNode::setOversample(OverSampleType type) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp
index 611052125..cfa4b56bf 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletNode.cpp
@@ -16,9 +16,7 @@ WorkletNode::WorkletNode(
           std::make_shared<AudioBuffer>(bufferLength, inputChannelCount, context->getSampleRate())),
       bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
-      curBuffIndex_(0) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+      curBuffIndex_(0) {}
 
 void WorkletNode::processNode(int framesToProcess) {
   size_t processed = 0;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
index 2bac2ec6e..002afc0dd 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
@@ -18,8 +18,6 @@ WorkletProcessingNode::WorkletProcessingNode(
     inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(RENDER_QUANTUM_SIZE);
     outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(RENDER_QUANTUM_SIZE);
   }
-
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 void WorkletProcessingNode::processNode(int framesToProcess) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
index 7365c11a1..3fc721165 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
@@ -25,8 +25,6 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
     // to compensate for processing latency.
     addExtraTailFrames_ = true;
   }
-
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 void AudioBufferQueueSourceNode::stop(double when) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index 1db142c09..02759e075 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -21,9 +21,7 @@ AudioBufferSourceNode::AudioBufferSourceNode(
       loop_(options.loop),
       loopSkip_(options.loopSkip),
       loopStart_(options.loopStart),
-      loopEnd_(options.loopEnd) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+      loopEnd_(options.loopEnd) {}
 
 void AudioBufferSourceNode::setLoop(bool loop) {
   loop_ = loop;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
index ccf820377..040605eb8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
@@ -68,6 +68,10 @@ void AudioScheduledSourceNode::unregisterOnEndedCallback(uint64_t callbackId) {
   audioEventHandlerRegistry_->unregisterHandler(AudioEvent::ENDED, callbackId);
 }
 
+bool AudioScheduledSourceNode::canBeDestructed() const {
+  return isUnscheduled() || isFinished();
+}
+
 void AudioScheduledSourceNode::updatePlaybackInfo(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     int framesToProcess,
@@ -155,8 +159,6 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 }
 
 void AudioScheduledSourceNode::disable() {
-  AudioNode::disable();
-
   if (onEndedCallbackId_ != 0) {
     audioEventHandlerRegistry_->invokeHandlerWithEventBody(
         AudioEvent::ENDED, onEndedCallbackId_, {});
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h
index 2b515e2c3..384669186 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h
@@ -44,10 +44,12 @@ class AudioScheduledSourceNode : public AudioNode {
   /// @note Audio Thread only
   void setOnEndedCallbackId(uint64_t callbackId);
 
-  void disable() override;
+  virtual void disable();
 
   void unregisterOnEndedCallback(uint64_t callbackId);
 
+  bool canBeDestructed() const override;
+
  protected:
   double startTime_;
   double stopTime_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp
index d52bf9c37..a40385923 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/ConstantSourceNode.cpp
@@ -16,9 +16,7 @@ ConstantSourceNode::ConstantSourceNode(
               options.offset,
               MOST_NEGATIVE_SINGLE_FLOAT,
               MOST_POSITIVE_SINGLE_FLOAT,
-              context)) {
-  isInitialized_.store(true, std::memory_order_release);
-}
+              context)) {}
 
 std::shared_ptr<AudioParam> ConstantSourceNode::getOffsetParam() const {
   return offsetParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
index 8acbd634b..255df2ac5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/OscillatorNode.cpp
@@ -26,8 +26,6 @@ OscillatorNode::OscillatorNode(
   } else {
     periodicWave_ = context->getBasicWaveForm(type_);
   }
-
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 std::shared_ptr<AudioParam> OscillatorNode::getFrequencyParam() const {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h
index f518e0f76..ebb811c63 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/RecorderAdapterNode.h
@@ -51,6 +51,8 @@ class RecorderAdapterNode : public AudioNode {
   // Accumulates resampled output across calls
   AudioBuffer overflowBuffer_;
   size_t overflowSize_ = 0;
+
+  std::atomic<bool> isInitialized_{false};
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
index e1c5e91d2..56a9405a7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.cpp
@@ -112,10 +112,6 @@ bool StreamerNode::initialize(const std::string &input_url) {
     return false;
   }
 
-  if (isInitialized_.load(std::memory_order_acquire)) {
-    return false;
-  }
-
   if (!openInput(input_url)) {
     if (VERBOSE)
       printf("Failed to open input\n");
@@ -151,7 +147,6 @@ bool StreamerNode::initialize(const std::string &input_url) {
   receiver_ = std::move(receiver);
 
   streamingThread_ = std::thread(&StreamerNode::streamAudio, this);
-  isInitialized_.store(true, std::memory_order_release);
   return true;
 }
 
@@ -344,7 +339,6 @@ void StreamerNode::cleanup() {
   decoder_ = nullptr;
   codecpar_ = nullptr;
   maxResampledSamples_ = 0;
-  isInitialized_.store(false, std::memory_order_release);
 }
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp
index c39bf0fd1..c650487aa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp
@@ -15,8 +15,6 @@ WorkletSourceNode::WorkletSourceNode(
   for (size_t i = 0; i < outputChannelCount; ++i) {
     outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(RENDER_QUANTUM_SIZE);
   }
-
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 void WorkletSourceNode::processNode(int framesToProcess) {
@@ -41,7 +39,7 @@ void WorkletSourceNode::processNode(int framesToProcess) {
       context->getSampleRate(),
       context->getCurrentSampleFrame());
 
-  if (nonSilentFramesToProcess == 0) {
+  if (!isPlaying() && !isStopScheduled() || nonSilentFramesToProcess == 0) {
     audioBuffer_->zero();
     return;
   }
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
index 804529b38..2b84f35dc 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioScheduledSourceTest.cpp
@@ -31,9 +31,7 @@ class AudioScheduledSourceTest : public ::testing::Test {
 class TestableAudioScheduledSourceNode : public AudioScheduledSourceNode {
  public:
   explicit TestableAudioScheduledSourceNode(std::shared_ptr<BaseAudioContext> context)
-      : AudioScheduledSourceNode(context) {
-    isInitialized_.store(true, std::memory_order_release);
-  }
+      : AudioScheduledSourceNode(context) {}
 
   void updatePlaybackInfo(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,

From 22c5b5f3d609c3c3eb2361dce37d723d94ecceea Mon Sep 17 00:00:00 2001
From: poneciak <poneciak@gmail.com>
Date: Sat, 28 Mar 2026 18:02:01 +0100
Subject: [PATCH 21/38] feat: bridge audio param to graph

---
 .../HostObjects/AudioNodeHostObject.cpp       |   8 +-
 .../HostObjects/AudioParamHostObject.cpp      |  26 +-
 .../HostObjects/AudioParamHostObject.h        |  28 ++-
 .../effects/BiquadFilterNodeHostObject.cpp    |  11 +-
 .../effects/DelayNodeHostObject.cpp           |   3 +-
 .../effects/GainNodeHostObject.cpp            |   2 +-
 .../effects/StereoPannerNodeHostObject.cpp    |   3 +-
 .../AudioBufferBaseSourceNodeHostObject.cpp   |   6 +-
 .../sources/ConstantSourceNodeHostObject.cpp  |   3 +-
 .../sources/OscillatorNodeHostObject.cpp      |   6 +-
 .../common/cpp/audioapi/core/AudioNode.h      |  34 +--
 .../common/cpp/audioapi/core/AudioParam.cpp   | 101 ++------
 .../common/cpp/audioapi/core/AudioParam.h     |  31 ++-
 .../cpp/audioapi/core/BaseAudioContext.cpp    |  11 +-
 .../audioapi/core/utils/graph/AudioGraph.hpp  |   3 +
 .../audioapi/core/utils/graph/BridgeNode.cpp  |  32 +++
 .../audioapi/core/utils/graph/BridgeNode.hpp  |  38 ++-
 .../cpp/audioapi/core/utils/graph/Graph.hpp   | 164 ------------
 .../audioapi/core/utils/graph/GraphObject.hpp |  75 ++++--
 .../audioapi/core/utils/graph/HostNode.hpp    |  12 -
 .../cpp/test/src/graph/BridgeNodeTest.cpp     | 235 ++++++++++--------
 .../cpp/test/src/graph/TestGraphUtils.h       |   8 +
 22 files changed, 403 insertions(+), 437 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp

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
index ab1b8b5aa..f2496461b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -66,8 +66,8 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
     connect(*node);
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    auto owner = args[1].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
-    connectParam(*owner, param->param_.get());
+    // Connect source → bridge (the bridge → owner edge is created at param construction)
+    graph_->addEdge(node_, param->bridgeNode());
   }
   return jsi::Value::undefined();
 }
@@ -84,8 +84,8 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, disconnect) {
     disconnect(*node);
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    auto owner = args[1].getObject(runtime).getHostObject<AudioNodeHostObject>(runtime);
-    disconnectParam(*owner, param->param_.get());
+    // Disconnect source → bridge
+    graph_->removeEdge(node_, param->bridgeNode());
   }
 
   return jsi::Value::undefined();
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
index 53d174d55..44ce149f5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/utils/graph/BridgeNode.hpp>
 #include <audioapi/utils/AudioArray.hpp>
 
 #include <memory>
@@ -8,11 +9,22 @@
 
 namespace audioapi {
 
-AudioParamHostObject::AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
-    : param_(param),
+AudioParamHostObject::AudioParamHostObject(
+    std::shared_ptr<utils::graph::Graph> graph,
+    HNode *ownerNode,
+    const std::shared_ptr<AudioParam> &param)
+    : graph_(std::move(graph)),
+      param_(param),
       defaultValue_(param->getDefaultValue()),
       minValue_(param->getMinValue()),
       maxValue_(param->getMaxValue()) {
+  // Create the bridge node in the graph
+  auto bridgeGraphObject = std::make_unique<utils::graph::BridgeNode>(param.get());
+  bridgeNode_ = graph_->addNode(std::move(bridgeGraphObject));
+
+  // Connect bridge → owner so topological sort orders correctly
+  (void)graph_->addEdge(bridgeNode_, ownerNode);
+
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
@@ -31,6 +43,16 @@ AudioParamHostObject::AudioParamHostObject(const std::shared_ptr<AudioParam> &pa
   addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioParamHostObject, value));
 }
 
+AudioParamHostObject::~AudioParamHostObject() {
+  if (graph_ && bridgeNode_) {
+    // Remove outgoing edges (bridge → owner)
+    (void)graph_->removeAllEdges(bridgeNode_);
+    // Remove the bridge node itself
+    (void)graph_->removeNode(bridgeNode_);
+    bridgeNode_ = nullptr;
+  }
+}
+
 JSI_PROPERTY_GETTER_IMPL(AudioParamHostObject, value) {
   return {param_->getValue()};
 }
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
index 64cd8b8fe..efb22ad20 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/utils/graph/HostNode.hpp>
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
@@ -11,9 +12,27 @@ using namespace facebook;
 
 class AudioParam;
 
+/// @brief Host object for AudioParam that owns its BridgeNode.
+///
+/// When created, a BridgeNode is added to the graph and connected to the
+/// owner node (bridge → owner). Sources connecting to this param connect
+/// to the bridge node (source → bridge).
+///
+/// When destroyed, the BridgeNode is removed from the graph.
 class AudioParamHostObject : public JsiHostObject {
  public:
-  explicit AudioParamHostObject(const std::shared_ptr<AudioParam> &param);
+  using HNode = utils::graph::HostGraph::Node;
+
+  /// @brief Creates an AudioParamHostObject with its BridgeNode.
+  /// @param graph The audio graph
+  /// @param ownerNode The HNode* of the AudioNode that owns this param
+  /// @param param The AudioParam this host object represents
+  explicit AudioParamHostObject(
+      std::shared_ptr<utils::graph::Graph> graph,
+      HNode *ownerNode,
+      const std::shared_ptr<AudioParam> &param);
+
+  ~AudioParamHostObject() override;
 
   JSI_PROPERTY_GETTER_DECL(value);
   JSI_PROPERTY_GETTER_DECL(defaultValue);
@@ -30,9 +49,16 @@ class AudioParamHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(cancelScheduledValues);
   JSI_HOST_FUNCTION_DECL(cancelAndHoldAtTime);
 
+  /// @brief Returns the bridge node for this param (for source → bridge connections).
+  [[nodiscard]] HNode *bridgeNode() const {
+    return bridgeNode_;
+  }
+
  private:
   friend class AudioNodeHostObject;
 
+  std::shared_ptr<utils::graph::Graph> graph_;
+  HNode *bridgeNode_ = nullptr;
   std::shared_ptr<AudioParam> param_;
   float defaultValue_;
   float minValue_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp
index 1e111e91f..0e1c2d6a7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp
@@ -20,10 +20,13 @@ BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
           options),
       type_(options.type) {
   auto biquadFilterNode = static_cast<BiquadFilterNode *>(node_->handle->audioNode->asAudioNode());
-  frequencyParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getFrequencyParam());
-  detuneParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getDetuneParam());
-  QParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
-  gainParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getGainParam());
+  frequencyParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, biquadFilterNode->getFrequencyParam());
+  detuneParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, biquadFilterNode->getDetuneParam());
+  QParam_ = std::make_shared<AudioParamHostObject>(graph_, node_, biquadFilterNode->getQParam());
+  gainParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, biquadFilterNode->getGainParam());
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, frequency),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
index 7467f61be..ee1fd5de5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
@@ -16,7 +16,8 @@ DelayNodeHostObject::DelayNodeHostObject(
           std::make_unique<DelayNode>(context, options),
           options) {
   auto delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
-  delayTimeParam_ = std::make_shared<AudioParamHostObject>(delayNode->getDelayTimeParam());
+  delayTimeParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, delayNode->getDelayTimeParam());
   addGetters(JSI_EXPORT_PROPERTY_GETTER(DelayNodeHostObject, delayTime));
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp
index d33c16fd8..e99133738 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp
@@ -16,7 +16,7 @@ GainNodeHostObject::GainNodeHostObject(
           std::make_unique<GainNode>(context, options),
           options) {
   auto gainNode = static_cast<GainNode *>(node_->handle->audioNode->asAudioNode());
-  gainParam_ = std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
+  gainParam_ = std::make_shared<AudioParamHostObject>(graph_, node_, gainNode->getGainParam());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(GainNodeHostObject, gain));
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp
index 77c6a76f9..45a666779 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp
@@ -16,7 +16,8 @@ StereoPannerNodeHostObject::StereoPannerNodeHostObject(
           std::make_unique<StereoPannerNode>(context, options),
           options) {
   auto stereoPannerNode = static_cast<StereoPannerNode *>(node_->handle->audioNode->asAudioNode());
-  panParam_ = std::make_shared<AudioParamHostObject>(stereoPannerNode->getPanParam());
+  panParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, stereoPannerNode->getPanParam());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(StereoPannerNodeHostObject, pan));
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
index 8dea41b50..41f5b49a3 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
@@ -19,8 +19,10 @@ AudioBufferBaseSourceNodeHostObject::AudioBufferBaseSourceNodeHostObject(
       pitchCorrection_(options.pitchCorrection) {
   auto sourceNode =
       static_cast<AudioBufferBaseSourceNode *>(node_->handle->audioNode->asAudioNode());
-  detuneParam_ = std::make_shared<AudioParamHostObject>(sourceNode->getDetuneParam());
-  playbackRateParam_ = std::make_shared<AudioParamHostObject>(sourceNode->getPlaybackRateParam());
+  detuneParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, sourceNode->getDetuneParam());
+  playbackRateParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, sourceNode->getPlaybackRateParam());
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, detune),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp
index c194026c6..c592661a6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/ConstantSourceNodeHostObject.cpp
@@ -16,7 +16,8 @@ ConstantSourceNodeHostObject::ConstantSourceNodeHostObject(
           options) {
   auto constantSourceNode =
       static_cast<ConstantSourceNode *>(node_->handle->audioNode->asAudioNode());
-  offsetParam_ = std::make_shared<AudioParamHostObject>(constantSourceNode->getOffsetParam());
+  offsetParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, constantSourceNode->getOffsetParam());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(ConstantSourceNodeHostObject, offset));
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
index 1ce8008fa..00bae4a65 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
@@ -20,8 +20,10 @@ OscillatorNodeHostObject::OscillatorNodeHostObject(
           options),
       type_(options.type) {
   auto oscillatorNode = static_cast<OscillatorNode *>(node_->handle->audioNode->asAudioNode());
-  frequencyParam_ = std::make_shared<AudioParamHostObject>(oscillatorNode->getFrequencyParam());
-  detuneParam_ = std::make_shared<AudioParamHostObject>(oscillatorNode->getDetuneParam());
+  frequencyParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, oscillatorNode->getFrequencyParam());
+  detuneParam_ =
+      std::make_shared<AudioParamHostObject>(graph_, node_, oscillatorNode->getDetuneParam());
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(OscillatorNodeHostObject, frequency),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 972e49b97..2b504e0f5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -12,6 +12,7 @@
 #include <cstddef>
 #include <memory>
 #include <utility>
+#include <vector>
 
 namespace audioapi {
 
@@ -25,20 +26,6 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
 
   size_t getChannelCount() const;
 
-  template <std::ranges::input_range R>
-    requires std::same_as<std::ranges::range_reference_t<R>, const GraphObject &>
-  void process(R &&inputs, int numFrames) {
-    getInputBuffer()->zero();
-
-    for (const auto &input : inputs) {
-      if (const AudioNode *audioNode = input.asAudioNode()) {
-        getInputBuffer()->sum(*audioNode->getOutputBuffer(), channelInterpretation_);
-      }
-    }
-
-    processNode(numFrames);
-  }
-
   float getContextSampleRate() const {
     if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
       return context->getSampleRate();
@@ -51,6 +38,12 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
     return getContextSampleRate() / 2.0f;
   }
 
+  /// @brief Returns the output buffer for this node.
+  /// @note Audio Thread only.
+  [[nodiscard]] const DSPAudioBuffer *getOutput() const override {
+    return audioBuffer_.get();
+  }
+
   /// @brief Returns the input buffer for this node. By default, this is the same as the output buffer.
   /// @note Audio Thread only.
   /// @note For StereoPannerNode and PannerNode due to channel limitations -
@@ -92,7 +85,6 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   }
 
  protected:
-  //  friend class ConvolverNode;
   friend class DelayNodeHostObject;
 
   std::weak_ptr<BaseAudioContext> context_;
@@ -105,6 +97,18 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   const ChannelInterpretation channelInterpretation_ = ChannelInterpretation::SPEAKERS;
   const bool requiresTailProcessing_;
 
+  /// @brief Implementation of processing logic for AudioNode.
+  /// Mixes input buffers and calls processNode.
+  void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override {
+    getInputBuffer()->zero();
+
+    for (const DSPAudioBuffer *input : inputs) {
+      getInputBuffer()->sum(*input, channelInterpretation_);
+    }
+
+    processNode(numFrames);
+  }
+
   virtual void processNode(int) = 0;
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
index af7966ce1..2cb710329 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
@@ -23,10 +23,10 @@ AudioParam::AudioParam(
       endTime_(0),
       startValue_(defaultValue),
       endValue_(defaultValue),
-      audioBuffer_(
+      inputBuffer_(
+          std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())),
+      outputBuffer_(
           std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())) {
-  inputBuffers_.reserve(4);
-  inputNodes_.reserve(4);
   // Default calculation function just returns the static value
   calculateValue_ = [this](double, double, float, float, double) {
     return value_.load(std::memory_order_relaxed);
@@ -214,90 +214,41 @@ void AudioParam::cancelAndHoldAtTime(double cancelTime) {
   this->eventsQueue_.cancelAndHoldAtTime(cancelTime, this->endTime_);
 }
 
-void AudioParam::addInputNode(AudioNode *node) {
-  inputNodes_.emplace_back(node);
-}
-
-void AudioParam::removeInputNode(AudioNode *node) {
-  for (int i = 0; i < inputNodes_.size(); i++) {
-    if (inputNodes_[i] == node) {
-      std::swap(inputNodes_[i], inputNodes_.back());
-      inputNodes_.resize(inputNodes_.size() - 1);
-      break;
-    }
-  }
-}
-
-std::shared_ptr<DSPAudioBuffer> AudioParam::calculateInputs(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
-  processingBuffer->zero();
-  if (inputNodes_.empty()) {
-    return processingBuffer;
-  }
-  processInputs(processingBuffer, framesToProcess, true);
-  mixInputsBuffers(processingBuffer);
-  return processingBuffer;
-}
-
 std::shared_ptr<DSPAudioBuffer> AudioParam::processARateParam(int framesToProcess, double time) {
-  auto processingBuffer = calculateInputs(audioBuffer_, framesToProcess);
-
   std::shared_ptr<BaseAudioContext> context = context_.lock();
-  if (context == nullptr)
-    return processingBuffer;
+  if (context == nullptr) {
+    outputBuffer_->zero();
+    return outputBuffer_;
+  }
+
   float sampleRate = context->getSampleRate();
-  auto bufferData = processingBuffer->getChannel(0)->span();
-  float timeCache = time;
-  float timeStep = 1.0f / sampleRate;
-  float sample = 0.0f;
+  double timeCache = time;
+  double timeStep = 1.0 / sampleRate;
+
+  // Read modulation from input buffer (filled by BridgeNode if connected, otherwise zeros)
+  auto inputData = inputBuffer_->getChannel(0)->span();
+  auto outputData = outputBuffer_->getChannel(0)->span();
 
-  // Add automated parameter value to each sample
+  // Compute: modulation + automated parameter value → output buffer
   for (size_t i = 0; i < framesToProcess; i++, timeCache += timeStep) {
-    sample = getValueAtTime(timeCache);
-    bufferData[i] += sample;
+    outputData[i] = inputData[i] + getValueAtTime(timeCache);
   }
-  // processingBuffer is a mono buffer containing per-sample parameter values
-  return processingBuffer;
-}
 
-float AudioParam::processKRateParam(int framesToProcess, double time) {
-  auto processingBuffer = calculateInputs(audioBuffer_, framesToProcess);
+  // Zero the input buffer so next frame starts clean if no BridgeNode refills it
+  inputBuffer_->zero();
 
-  // Return block-rate parameter value plus first sample of input modulation
-  return processingBuffer->getChannel(0)->span()[0] + getValueAtTime(time);
+  return outputBuffer_;
 }
 
-void AudioParam::processInputs(
-    const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  for (auto it = inputNodes_.begin(), end = inputNodes_.end(); it != end; ++it) {
-    auto inputNode = *it;
-    assert(inputNode != nullptr);
-
-    // if (!inputNode->isEnabled()) {
-    //   continue;
-    // }
-
-    // Process this input node and store its output buffer
-    // TODO
-    // auto inputBuffer =
-    //     inputNode->processAudio(outputBuffer, framesToProcess, checkIsAlreadyProcessed);
-    // inputBuffers_.emplace_back(inputBuffer);
-  }
-}
-
-void AudioParam::mixInputsBuffers(const std::shared_ptr<DSPAudioBuffer> &processingBuffer) {
-  assert(processingBuffer != nullptr);
+float AudioParam::processKRateParam(int framesToProcess, double time) {
+  // Return block-rate parameter value plus first sample of input modulation
+  float modulation = inputBuffer_->getChannel(0)->span()[0];
+  float result = modulation + getValueAtTime(time);
 
-  // Sum all input buffers into the processing buffer
-  for (auto it = inputBuffers_.begin(), end = inputBuffers_.end(); it != end; ++it) {
-    processingBuffer->sum(**it, ChannelInterpretation::SPEAKERS);
-  }
+  // Zero the input buffer so next frame starts clean if no BridgeNode refills it
+  inputBuffer_->zero();
 
-  // Clear for next processing cycle
-  inputBuffers_.clear();
+  return result;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
index 67484b3d8..c3a2a0403 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
@@ -1,18 +1,15 @@
 #pragma once
 
-#include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
 #include <audioapi/core/utils/AudioParamEventQueue.h>
 #include <audioapi/core/utils/ParamChangeEvent.hpp>
-#include <audioapi/core/utils/graph/GraphObject.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
 #include <cstddef>
 #include <memory>
 #include <utility>
-#include <vector>
 
 namespace audioapi {
 
@@ -83,11 +80,18 @@ class AudioParam {
   /// Audio-Thread only methods
   /// These methods are called only from the Audio rendering thread.
 
+  /// @brief Returns the input buffer where BridgeNode stores mixed modulation signals.
   /// @note Audio Thread only
-  void addInputNode(AudioNode *node);
+  [[nodiscard]] std::shared_ptr<DSPAudioBuffer> getInputBuffer() const {
+    return inputBuffer_;
+  }
 
+  /// @brief Called when a BridgeNode connected to this param is being destroyed.
+  /// Clears the input buffer so the param no longer relies on stale bridge data.
   /// @note Audio Thread only
-  void removeInputNode(AudioNode *node);
+  void onBridgeDetached() {
+    inputBuffer_->zero();
+  }
 
   /// @note Audio Thread only
   std::shared_ptr<DSPAudioBuffer> processARateParam(int framesToProcess, double time);
@@ -112,10 +116,10 @@ class AudioParam {
   float endValue_;
   std::function<float(double, double, float, float, double)> calculateValue_;
 
-  // Input modulation system
-  std::vector<AudioNode *> inputNodes_;
-  std::shared_ptr<DSPAudioBuffer> audioBuffer_;
-  std::vector<std::shared_ptr<DSPAudioBuffer>> inputBuffers_;
+  // Input modulation buffer - filled by BridgeNode during graph processing
+  std::shared_ptr<DSPAudioBuffer> inputBuffer_;
+  // Output buffer for a-rate processing - contains modulation + param value
+  std::shared_ptr<DSPAudioBuffer> outputBuffer_;
 
   /// @brief Get the end time of the parameter queue.
   /// @return The end time of the parameter queue or last endTime_ if queue is empty.
@@ -141,15 +145,8 @@ class AudioParam {
   inline void updateQueue(ParamChangeEvent &&event) {
     eventsQueue_.pushBack(std::move(event));
   }
+
   float getValueAtTime(double time);
-  void processInputs(
-      const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-      int framesToProcess,
-      bool checkIsAlreadyProcessed);
-  void mixInputsBuffers(const std::shared_ptr<DSPAudioBuffer> &processingBuffer);
-  std::shared_ptr<DSPAudioBuffer> calculateInputs(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index dee452c3a..448c12e4b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -112,12 +112,11 @@ void BaseAudioContext::processGraph(DSPAudioBuffer *buffer, int numFrames) {
   processAudioEvents();
 
   for (auto &&[node, inputs] : graph_->iter()) {
-    auto audioNode = node.asAudioNode();
-    if (audioNode != nullptr) {
-      audioNode->process(inputs, numFrames);
-      if (audioNode == destination_) {
-        buffer->copy(*audioNode->getOutputBuffer(), 0, 0, numFrames);
-      }
+    node.process(inputs, numFrames);
+
+    // Copy destination output to the final buffer
+    if (auto *audioNode = node.asAudioNode(); audioNode == destination_) {
+      buffer->copy(*audioNode->getOutputBuffer(), 0, 0, numFrames);
     }
   }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
index 9a2b98295..d5d03aff8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
@@ -223,6 +223,8 @@ inline void AudioGraph::process() {
     if (node.orphaned && InputPool::isEmpty(node.input_head) &&
         node.handle->audioNode->canBeDestructed()) {
       node.will_be_deleted = true;
+      // Call beforeDestruction while node is still valid (before move/compaction)
+      node.handle->audioNode->beforeDestruction();
     }
   }
 
@@ -265,6 +267,7 @@ inline void AudioGraph::process() {
   for (std::uint32_t i = b; i < n; i++) {
     // Free any lingering pool slots (should already be empty for deleted nodes)
     pool_.freeAll(nodes[i].input_head);
+    // Handle may have been moved-from during compaction, so just null it
     nodes[i].handle = nullptr;
   }
   nodes.resize(b);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
new file mode 100644
index 000000000..ff4620269
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
@@ -0,0 +1,32 @@
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/utils/graph/BridgeNode.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+
+#include <vector>
+
+namespace audioapi::utils::graph {
+
+void BridgeNode::beforeDestruction() {
+  // Notify AudioParam that it should no longer rely on bridge input
+  if (param_ != nullptr) {
+    param_->onBridgeDetached();
+  }
+}
+
+void BridgeNode::processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) {
+  // Skip processing if param is null (e.g., in tests)
+  if (param_ == nullptr) {
+    return;
+  }
+
+  // Get AudioParam's input buffer and fill it with mixed inputs
+  auto inputBuffer = param_->getInputBuffer();
+  inputBuffer->zero();
+
+  for (const DSPAudioBuffer *input : inputs) {
+    inputBuffer->sum(*input, ChannelInterpretation::SPEAKERS);
+  }
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
index d373977a2..6fcbea67b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
@@ -1,6 +1,11 @@
 #pragma once
 
+#include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/graph/GraphObject.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+
+#include <memory>
+#include <vector>
 
 namespace audioapi {
 class AudioParam;
@@ -8,37 +13,52 @@ class AudioParam;
 
 namespace audioapi::utils::graph {
 
-/// @brief Lightweight graph-only node that represents an AudioParam connection.
+/// @brief Processable graph node that bridges AudioNode outputs to AudioParam inputs.
 ///
-/// A BridgeNode sits between a source AudioNode and the owner AudioNode of a
-/// param, forming the path: source → bridge → owner. This lets the graph
+/// A BridgeNode sits between source AudioNode(s) and the owner AudioNode of a
+/// param, forming the path: source(s) → bridge → owner. This lets the graph
 /// system detect cycles and compute correct topological ordering for param
-/// connections without creating real ownership dependencies.
+/// connections.
 ///
 /// BridgeNodes are:
-///   - **Not processable** — skipped by `AudioGraph::iter()`.
+///   - **Processable** — mixes inputs and writes directly to AudioParam's input buffer.
+///   - **Not mixable** — getOutput() returns nullptr, so other nodes won't mix it.
 ///   - **Always destructible** — removed by compaction when orphaned with no inputs.
-///   - **Non-owning** — stores a raw `AudioParam*` whose lifetime is guaranteed
-///     by the owner node.
+///
+/// ## Lifetime Management
+/// - HostAudioParam owns the BridgeNode
+/// - BridgeNode holds raw pointer to AudioParam (lifetime guaranteed by owner)
+/// - When HostAudioParam is destructed, BridgeNode becomes orphaned
+/// - canBeDestructed() always returns true, so it's cleaned up on next compaction
 class BridgeNode final : public GraphObject {
  public:
   explicit BridgeNode(AudioParam *param) : param_(param) {}
 
+  void beforeDestruction() override;
+
   [[nodiscard]] bool isProcessable() const override {
-    return false;
+    return true;
   }
 
   [[nodiscard]] bool canBeDestructed() const override {
     return true;
   }
 
+  /// @brief Returns nullptr - BridgeNode should not be mixed as input for other nodes.
+  [[nodiscard]] const DSPAudioBuffer *getOutput() const override {
+    return nullptr;
+  }
+
   /// @brief Returns the param this bridge represents a connection to.
   [[nodiscard]] AudioParam *param() const {
     return param_;
   }
 
+ protected:
+  void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override;
+
  private:
-  AudioParam *param_; // non-owning — lifetime guaranteed by owner node
+  AudioParam *param_;
 };
 
 } // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index cd7bf1893..ec58a618e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -2,7 +2,6 @@
 
 #include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/BridgeNode.hpp>
 #include <audioapi/core/utils/graph/HostGraph.hpp>
 #include <audioapi/core/utils/graph/InputPool.hpp>
 
@@ -14,13 +13,8 @@
 #include <algorithm>
 #include <cstdint>
 #include <memory>
-#include <unordered_map>
 #include <utility>
 
-namespace audioapi {
-class AudioParam;
-}
-
 namespace audioapi::utils::graph {
 
 /// @brief Thread-safe graph coordinator that bridges HostGraph (main thread)
@@ -182,115 +176,6 @@ class Graph {
     });
   }
 
-  // ── Param bridge API ───────────────────────────────────────────────────
-
-  /// @brief Creates a bridge node representing: source → bridge → owner.
-  ///
-  /// The bridge encodes a param connection in the graph for cycle detection
-  /// and topological ordering. The bridge itself is not processable.
-  ///
-  /// @param source the node whose output feeds the param
-  /// @param owner the node that owns the param
-  /// @param param raw pointer to the AudioParam (lifetime guaranteed by owner)
-  /// @return Ok on success, Err on cycle/duplicate/not-found
-  Res connectParam(HNode *source, HNode *owner, AudioParam *param) {
-    hostGraph.collectDisposedNodes();
-
-    BridgeKey key{source, param};
-    if (bridgeMap_.count(key)) {
-      return Res::Err(ResultError::EDGE_ALREADY_EXISTS);
-    }
-
-    // Create bridge node
-    auto bridgeObj = std::make_unique<BridgeNode>(param);
-    auto bridgeHandle = std::make_shared<NodeHandle>(0, std::move(bridgeObj));
-    auto [bridgeHostNode, addEvent] = hostGraph.addNode(bridgeHandle);
-
-    // source → bridge
-    auto edgeRes1 = hostGraph.addEdge(source, bridgeHostNode);
-    if (edgeRes1.is_err()) {
-      // Rollback: remove bridge node
-      (void)hostGraph.removeNode(bridgeHostNode);
-      return Res::Err(edgeRes1.unwrap_err());
-    }
-
-    // bridge → owner
-    auto edgeRes2 = hostGraph.addEdge(bridgeHostNode, owner);
-    if (edgeRes2.is_err()) {
-      // Rollback: remove source→bridge edge and bridge node
-      (void)hostGraph.removeEdge(source, bridgeHostNode);
-      (void)hostGraph.removeNode(bridgeHostNode);
-      return Res::Err(edgeRes2.unwrap_err());
-    }
-
-    // All succeeded — send events through SPSC
-    sendNodeGrowIfNeeded();
-    eventSender_.send(std::move(addEvent));
-
-    sendPoolGrowIfNeeded();
-    eventSender_.send(std::move(edgeRes1).unwrap());
-
-    sendPoolGrowIfNeeded();
-    eventSender_.send(std::move(edgeRes2).unwrap());
-
-    // Track bridge
-    bridgeMap_[key] = bridgeHostNode;
-    bridgeOwners_[bridgeHostNode] = owner;
-
-    return Res::Ok(NoneType{});
-  }
-
-  /// @brief Removes a bridge node for the given (source, param) pair.
-  Res disconnectParam(HNode *source, HNode * /*owner*/, AudioParam *param) {
-    hostGraph.collectDisposedNodes();
-
-    BridgeKey key{source, param};
-    auto it = bridgeMap_.find(key);
-    if (it == bridgeMap_.end()) {
-      return Res::Err(ResultError::EDGE_NOT_FOUND);
-    }
-
-    HNode *bridge = it->second;
-    removeBridge(source, bridge);
-    bridgeMap_.erase(it);
-
-    return Res::Ok(NoneType{});
-  }
-
-  /// @brief Removes a node and cascade-removes any bridges where this node
-  /// is the source or owner.
-  Res removeNodeWithBridges(HNode *node) {
-    hostGraph.collectDisposedNodes();
-
-    // Cascade: remove bridges where this node is source
-    for (auto it = bridgeMap_.begin(); it != bridgeMap_.end();) {
-      if (it->first.source == node) {
-        HNode *bridge = it->second;
-        removeBridge(node, bridge);
-        bridgeOwners_.erase(bridge);
-        it = bridgeMap_.erase(it);
-      } else {
-        ++it;
-      }
-    }
-
-    // Cascade: remove bridges where this node is owner
-    for (auto it = bridgeMap_.begin(); it != bridgeMap_.end();) {
-      auto ownerIt = bridgeOwners_.find(it->second);
-      if (ownerIt != bridgeOwners_.end() && ownerIt->second == node) {
-        HNode *bridge = it->second;
-        HNode *source = it->first.source;
-        removeBridge(source, bridge);
-        bridgeOwners_.erase(ownerIt);
-        it = bridgeMap_.erase(it);
-      } else {
-        ++it;
-      }
-    }
-
-    return removeNode(node);
-  }
-
  private:
   using OwnedSlotBuffer = std::unique_ptr<InputPool::Slot[]>;
 
@@ -349,55 +234,6 @@ class Graph {
 
   // ── Bridge tracking (main thread only) ──────────────────────────────────
 
-  struct BridgeKey {
-    HNode *source;
-    AudioParam *param;
-
-    bool operator==(const BridgeKey &other) const {
-      return source == other.source && param == other.param;
-    }
-  };
-
-  struct BridgeKeyHash {
-    size_t operator()(const BridgeKey &k) const {
-      auto h1 = std::hash<HNode *>{}(k.source);
-      auto h2 = std::hash<AudioParam *>{}(k.param);
-      return h1 ^ (h2 << 1);
-    }
-  };
-
-  /// Maps (source, param) → bridge host node
-  std::unordered_map<BridgeKey, HNode *, BridgeKeyHash> bridgeMap_;
-
-  /// Maps bridge host node → owner host node (for cascade removal)
-  std::unordered_map<HNode *, HNode *> bridgeOwners_;
-
-  /// @brief Removes a bridge node: tears down edges and marks for removal.
-  void removeBridge(HNode *source, HNode *bridge) {
-    // Find the owner from bridgeOwners_
-    auto ownerIt = bridgeOwners_.find(bridge);
-    HNode *owner = (ownerIt != bridgeOwners_.end()) ? ownerIt->second : nullptr;
-
-    // Remove edges: source→bridge, bridge→owner
-    auto res1 = hostGraph.removeEdge(source, bridge);
-    if (res1.is_ok()) {
-      eventSender_.send(std::move(res1).unwrap());
-    }
-
-    if (owner) {
-      auto res2 = hostGraph.removeEdge(bridge, owner);
-      if (res2.is_ok()) {
-        eventSender_.send(std::move(res2).unwrap());
-      }
-    }
-
-    // Remove bridge node
-    auto res3 = hostGraph.removeNode(bridge);
-    if (res3.is_ok()) {
-      eventSender_.send(std::move(res3).unwrap());
-    }
-  }
-
   friend class GraphTest;
 };
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
index 2363af77c..61bafc2eb 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
@@ -1,63 +1,98 @@
 #pragma once
 
+#include <audioapi/utils/AudioBuffer.hpp>
+
+#include <ranges>
+#include <vector>
+
 namespace audioapi {
 class AudioNode;
-class AudioParam;
 } // namespace audioapi
 
 namespace audioapi::utils::graph {
 
-/// @brief Base class for graph objects (AudioNode or AudioParam).
+/// @brief Base class for graph objects (AudioNode, BridgeNode, etc.).
 /// GraphObjects are owned by NodeHandles and stored in AudioGraph's flat vector
 ///
 /// ## Lifecycle
 /// - Created on the main thread as a unique_ptr
 /// - Transferred to AudioGraph via NodeHandle on node addition
-/// - Accessed on the audio thread during processing (e.g. for processAudio)
+/// - Accessed on the audio thread during processing
 /// - Destroyed when all below conditions are met:
 ///   1. The HostNode is removed and the NodeHandle is marked as a ghost
 ///   2. The Node has no inputs
-///   3. canBeDestructed() returns true (e.g. AudioNode-specific lifecycle checks)
+///   3. canBeDestructed() returns true
+///
+/// ## Processing Model
+/// - `isProcessable()` determines if the node participates in audio processing
+/// - `process()` is called during graph iteration for processable nodes
+/// - `getOutput()` returns the output buffer; nullptr means not mixable as input
 class GraphObject {
  public:
   virtual ~GraphObject() = default;
 
+  /// @brief Called before destruction to allow cleanup or state updates.
+  /// @note called on the audio thread just before letting the object go
+  virtual void beforeDestruction() {}
+
   /// @brief Returns whether this graph object can be safely destroyed.
-  ///
-  /// Default behavior is permissive for new GraphObject-based entities.
-  /// AudioNode / AudioParam can override with richer lifecycle checks.
   [[nodiscard]] virtual bool canBeDestructed() const {
     return true;
   }
 
   /// @brief Returns whether this node should be processed during audio iteration.
-  ///
-  /// Default is true. BridgeNodes override to return false — they exist only
-  /// for graph structure (cycle detection, topo ordering) and are skipped
-  /// by AudioGraph::iter().
   [[nodiscard]] virtual bool isProcessable() const {
     return true;
   }
 
-  /// @brief Downcast helper for node-specific handling.
-  [[nodiscard]] virtual AudioNode *asAudioNode() {
+  /// @brief Returns the output buffer for this node.
+  /// @return Pointer to output buffer, or nullptr if this node should not
+  ///         contribute to input mixing for other nodes.
+  [[nodiscard]] virtual const DSPAudioBuffer *getOutput() const {
     return nullptr;
   }
 
-  /// @brief Downcast helper for node-specific handling.
-  [[nodiscard]] virtual const AudioNode *asAudioNode() const {
-    return nullptr;
+  /// @brief Processes this node with the given inputs.
+  /// Filters inputs to only those with valid output buffers.
+  /// @tparam R Range of GraphObject references (inputs from the graph)
+  /// @param inputs Range of input GraphObjects
+  /// @param numFrames Number of audio frames to process
+  template <std::ranges::input_range R>
+    requires std::same_as<std::ranges::range_reference_t<R>, const GraphObject &>
+  void process(R &&inputs, int numFrames) {
+    // Collect valid input buffers (those with non-null getOutput)
+    inputBuffers_.clear();
+    for (const GraphObject &input : inputs) {
+      if (const DSPAudioBuffer *output = input.getOutput()) {
+        inputBuffers_.push_back(output);
+      }
+    }
+    processInputs(inputBuffers_, numFrames);
   }
 
-  /// @brief Downcast helper for param-specific handling.
-  [[nodiscard]] virtual AudioParam *asAudioParam() {
+  /// @brief Downcast helper for JS thread communication with AudioNode.
+  [[nodiscard]] virtual AudioNode *asAudioNode() {
     return nullptr;
   }
 
-  /// @brief Downcast helper for param-specific handling.
-  [[nodiscard]] virtual const AudioParam *asAudioParam() const {
+  /// @brief Downcast helper for JS thread communication with AudioNode.
+  [[nodiscard]] virtual const AudioNode *asAudioNode() const {
     return nullptr;
   }
+
+ protected:
+  /// @brief Implementation of processing logic with filtered input buffers.
+  /// @param inputs Vector of pointers to valid input buffers
+  /// @param numFrames Number of audio frames to process
+  virtual void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) {
+    // Default: do nothing. Subclasses override for actual processing.
+    (void)inputs;
+    (void)numFrames;
+  }
+
+ private:
+  // Reusable buffer for collecting inputs (avoids allocation per frame)
+  std::vector<const DSPAudioBuffer *> inputBuffers_;
 };
 
 } // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
index e778e0b88..2790622a7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
@@ -103,18 +103,6 @@ class HostNode {
     return graph_->removeEdge(node_, other.node_);
   }
 
-  /// @brief Connects this node's output to a param on the owner node via a bridge.
-  /// @return Ok on success, Err on cycle / duplicate / not-found
-  Res connectParam(HostNode &owner, AudioParam *param) {
-    return graph_->connectParam(node_, owner.node_, param);
-  }
-
-  /// @brief Disconnects this node's output from a param on the owner node.
-  /// @return Ok on success, Err on not-found
-  Res disconnectParam(HostNode &owner, AudioParam *param) {
-    return graph_->disconnectParam(node_, owner.node_, param);
-  }
-
   /// @brief Disconnects all this node's outputs.
   /// @return Ok on success, Err on not-found
   Res disconnect() {
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
index 3751ef8ea..47b50c0b3 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
@@ -23,9 +23,9 @@ TEST(BridgeNodeContract, MockNodeIsProcessable) {
   EXPECT_TRUE(node.isProcessable());
 }
 
-TEST(BridgeNodeContract, BridgeNodeIsNotProcessable) {
+TEST(BridgeNodeContract, BridgeNodeIsProcessable) {
   BridgeNode bridge(nullptr);
-  EXPECT_FALSE(bridge.isProcessable());
+  EXPECT_TRUE(bridge.isProcessable());
 }
 
 TEST(BridgeNodeContract, BridgeNodeIsAlwaysDestructible) {
@@ -40,10 +40,10 @@ TEST(BridgeNodeContract, NonProcessableMockNodeIsNotProcessable) {
 }
 
 TEST(BridgeNodeContract, BridgeNodeStoresParam) {
-  // Use a dummy pointer to verify storage
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0xDEAD);
-  BridgeNode bridge(fakeParam);
-  EXPECT_EQ(bridge.param(), fakeParam);
+  // Use a real AudioParam to verify storage
+  auto param = createMockAudioParam();
+  BridgeNode bridge(param.get());
+  EXPECT_EQ(bridge.param(), param.get());
 }
 
 // =========================================================================
@@ -215,23 +215,17 @@ TEST_F(BridgeIterTest, AllProcessableNodesInTopoOrder) {
   ASSERT_TRUE(addEdge(b, c));
   audioGraph.process();
 
-  // Should yield A, B, C in topo order (bridge skipped)
-  std::vector<int> values;
+  // Should yield A, bridge, B, C in topo order (bridge is now processable)
+  size_t count = 0;
   for (auto &&[graphObject, inputs] : audioGraph.iter()) {
-    auto *node = dynamic_cast<ProcessableMockNode *>(&graphObject);
-    ASSERT_NE(node, nullptr);
-    values.push_back(node->value.load());
+    count++;
   }
-  ASSERT_EQ(values.size(), 3u);
-  EXPECT_EQ(values[0], 1);
-  EXPECT_EQ(values[1], 2);
-  EXPECT_EQ(values[2], 3);
+  EXPECT_EQ(count, 4u);
 }
 
 TEST_F(BridgeIterTest, InputsViewMayReferenceBridgeIndices) {
   // source → bridge → owner
-  // iter() skips bridge but owner's input list in AudioGraph still
-  // references the bridge's index. Callers use asAudioNode() to handle this.
+  // iter() yields all processable nodes including bridge
   auto *source = addNode(std::make_unique<MockNode>());
   auto *bridge = addNode(std::make_unique<BridgeNode>(nullptr));
   auto *owner = addNode(std::make_unique<MockNode>());
@@ -243,13 +237,12 @@ TEST_F(BridgeIterTest, InputsViewMayReferenceBridgeIndices) {
   size_t processableCount = 0;
   for (auto &&[graphObject, inputs] : audioGraph.iter()) {
     processableCount++;
-    // Owner should see bridge as input (which is a BridgeNode, not AudioNode)
+    // Input could be bridge or source — both are valid GraphObjects
     for (const auto &input : inputs) {
-      // Input could be bridge or source — both are valid GraphObjects
       (void)input;
     }
   }
-  EXPECT_EQ(processableCount, 2u); // source + owner (bridge skipped)
+  EXPECT_EQ(processableCount, 3u); // source + bridge + owner
 }
 
 // =========================================================================
@@ -320,147 +313,158 @@ TEST_F(BridgeGraphTest, BridgeOrphanedAndNoInputsGetsCompacted) {
 
 class BridgeGraphWrapperTest : public ::testing::Test {
  protected:
+  using HNode = HostGraph::Node;
   static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
   DisposerImpl<kPayloadSize> disposer_{64};
   std::shared_ptr<Graph> graph;
+  // Hold real AudioParams to avoid fake pointer crashes
+  std::vector<std::shared_ptr<AudioParam>> params_;
 
   void SetUp() override {
     graph = std::make_shared<Graph>(4096, &disposer_);
   }
 
+  AudioParam *createParam() {
+    params_.push_back(createMockAudioParam());
+    return params_.back().get();
+  }
+
+  /// Simulates AudioParamHostObject: creates bridge, adds to graph, connects bridge→owner
+  HNode *createParamBridge(AudioParam *param, HNode *owner) {
+    auto *bridge = graph->addNode(std::make_unique<BridgeNode>(param));
+    EXPECT_TRUE(graph->addEdge(bridge, owner).is_ok());
+    return bridge;
+  }
+
   void processAll() {
     graph->processEvents();
     graph->process();
   }
 };
 
-TEST_F(BridgeGraphWrapperTest, ConnectParamCreatesBridge) {
+TEST_F(BridgeGraphWrapperTest, ConnectSourceToBridge) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
   auto *owner = graph->addNode(std::make_unique<MockNode>());
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+  auto *param = createParam();
+  auto *bridge = createParamBridge(param, owner);
 
-  auto result = graph->connectParam(source, owner, fakeParam);
+  auto result = graph->addEdge(source, bridge);
   ASSERT_TRUE(result.is_ok());
 
   processAll();
 
-  // Should have 3 nodes: source, bridge, owner
+  // Should have 3 nodes: source, bridge, owner (all processable now)
   size_t iterCount = 0;
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  // iter() skips non-processable bridge, so we see 2
-  EXPECT_EQ(iterCount, 2u);
+  EXPECT_EQ(iterCount, 3u);
 }
 
-TEST_F(BridgeGraphWrapperTest, DisconnectParamRemovesBridge) {
+TEST_F(BridgeGraphWrapperTest, DisconnectSourceFromBridge) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
   auto *owner = graph->addNode(std::make_unique<MockNode>());
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+  auto *param = createParam();
+  auto *bridge = createParamBridge(param, owner);
 
-  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  ASSERT_TRUE(graph->addEdge(source, bridge).is_ok());
   processAll();
 
-  ASSERT_TRUE(graph->disconnectParam(source, owner, fakeParam).is_ok());
+  // Disconnect source → bridge
+  ASSERT_TRUE(graph->removeEdge(source, bridge).is_ok());
   processAll();
 
-  // Bridge should be compacted away (orphaned + no inputs)
+  // Bridge still exists (owned by param host object), but no source connected
   size_t iterCount = 0;
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  EXPECT_EQ(iterCount, 2u); // source + owner
+  EXPECT_EQ(iterCount, 3u); // source + bridge + owner all still exist
 }
 
-TEST_F(BridgeGraphWrapperTest, DuplicateConnectParamRejected) {
+TEST_F(BridgeGraphWrapperTest, DuplicateEdgeToBridgeRejected) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
   auto *owner = graph->addNode(std::make_unique<MockNode>());
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+  auto *param = createParam();
+  auto *bridge = createParamBridge(param, owner);
 
-  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  ASSERT_TRUE(graph->addEdge(source, bridge).is_ok());
 
-  // Same connection again should fail
-  auto result = graph->connectParam(source, owner, fakeParam);
+  // Same edge again should fail
+  auto result = graph->addEdge(source, bridge);
   EXPECT_TRUE(result.is_err());
   EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::EDGE_ALREADY_EXISTS);
 }
 
-TEST_F(BridgeGraphWrapperTest, ConnectParamCycleDetected) {
+TEST_F(BridgeGraphWrapperTest, CycleDetectedThroughBridge) {
   auto *nodeA = graph->addNode(std::make_unique<MockNode>());
   auto *nodeB = graph->addNode(std::make_unique<MockNode>());
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+  auto *param = createParam();
 
   // A → B (regular edge)
   ASSERT_TRUE(graph->addEdge(nodeA, nodeB).is_ok());
 
-  // Now try B →(param)→ A — this would create: B → bridge → A
-  // Combined with A → B, this creates cycle: A → B → bridge → A
-  auto result = graph->connectParam(nodeB, nodeA, fakeParam);
+  // Create bridge for nodeA's param (bridge → nodeA)
+  auto *bridge = createParamBridge(param, nodeA);
+
+  // Try B → bridge — combined with bridge → A and A → B creates cycle
+  auto result = graph->addEdge(nodeB, bridge);
   EXPECT_TRUE(result.is_err());
   EXPECT_EQ(result.unwrap_err(), HostGraph::ResultError::CYCLE_DETECTED);
 }
 
-TEST_F(BridgeGraphWrapperTest, OwnerRemovalCascadesBridgeCleanup) {
+TEST_F(BridgeGraphWrapperTest, BridgeRemovalWhenParamDestroyed) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
   auto *owner = graph->addNode(std::make_unique<MockNode>());
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+  auto *param = createParam();
+  auto *bridge = createParamBridge(param, owner);
 
-  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  ASSERT_TRUE(graph->addEdge(source, bridge).is_ok());
   processAll();
 
-  // Remove owner — should cascade remove the bridge
-  ASSERT_TRUE(graph->removeNodeWithBridges(owner).is_ok());
+  // Simulate AudioParamHostObject destruction:
+  // First remove all edges to/from bridge, then remove bridge node
+  ASSERT_TRUE(graph->removeEdge(source, bridge).is_ok());
+  ASSERT_TRUE(graph->removeEdge(bridge, owner).is_ok());
+  ASSERT_TRUE(graph->removeNode(bridge).is_ok());
   processAll();
 
-  // Only source should remain as processable
+  // Bridge should be compacted away (orphaned + no inputs)
   size_t iterCount = 0;
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  EXPECT_EQ(iterCount, 1u);
+  EXPECT_EQ(iterCount, 2u); // source + owner
 }
 
-TEST_F(BridgeGraphWrapperTest, SourceRemovalCascadesBridgeCleanup) {
-  auto *source = graph->addNode(std::make_unique<MockNode>());
+TEST_F(BridgeGraphWrapperTest, MultipleSourcesConnectToSameBridge) {
+  auto *source1 = graph->addNode(std::make_unique<MockNode>());
+  auto *source2 = graph->addNode(std::make_unique<MockNode>());
   auto *owner = graph->addNode(std::make_unique<MockNode>());
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x1234);
+  auto *param = createParam();
+  auto *bridge = createParamBridge(param, owner);
 
-  ASSERT_TRUE(graph->connectParam(source, owner, fakeParam).is_ok());
+  ASSERT_TRUE(graph->addEdge(source1, bridge).is_ok());
+  ASSERT_TRUE(graph->addEdge(source2, bridge).is_ok());
   processAll();
 
-  // Remove source — should cascade remove the bridge
-  ASSERT_TRUE(graph->removeNodeWithBridges(source).is_ok());
-  processAll();
-
-  // Only owner should remain as processable
+  // Should have 4 nodes: source1, source2, bridge, owner
   size_t iterCount = 0;
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  EXPECT_EQ(iterCount, 1u);
-}
-
-TEST_F(BridgeGraphWrapperTest, MultipleBridgesFromSameSource) {
-  auto *source = graph->addNode(std::make_unique<MockNode>());
-  auto *ownerA = graph->addNode(std::make_unique<MockNode>());
-  auto *ownerB = graph->addNode(std::make_unique<MockNode>());
-  auto *paramA = reinterpret_cast<AudioParam *>(0xA);
-  auto *paramB = reinterpret_cast<AudioParam *>(0xB);
+  EXPECT_EQ(iterCount, 4u);
 
-  ASSERT_TRUE(graph->connectParam(source, ownerA, paramA).is_ok());
-  ASSERT_TRUE(graph->connectParam(source, ownerB, paramB).is_ok());
+  // Disconnect one source
+  ASSERT_TRUE(graph->removeEdge(source1, bridge).is_ok());
   processAll();
 
-  // Disconnect one
-  ASSERT_TRUE(graph->disconnectParam(source, ownerA, paramA).is_ok());
-  processAll();
-
-  // Other bridge should still exist (source → bridge → ownerB)
-  // Disconnected bridge should be compacted away
-
-  // Connect again should work
-  ASSERT_TRUE(graph->connectParam(source, ownerA, paramA).is_ok());
-  processAll();
+  // Still 4 nodes
+  iterCount = 0;
+  for (auto &&[graphObject, inputs] : graph->iter()) {
+    iterCount++;
+  }
+  EXPECT_EQ(iterCount, 4u);
 }
 
 TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
@@ -473,16 +477,20 @@ TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
 
   auto *source = sharedGraph->addNode(std::make_unique<ProcessableMockNode>(nullptr, 10));
   auto *owner = sharedGraph->addNode(std::make_unique<ProcessableMockNode>(nullptr, 20));
-  auto *fakeParam = reinterpret_cast<AudioParam *>(0x42);
+  auto *param = createParam();
 
-  ASSERT_TRUE(sharedGraph->connectParam(source, owner, fakeParam).is_ok());
+  // Create bridge and connect
+  auto *bridge = sharedGraph->addNode(std::make_unique<BridgeNode>(param));
+  ASSERT_TRUE(sharedGraph->addEdge(bridge, owner).is_ok());
+  ASSERT_TRUE(sharedGraph->addEdge(source, bridge).is_ok());
 
   // Let processor run a few cycles
   while (processor.cyclesCompleted() < 10) {
     std::this_thread::yield();
   }
 
-  ASSERT_TRUE(sharedGraph->disconnectParam(source, owner, fakeParam).is_ok());
+  // Disconnect source from bridge
+  ASSERT_TRUE(sharedGraph->removeEdge(source, bridge).is_ok());
 
   while (processor.cyclesCompleted() < 20) {
     std::this_thread::yield();
@@ -493,7 +501,7 @@ TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
 }
 
 // =========================================================================
-// F. Fuzz test extension with connectParam/disconnectParam
+// F. Fuzz test with bridge nodes
 // =========================================================================
 
 class BridgeFuzzTest : public ::testing::TestWithParam<uint64_t> {
@@ -505,15 +513,18 @@ class BridgeFuzzTest : public ::testing::TestWithParam<uint64_t> {
   std::shared_ptr<Graph> graph;
   std::mt19937_64 rng;
   std::vector<HNode *> liveNodes;
-  std::vector<AudioParam *> fakeParams;
+  std::vector<HNode *> bridgeNodes;
+  std::vector<std::shared_ptr<AudioParam>> params_; // Real params
+  std::vector<AudioParam *> paramPtrs_;             // Raw pointers for test use
 
   void SetUp() override {
     graph = std::make_shared<Graph>(4096, &disposer_);
     rng.seed(GetParam());
 
-    // Create a set of fake param pointers
+    // Create real AudioParam objects for testing
     for (int i = 1; i <= 8; i++) {
-      fakeParams.push_back(reinterpret_cast<AudioParam *>(static_cast<uintptr_t>(i * 0x100)));
+      params_.push_back(createMockAudioParam());
+      paramPtrs_.push_back(params_.back().get());
     }
   }
 
@@ -528,8 +539,14 @@ class BridgeFuzzTest : public ::testing::TestWithParam<uint64_t> {
     return liveNodes[std::uniform_int_distribution<size_t>(0, liveNodes.size() - 1)(rng)];
   }
 
+  HNode *pickBridge() {
+    if (bridgeNodes.empty())
+      return nullptr;
+    return bridgeNodes[std::uniform_int_distribution<size_t>(0, bridgeNodes.size() - 1)(rng)];
+  }
+
   AudioParam *pickParam() {
-    return fakeParams[std::uniform_int_distribution<size_t>(0, fakeParams.size() - 1)(rng)];
+    return paramPtrs_[std::uniform_int_distribution<size_t>(0, paramPtrs_.size() - 1)(rng)];
   }
 };
 
@@ -558,31 +575,49 @@ TEST_P(BridgeFuzzTest, RandomParamOps) {
         (void)graph->addEdge(a, b);
       }
 
-    } else if (op < 40) {
-      // Connect param
-      auto *source = pickRandom();
+    } else if (op < 35) {
+      // Create bridge for a param and connect to owner
       auto *owner = pickRandom();
-      if (source && owner && source != owner) {
-        (void)graph->connectParam(source, owner, pickParam());
+      if (owner) {
+        auto *bridge = graph->addNode(std::make_unique<BridgeNode>(pickParam()));
+        (void)graph->addEdge(bridge, owner);
+        bridgeNodes.push_back(bridge);
       }
 
-    } else if (op < 55) {
-      // Disconnect param
+    } else if (op < 50) {
+      // Connect source to bridge
       auto *source = pickRandom();
-      auto *owner = pickRandom();
-      if (source && owner) {
-        (void)graph->disconnectParam(source, owner, pickParam());
+      auto *bridge = pickBridge();
+      if (source && bridge) {
+        (void)graph->addEdge(source, bridge);
+      }
+
+    } else if (op < 60) {
+      // Disconnect source from bridge
+      auto *source = pickRandom();
+      auto *bridge = pickBridge();
+      if (source && bridge) {
+        (void)graph->removeEdge(source, bridge);
       }
 
     } else if (op < 70) {
-      // Remove node with bridges
+      // Remove bridge node (simulating param destruction)
+      auto *bridge = pickBridge();
+      if (bridge) {
+        (void)graph->removeNode(bridge);
+        bridgeNodes.erase(
+            std::remove(bridgeNodes.begin(), bridgeNodes.end(), bridge), bridgeNodes.end());
+      }
+
+    } else if (op < 80) {
+      // Remove regular node
       auto *n = pickRandom();
       if (n) {
-        (void)graph->removeNodeWithBridges(n);
+        (void)graph->removeNode(n);
         liveNodes.erase(std::remove(liveNodes.begin(), liveNodes.end(), n), liveNodes.end());
       }
 
-    } else if (op < 85) {
+    } else if (op < 90) {
       // Remove regular edge
       auto *a = pickRandom();
       auto *b = pickRandom();
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
index 5adc29544..7dff487d5 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
@@ -6,6 +6,7 @@
 #endif
 
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
@@ -36,6 +37,13 @@ inline std::shared_ptr<BaseAudioContext> getGraphTestContext() {
   return context;
 }
 
+// ── MockAudioParam ────────────────────────────────────────────────────────
+// Real AudioParam for use in graph tests that need valid param pointers.
+
+inline std::shared_ptr<AudioParam> createMockAudioParam() {
+  return std::make_shared<AudioParam>(0.0f, -1.0f, 1.0f, getGraphTestContext());
+}
+
 struct MockNode : AudioNode {
   explicit MockNode(bool destructible = true)
       : AudioNode(getGraphTestContext()), destructible_(destructible) {}

From a7a0fc461b70ae52a40ee3b84a91e4aa4d6b1faa Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Mon, 30 Mar 2026 08:34:29 +0200
Subject: [PATCH 22/38] ci: yarn format

---
 .../common/cpp/audioapi/core/AudioNode.h                     | 5 +++--
 .../common/cpp/audioapi/core/effects/StereoPannerNode.cpp    | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 96f97ead6..ec25d95ea 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -21,8 +21,9 @@ class AudioParam;
 
 class AudioNode : public utils::graph::GraphObject, public std::enable_shared_from_this<AudioNode> {
  public:
-  explicit AudioNode(const std::shared_ptr<BaseAudioContext> &context,
-                     const AudioNodeOptions &options = AudioNodeOptions());
+  explicit AudioNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioNodeOptions &options = AudioNodeOptions());
   ~AudioNode() override = default;
   DELETE_COPY_AND_MOVE(AudioNode);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
index d4d3f16ab..58ea85519 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.cpp
@@ -34,7 +34,7 @@ void StereoPannerNode::processNode(int framesToProcess) {
   if (context == nullptr) {
     return;
   }
-  
+
   double time = context->getCurrentTime();
   double deltaTime = 1.0 / context->getSampleRate();
 

From 43a73959a5829bc883cea89c8ccda3feeb52f687 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Mon, 30 Mar 2026 09:51:06 +0200
Subject: [PATCH 23/38] fix: fixed removeAllEdges

---
 .../cpp/audioapi/core/utils/graph/HostGraph.hpp  | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
index 0a3fcdfce..6cbf0d074 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
@@ -41,7 +41,7 @@ class HostGraph {
   };
 
   /// Size of the Disposer payload (= sizeof(std::shared_ptr<T[]>)).
-  static constexpr size_t kDisposerPayloadSize = 16;
+  static constexpr size_t kDisposerPayloadSize = 24;
 
   /// Event that modifies AudioGraph to keep it consistent with HostGraph.
   /// The second argument is the Disposer used to offload buffer deallocation.
@@ -217,8 +217,9 @@ inline auto HostGraph::addEdge(Node *from, Node *to) -> Res {
   }
 
   for (Node *out : from->outputs) {
-    if (out == to)
+    if (out == to) {
       return Res::Err(ResultError::EDGE_ALREADY_EXISTS);
+    }
   }
 
   if (hasPath(to, from)) {
@@ -267,8 +268,8 @@ inline auto HostGraph::removeAllEdges(Node *from) -> Res {
     return Res::Err(ResultError::NODE_NOT_FOUND);
   }
 
-  auto pairs = std::make_shared<std::vector<std::pair<std::uint32_t, std::uint32_t>>>();
-  pairs->reserve(from->outputs.size());
+  auto pairs = std::vector<std::pair<std::uint32_t, std::uint32_t>>();
+  pairs.reserve(from->outputs.size());
 
   for (Node *to : from->outputs) {
     auto itIn = std::find(to->inputs.begin(), to->inputs.end(), from);
@@ -276,15 +277,16 @@ inline auto HostGraph::removeAllEdges(Node *from) -> Res {
       to->inputs.erase(itIn);
     }
     edgeCount_--;
-    pairs->emplace_back(from->handle->index, to->handle->index);
+    pairs.emplace_back(from->handle->index, to->handle->index);
   }
   from->outputs.clear();
 
-  return Res::Ok([pairs = std::move(pairs)](AudioGraph &graph, auto &) {
-    for (auto &[fromIdx, toIdx] : *pairs) {
+  return Res::Ok([pairs = std::move(pairs)](AudioGraph &graph, auto &disposer) mutable {
+    for (const auto &[fromIdx, toIdx] : pairs) {
       graph.pool().remove(graph[toIdx].input_head, fromIdx);
     }
     graph.markDirty();
+    disposer.dispose(std::move(pairs));
   });
 }
 

From 2952e5ee220005ba9e9d919e78d2a8b329c42eed Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 08:18:35 +0200
Subject: [PATCH 24/38] refactor: cleanup

---
 apps/fabric-example/ios/Podfile.lock          |  6 ++--
 .../HostObjects/AudioParamHostObject.cpp      |  4 +--
 .../common/cpp/audioapi/core/AudioParam.h     | 11 +------
 .../cpp/audioapi/core/BaseAudioContext.h      |  4 +--
 .../audioapi/core/effects/StereoPannerNode.h  |  3 +-
 .../cpp/audioapi/core/utils/Constants.h       |  3 ++
 .../audioapi/core/utils/graph/AudioGraph.hpp  | 28 ++++++++++------
 .../audioapi/core/utils/graph/BridgeNode.cpp  | 32 -------------------
 .../audioapi/core/utils/graph/BridgeNode.hpp  | 18 +++++++++--
 .../cpp/audioapi/core/utils/graph/Graph.hpp   | 23 ++++++-------
 .../audioapi/core/utils/graph/GraphObject.hpp |  7 ++--
 .../audioapi/core/utils/graph/HostGraph.hpp   |  6 ++--
 .../cpp/test/src/graph/AudioGraphFuzzTest.cpp |  4 +--
 .../cpp/test/src/graph/AudioGraphTest.cpp     |  2 +-
 .../cpp/test/src/graph/BridgeNodeTest.cpp     |  8 ++---
 .../test/src/graph/GraphCycleDebugTest.cpp    |  2 +-
 .../cpp/test/src/graph/GraphFuzzTest.cpp      |  5 +--
 .../common/cpp/test/src/graph/GraphTest.cpp   |  3 +-
 .../cpp/test/src/graph/HostGraphTest.cpp      |  3 +-
 19 files changed, 72 insertions(+), 100 deletions(-)
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp

diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 0ff51c1dc..a344b24dc 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2514,7 +2514,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: e97c19a5a442429d1988f182a1940fb08df514da
-  hermes-engine: 471e81260adadffc041e40c5eea01333addabb53
+  hermes-engine: ca0c1d4fe0200e05fedd8d7c0c283b54cd461436
   RCTDeprecation: af44b104091a34482596cd9bd7e8d90c4e9b4bd7
   RCTRequired: bb77b070f75f53398ce43c0aaaa58337cebe2bf6
   RCTSwiftUI: afc0a0a635860da1040a0b894bfd529da06d7810
@@ -2523,7 +2523,7 @@ SPEC CHECKSUMS:
   React: 1ba7d364ade7d883a1ec055bfc3606f35fdee17b
   React-callinvoker: bc2a26f8d84fb01f003fc6de6c9337b64715f95b
   React-Core: 7840d3a80b43a95c5e80ef75146bd70925ebab0f
-  React-Core-prebuilt: 6586031f606ff8ab466cac9e8284053a91342881
+  React-Core-prebuilt: e44365cf4785c3aa56ababc9ab204fe8bc6b17d0
   React-CoreModules: 2eb010400b63b89e53a324ffb3c112e4c7c3ce42
   React-cxxreact: a558e92199d26f145afa9e62c4233cf8e7950efe
   React-debug: 755200a6e7f5e6e0a40ff8d215493d43cce285fc
@@ -2587,7 +2587,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: e96e93b493d8d86eeaee3e590ba0be53f6abe46f
   ReactCodegen: f66521b131699d6af0790f10653933b3f1f79a6f
   ReactCommon: 07572bf9e687c8a52fbe4a3641e9e3a1a477c78e
-  ReactNativeDependencies: a5d71d95f2654107eb45e6ece04caba36beac2bd
+  ReactNativeDependencies: 3467a1fea6f7a524df13b30430bebcc254d9aee2
   RNAudioAPI: fa5c075d2fcdb1ad9a695754b38f07c8c3074396
   RNGestureHandler: 07de6f059e0ee5744ae9a56feb07ee345338cc31
   RNReanimated: d75c81956bf7531fe08ba4390149002ab8bdd127
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
index e743e390b..833b3d82a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
@@ -44,9 +44,7 @@ AudioParamHostObject::AudioParamHostObject(
 }
 
 AudioParamHostObject::~AudioParamHostObject() {
-  if (graph_ && bridgeNode_) {
-    // Remove outgoing edges (bridge → owner)
-    (void)graph_->removeAllEdges(bridgeNode_);
+  if (graph_ && bridgeNode_ != nullptr) {
     // Remove the bridge node itself
     (void)graph_->removeNode(bridgeNode_);
     bridgeNode_ = nullptr;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
index 28d1d7c98..3c918a006 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h
@@ -66,9 +66,7 @@ class AudioParam {
   /// @note Audio Thread only
   void cancelAndHoldAtTime(double cancelTime);
 
-  template <
-      typename F,
-      typename = std::enable_if_t<std::is_invocable_r_v<void, std::decay_t<F>, BaseAudioContext &>>>
+  template <typename F>
   bool scheduleAudioEvent(F &&event) noexcept {
     if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
       return context->scheduleAudioEvent(std::forward<F>(event));
@@ -86,13 +84,6 @@ class AudioParam {
     return inputBuffer_;
   }
 
-  /// @brief Called when a BridgeNode connected to this param is being destroyed.
-  /// Clears the input buffer so the param no longer relies on stale bridge data.
-  /// @note Audio Thread only
-  void onBridgeDetached() {
-    inputBuffer_->zero();
-  }
-
   /// @note Audio Thread only
   std::shared_ptr<DSPAudioBuffer> processARateParam(int framesToProcess, double time);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 6266386c5..00a538e91 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -50,7 +50,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<utils::graph::Graph> getGraph() const;
   std::shared_ptr<IAudioEventHandlerRegistry> getAudioEventHandlerRegistry() const;
   const RuntimeRegistry &getRuntimeRegistry() const;
-  utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *getDisposer() const;
+  utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *getDisposer() const;
 
   /// @brief Assigns the audio destination node to the context.
   /// @param destination The audio destination node to be associated with the context.
@@ -92,7 +92,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
 
-  std::unique_ptr<utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize>> disposer_;
+  std::unique_ptr<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>> disposer_;
   std::shared_ptr<utils::graph::Graph> graph_;
 
   [[nodiscard]] virtual bool isDriverRunning() const = 0;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
index 5dd328f24..3da3d7555 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
@@ -18,8 +18,7 @@ class StereoPannerNode : public AudioNode {
       const StereoPannerOptions &options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getPanParam() const;
-
-  std::shared_ptr<DSPAudioBuffer> getOutputBuffer() const override;
+  [[nodiscard]] std::shared_ptr<DSPAudioBuffer> getOutputBuffer() const override;
 
  protected:
   void processNode(int framesToProcess) override;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
index 1d6897af0..7f411308a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/Constants.h
@@ -36,6 +36,9 @@ inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;
 inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE = 32;
 inline constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_QUEUE_SIZE = 32;
 
+// Disposer payload size (= sizeof(std::vector<T>))
+inline constexpr size_t DISPOSER_PAYLOAD_SIZE = 24;
+
 // Cache line size
 #ifdef __cpp_lib_hardware_interference_size
 using std::hardware_constructive_interference_size;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
index d5d03aff8..b3f712573 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/graph/InputPool.hpp>
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
 
@@ -223,8 +225,6 @@ inline void AudioGraph::process() {
     if (node.orphaned && InputPool::isEmpty(node.input_head) &&
         node.handle->audioNode->canBeDestructed()) {
       node.will_be_deleted = true;
-      // Call beforeDestruction while node is still valid (before move/compaction)
-      node.handle->audioNode->beforeDestruction();
     }
   }
 
@@ -242,8 +242,9 @@ inline void AudioGraph::process() {
   // Must happen BEFORE shifting nodes, because shifting invalidates source
   // positions that later nodes' inputs may still reference.
   for (std::uint32_t e = 0; e < n; e++) {
-    if (nodes[e].will_be_deleted)
+    if (nodes[e].will_be_deleted) {
       continue;
+    }
     for (auto &inp : pool_.mutableView(nodes[e].input_head)) {
       inp = static_cast<std::uint32_t>(nodes[inp].after_compaction_ind);
     }
@@ -252,8 +253,9 @@ inline void AudioGraph::process() {
   // ── Pass 2b: compact — shift kept nodes left ───────────────────────────
   std::uint32_t b = 0;
   for (std::uint32_t e = 0; e < n; e++) {
-    if (nodes[e].will_be_deleted)
+    if (nodes[e].will_be_deleted) {
       continue;
+    }
     if (b != e) {
       nodes[b] = std::move(nodes[e]);
       nodes[e].input_head = InputPool::kNull; // prevent double-free in truncation
@@ -283,13 +285,15 @@ inline void AudioGraph::process() {
 
 inline void AudioGraph::kahn_toposort() {
   const auto n = static_cast<std::uint32_t>(nodes.size());
-  if (n <= 1)
+  if (n <= 1) {
     return;
+  }
 
   // Phase 1: compute out-degree
   for (const auto &nd : nodes) {
-    for (std::uint32_t inp : pool_.view(nd.input_head))
+    for (std::uint32_t inp : pool_.view(nd.input_head)) {
       nodes[inp].topo_out_degree++;
+    }
   }
 
   // Phase 2: reverse Kahn BFS — sinks first, sources last in dequeue order.
@@ -306,8 +310,9 @@ inline void AudioGraph::kahn_toposort() {
   };
 
   for (std::uint32_t i = 0; i < n; i++) {
-    if (nodes[i].topo_out_degree == 0)
+    if (nodes[i].topo_out_degree == 0) {
       enq(i);
+    }
   }
 
   std::uint32_t write = n;
@@ -317,15 +322,17 @@ inline void AudioGraph::kahn_toposort() {
     nodes[idx].after_compaction_ind = static_cast<std::int32_t>(--write);
 
     for (std::uint32_t inp : pool_.view(nodes[idx].input_head)) {
-      if (--nodes[inp].topo_out_degree == 0)
+      if (--nodes[inp].topo_out_degree == 0) {
         enq(inp);
+      }
     }
   }
 
   // Phase 3: remap input indices to new positions (before nodes move)
   for (auto &nd : nodes) {
-    for (std::uint32_t &inp : pool_.mutableView(nd.input_head))
+    for (std::uint32_t &inp : pool_.mutableView(nd.input_head)) {
       inp = static_cast<std::uint32_t>(nodes[inp].after_compaction_ind);
+    }
   }
 
   // Phase 4: apply permutation in place via cycle sort
@@ -338,8 +345,9 @@ inline void AudioGraph::kahn_toposort() {
 
   // Phase 5: update handle indices & reset scratch
   for (std::uint32_t i = 0; i < n; i++) {
-    if (nodes[i].handle)
+    if (nodes[i].handle) {
       nodes[i].handle->index = i;
+    }
     nodes[i].after_compaction_ind = -1;
   }
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
deleted file mode 100644
index ff4620269..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <audioapi/core/AudioParam.h>
-#include <audioapi/core/types/ChannelInterpretation.h>
-#include <audioapi/core/utils/graph/BridgeNode.hpp>
-#include <audioapi/utils/AudioBuffer.hpp>
-
-#include <vector>
-
-namespace audioapi::utils::graph {
-
-void BridgeNode::beforeDestruction() {
-  // Notify AudioParam that it should no longer rely on bridge input
-  if (param_ != nullptr) {
-    param_->onBridgeDetached();
-  }
-}
-
-void BridgeNode::processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) {
-  // Skip processing if param is null (e.g., in tests)
-  if (param_ == nullptr) {
-    return;
-  }
-
-  // Get AudioParam's input buffer and fill it with mixed inputs
-  auto inputBuffer = param_->getInputBuffer();
-  inputBuffer->zero();
-
-  for (const DSPAudioBuffer *input : inputs) {
-    inputBuffer->sum(*input, ChannelInterpretation::SPEAKERS);
-  }
-}
-
-} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
index 6fcbea67b..daa754581 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/AudioParam.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/graph/GraphObject.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
@@ -34,8 +35,6 @@ class BridgeNode final : public GraphObject {
  public:
   explicit BridgeNode(AudioParam *param) : param_(param) {}
 
-  void beforeDestruction() override;
-
   [[nodiscard]] bool isProcessable() const override {
     return true;
   }
@@ -55,7 +54,20 @@ class BridgeNode final : public GraphObject {
   }
 
  protected:
-  void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override;
+  void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override {
+    // Skip processing if param is null (e.g., in tests)
+    if (param_ == nullptr) {
+      return;
+    }
+
+    // Get AudioParam's input buffer and fill it with mixed inputs
+    auto inputBuffer = param_->getInputBuffer();
+    inputBuffer->zero();
+
+    for (const DSPAudioBuffer *input : inputs) {
+      inputBuffer->sum(*input, ChannelInterpretation::SPEAKERS);
+    }
+  }
 
  private:
   AudioParam *param_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index ec58a618e..5590c2461 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -49,11 +49,11 @@ class Graph {
   using HNode = HostGraph::Node;
 
  public:
-  static constexpr size_t kDisposerPayloadSize = HostGraph::kDisposerPayloadSize;
   using ResultError = HostGraph::ResultError;
   using Res = Result<NoneType, ResultError>;
 
-  Graph(size_t eventQueueCapacity, Disposer<kDisposerPayloadSize> *disposer) : disposer_(disposer) {
+  Graph(size_t eventQueueCapacity, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer)
+      : disposer_(disposer) {
     using namespace audioapi::channels::spsc;
 
     auto [es, er] = channel<AGEvent, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::BUSY_LOOP>(
@@ -64,7 +64,7 @@ class Graph {
 
   Graph(
       size_t eventQueueCapacity,
-      Disposer<kDisposerPayloadSize> *disposer,
+      Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer,
       std::uint32_t initialNodeCapacity,
       std::uint32_t initialEdgeCapacity)
       : Graph(eventQueueCapacity, disposer) {
@@ -190,7 +190,7 @@ class Graph {
 
   // ── Disposer — destroys old pool buffers off the audio thread ───────────
 
-  Disposer<kDisposerPayloadSize> *disposer_;
+  Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer_;
 
   // ── Main-thread tracking for pre-growth ─────────────────────────────────
 
@@ -209,13 +209,14 @@ class Graph {
     if (edges > poolCapacity_ / 2) {
       std::uint32_t newCap = std::max(static_cast<std::uint32_t>(edges * 2), std::uint32_t{64});
       auto buf = std::make_unique<InputPool::Slot[]>(newCap);
-      eventSender_.send([buf = std::move(buf), newCap](
-                            AudioGraph &graph, Disposer<kDisposerPayloadSize> &disposer) mutable {
-        auto *old = graph.pool().adoptBuffer(buf.release(), newCap);
-        if (old) {
-          disposer.dispose(OwnedSlotBuffer(old));
-        }
-      });
+      eventSender_.send(
+          [buf = std::move(buf), newCap](
+              AudioGraph &graph, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &disposer) mutable {
+            auto *old = graph.pool().adoptBuffer(buf.release(), newCap);
+            if (old) {
+              disposer.dispose(OwnedSlotBuffer(old));
+            }
+          });
       poolCapacity_ = newCap;
     }
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
index 61bafc2eb..02e787bbe 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/utils/AudioBuffer.hpp>
+#include <audioapi/utils/Macros.h>
 
 #include <ranges>
 #include <vector>
@@ -29,11 +30,9 @@ namespace audioapi::utils::graph {
 /// - `getOutput()` returns the output buffer; nullptr means not mixable as input
 class GraphObject {
  public:
+  GraphObject() = default;
   virtual ~GraphObject() = default;
-
-  /// @brief Called before destruction to allow cleanup or state updates.
-  /// @note called on the audio thread just before letting the object go
-  virtual void beforeDestruction() {}
+  DELETE_COPY_AND_MOVE(GraphObject);
 
   /// @brief Returns whether this graph object can be safely destroyed.
   [[nodiscard]] virtual bool canBeDestructed() const {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
index 6cbf0d074..2d1201748 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Disposer.hpp>
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
@@ -40,12 +41,9 @@ class HostGraph {
     EDGE_ALREADY_EXISTS,
   };
 
-  /// Size of the Disposer payload (= sizeof(std::shared_ptr<T[]>)).
-  static constexpr size_t kDisposerPayloadSize = 24;
-
   /// Event that modifies AudioGraph to keep it consistent with HostGraph.
   /// The second argument is the Disposer used to offload buffer deallocation.
-  using AGEvent = FatFunction<32, void(AudioGraph &, Disposer<kDisposerPayloadSize> &)>;
+  using AGEvent = FatFunction<32, void(AudioGraph &, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &)>;
 
   using Res = Result<AGEvent, ResultError>;
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
index 8e679116e..602aa166e 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
@@ -3,14 +3,13 @@
 #include <gtest/gtest.h>
 #include "TestGraphUtils.h"
 
-#include <algorithm>
 #include <iostream>
-#include <memory>
 #include <random>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
+#include <memory>
 
 namespace audioapi::utils::graph {
 
@@ -25,6 +24,7 @@ class AudioGraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
  protected:
   using MNode = MockNode;
 
+  DisposerImpl<audioapi::DISPOSER_PAYLOAD_SIZE> disposer_{64};
   AudioGraph graph;
   std::mt19937_64 rng;
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
index e21c32b47..47a5165af 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
@@ -1,7 +1,6 @@
 #include <audioapi/core/utils/graph/AudioGraph.hpp>
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
 #include <gtest/gtest.h>
-#include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ -14,6 +13,7 @@ namespace audioapi::utils::graph {
 // ---------------------------------------------------------------------------
 class AudioGraphTest : public ::testing::Test {
  protected:
+  DisposerImpl<audioapi::DISPOSER_PAYLOAD_SIZE> disposer_{64};
   AudioGraph graph;
 
   // Helpers ----------------------------------------------------------------
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
index 47b50c0b3..dd7ef74d2 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
@@ -54,7 +54,7 @@ class BridgeGraphTest : public ::testing::Test {
  protected:
   using HNode = HostGraph::Node;
   using AGEvent = HostGraph::AGEvent;
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
 
   AudioGraph audioGraph;
   HostGraph hostGraph;
@@ -162,7 +162,7 @@ TEST_F(BridgeGraphTest, DuplicateEdgeRejectionWithBridges) {
 class BridgeIterTest : public ::testing::Test {
  protected:
   using HNode = HostGraph::Node;
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
 
   AudioGraph audioGraph;
   HostGraph hostGraph;
@@ -314,7 +314,7 @@ TEST_F(BridgeGraphTest, BridgeOrphanedAndNoInputsGetsCompacted) {
 class BridgeGraphWrapperTest : public ::testing::Test {
  protected:
   using HNode = HostGraph::Node;
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
   DisposerImpl<kPayloadSize> disposer_{64};
   std::shared_ptr<Graph> graph;
   // Hold real AudioParams to avoid fake pointer crashes
@@ -507,7 +507,7 @@ TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
 class BridgeFuzzTest : public ::testing::TestWithParam<uint64_t> {
  protected:
   using HNode = HostGraph::Node;
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
 
   DisposerImpl<kPayloadSize> disposer_{64};
   std::shared_ptr<Graph> graph;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
index 5b4d18b53..08b3a537a 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
@@ -21,7 +21,7 @@ class GraphCycleDebugTest : public ::testing::TestWithParam<uint64_t> {
   using HNode = HostGraph::Node;
   using AGEvent = HostGraph::AGEvent;
 
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
 
   std::mt19937_64 rng;
   AudioGraph audioGraph;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
index 3ce789910..f1e0810fa 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
@@ -1,7 +1,5 @@
 #include <audioapi/core/utils/graph/Graph.hpp>
 #include <gtest/gtest.h>
-#include <algorithm>
-#include <atomic>
 #include <chrono>
 #include <memory>
 #include <random>
@@ -9,7 +7,6 @@
 #include <thread>
 #include <utility>
 #include <vector>
-#include "AudioThreadGuard.h"
 #include "MockGraphProcessor.h"
 #include "TestGraphUtils.h"
 
@@ -28,7 +25,7 @@ class GraphFuzzTest : public ::testing::TestWithParam<uint64_t> {
   using Res = Graph::Res;
   using ResultError = Graph::ResultError;
 
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
   DisposerImpl<kPayloadSize> disposer_{64};
   std::mt19937_64 rng;
   std::unique_ptr<Graph> graph;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
index db8943cbe..80f3e18ee 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
@@ -4,7 +4,6 @@
 #include <chrono>
 #include <cstdlib>
 #include <memory>
-#include <mutex>
 #include <thread>
 #include <vector>
 #include "TestGraphUtils.h"
@@ -13,7 +12,7 @@ namespace audioapi::utils::graph {
 
 class GraphTest : public ::testing::Test {
  protected:
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
   DisposerImpl<kPayloadSize> disposer_{64};
   std::unique_ptr<Graph> graph;
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
index e2554b355..b11a5002f 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
@@ -4,7 +4,6 @@
 #include <audioapi/core/utils/graph/NodeHandle.hpp>
 #include <gtest/gtest.h>
 #include <memory>
-#include <unordered_map>
 #include <utility>
 #include <vector>
 #include "TestGraphUtils.h"
@@ -13,7 +12,7 @@ namespace audioapi::utils::graph {
 
 class HostGraphTest : public ::testing::Test {
  protected:
-  static constexpr size_t kPayloadSize = HostGraph::kDisposerPayloadSize;
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
   DisposerImpl<kPayloadSize> disposer_{64};
 
   void verifyAddEdge(

From 1888507edd75b85af44d2f5e14c2a7da9f90e835 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 08:42:41 +0200
Subject: [PATCH 25/38] fix: nitpicks

---
 .../common/cpp/audioapi/core/BaseAudioContext.cpp         | 8 +++-----
 .../common/cpp/test/src/graph/AudioGraphFuzzTest.cpp      | 2 +-
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 448c12e4b..459de16fa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -20,8 +20,7 @@ BaseAudioContext::BaseAudioContext(
       runtimeRegistry_(runtimeRegistry),
       audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
       disposer_(
-          std::make_unique<utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize>>(
-              AUDIO_SCHEDULER_CAPACITY)),
+          std::make_unique<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>>(AUDIO_SCHEDULER_CAPACITY)),
       graph_(std::make_shared<utils::graph::Graph>(AUDIO_SCHEDULER_CAPACITY, disposer_.get())) {}
 
 void BaseAudioContext::initialize(const AudioDestinationNode *destination) {
@@ -101,15 +100,14 @@ const RuntimeRegistry &BaseAudioContext::getRuntimeRegistry() const {
   return runtimeRegistry_;
 }
 
-utils::DisposerImpl<utils::graph::Graph::kDisposerPayloadSize> *BaseAudioContext::getDisposer()
-    const {
+utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE> *BaseAudioContext::getDisposer() const {
   return disposer_.get();
 }
 
 void BaseAudioContext::processGraph(DSPAudioBuffer *buffer, int numFrames) {
+  processAudioEvents();
   graph_->processEvents();
   graph_->process();
-  processAudioEvents();
 
   for (auto &&[node, inputs] : graph_->iter()) {
     node.process(inputs, numFrames);
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
index 602aa166e..556ee58ec 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
@@ -4,12 +4,12 @@
 #include "TestGraphUtils.h"
 
 #include <iostream>
+#include <memory>
 #include <random>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
-#include <memory>
 
 namespace audioapi::utils::graph {
 

From 88f506cb66e3eb5277dff2b165cdabe9efc71de1 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 13:54:25 +0200
Subject: [PATCH 26/38] refactor: lazy bridge node creation for
 AudioParamHostObject

---
 .../HostObjects/AudioNodeHostObject.cpp       |  2 +-
 .../HostObjects/AudioParamHostObject.cpp      | 27 +++++++++++--------
 .../HostObjects/AudioParamHostObject.h        | 10 ++++---
 .../src/core/AudioNode.ts                     |  4 +--
 .../react-native-audio-api/src/interfaces.ts  |  7 ++---
 5 files changed, 28 insertions(+), 22 deletions(-)

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
index f2496461b..8aa8e75c8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -66,7 +66,7 @@ JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
     connect(*node);
   } else if (obj.isHostObject<AudioParamHostObject>(runtime)) {
     auto param = obj.getHostObject<AudioParamHostObject>(runtime);
-    // Connect source → bridge (the bridge → owner edge is created at param construction)
+    param->connectToGraph();
     graph_->addEdge(node_, param->bridgeNode());
   }
   return jsi::Value::undefined();
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
index 833b3d82a..9bffb6ca2 100644
--- 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,22 +9,15 @@
 
 namespace audioapi {
 
-AudioParamHostObject::AudioParamHostObject(
-    std::shared_ptr<utils::graph::Graph> graph,
-    HNode *ownerNode,
-    const std::shared_ptr<AudioParam> &param)
+AudioParamHostObject::AudioParamHostObject(std::shared_ptr<utils::graph::Graph> graph,
+                                           HNode *ownerNode,
+                                           const std::shared_ptr<AudioParam> &param)
     : graph_(std::move(graph)),
+      ownerNode_(ownerNode),
       param_(param),
       defaultValue_(param->getDefaultValue()),
       minValue_(param->getMinValue()),
       maxValue_(param->getMaxValue()) {
-  // Create the bridge node in the graph
-  auto bridgeGraphObject = std::make_unique<utils::graph::BridgeNode>(param.get());
-  bridgeNode_ = graph_->addNode(std::move(bridgeGraphObject));
-
-  // Connect bridge → owner so topological sort orders correctly
-  (void)graph_->addEdge(bridgeNode_, ownerNode);
-
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, defaultValue),
@@ -157,4 +150,16 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, cancelAndHoldAtTime) {
   return jsi::Value::undefined();
 }
 
+void AudioParamHostObject::connectToGraph() {
+  if (isConnectedToGraph_ || graph_ == nullptr) {
+    return;
+  }
+
+  auto bridgeGraphObject = std::make_unique<utils::graph::BridgeNode>(param_.get());
+  bridgeNode_ = graph_->addNode(std::move(bridgeGraphObject));
+  // Connect bridge → owner so topological sort orders correctly
+  (void)graph_->addEdge(bridgeNode_, ownerNode_);
+  isConnectedToGraph_ = true;
+}
+
 } // namespace audioapi
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
index efb22ad20..2730cde9f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
@@ -14,9 +14,9 @@ class AudioParam;
 
 /// @brief Host object for AudioParam that owns its BridgeNode.
 ///
-/// When created, a BridgeNode is added to the graph and connected to the
-/// owner node (bridge → owner). Sources connecting to this param connect
-/// to the bridge node (source → bridge).
+/// The BridgeNode is created lazily on the first connectToGraph() call
+/// and connected to the owner node (bridge → owner). Sources connecting
+/// to this param connect to the bridge node (source → bridge).
 ///
 /// When destroyed, the BridgeNode is removed from the graph.
 class AudioParamHostObject : public JsiHostObject {
@@ -54,11 +54,15 @@ class AudioParamHostObject : public JsiHostObject {
     return bridgeNode_;
   }
 
+  void connectToGraph();
+
  private:
   friend class AudioNodeHostObject;
 
   std::shared_ptr<utils::graph::Graph> graph_;
+  HNode *ownerNode_ = nullptr;
   HNode *bridgeNode_ = nullptr;
+  bool isConnectedToGraph_ = false;
   std::shared_ptr<AudioParam> param_;
   float defaultValue_;
   float minValue_;
diff --git a/packages/react-native-audio-api/src/core/AudioNode.ts b/packages/react-native-audio-api/src/core/AudioNode.ts
index 164ecf20c..e11594798 100644
--- a/packages/react-native-audio-api/src/core/AudioNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioNode.ts
@@ -37,7 +37,7 @@ export default class AudioNode {
     }
 
     if (destination instanceof AudioParam) {
-      this.node.connect(destination.audioParam, destination.owner.node);
+      this.node.connect(destination.audioParam);
     } else {
       if (destination.numberOfInputs === 0) {
         throw new IndexSizeError(
@@ -52,7 +52,7 @@ export default class AudioNode {
 
   public disconnect(destination?: AudioNode | AudioParam): void {
     if (destination instanceof AudioParam) {
-      this.node.disconnect(destination.audioParam, destination.owner.node);
+      this.node.disconnect(destination.audioParam);
     } else if (destination) {
       this.node.disconnect(destination.node);
     } else {
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index fe0d4f59a..d94a75169 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -124,11 +124,8 @@ export interface IAudioNode {
   readonly channelCountMode: ChannelCountMode;
   readonly channelInterpretation: ChannelInterpretation;
 
-  connect(destination: IAudioNode): void;
-  connect(destination: IAudioParam, owner: IAudioNode): void;
-  disconnect(): void;
-  disconnect(destination: IAudioNode): void;
-  disconnect(destination: IAudioParam, owner: IAudioNode): void;
+  connect(destination: IAudioNode | IAudioParam): void;
+  disconnect(destination?: IAudioNode | IAudioParam): void;
 }
 
 export interface IDelayNode extends IAudioNode {

From 4db7657dde908b63174cc936a16b79a2c428c8f4 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 15:04:24 +0200
Subject: [PATCH 27/38] refactor: trigger disposing of ghost nodes on context
 state changes

---
 .../HostObjects/AudioContextHostObject.cpp         |  3 +++
 .../audioapi/HostObjects/AudioParamHostObject.cpp  |  8 +++++---
 .../HostObjects/OfflineAudioContextHostObject.cpp  |  2 ++
 .../core/effects/WorkletProcessingNode.cpp         |  1 +
 .../common/cpp/audioapi/core/utils/graph/Graph.hpp | 14 +++++++++-----
 5 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp
index c76067bb7..91dbb34a5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp
@@ -23,6 +23,7 @@ AudioContextHostObject::AudioContextHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
     return [audioContext](jsi::Runtime &runtime) {
@@ -35,6 +36,7 @@ JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
     auto result = audioContext->resume();
@@ -46,6 +48,7 @@ JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext = std::move(audioContext)]() {
     auto result = audioContext->suspend();
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
index 9bffb6ca2..24689e48c 100644
--- 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,9 +9,10 @@
 
 namespace audioapi {
 
-AudioParamHostObject::AudioParamHostObject(std::shared_ptr<utils::graph::Graph> graph,
-                                           HNode *ownerNode,
-                                           const std::shared_ptr<AudioParam> &param)
+AudioParamHostObject::AudioParamHostObject(
+    std::shared_ptr<utils::graph::Graph> graph,
+    HNode *ownerNode,
+    const std::shared_ptr<AudioParam> &param)
     : graph_(std::move(graph)),
       ownerNode_(ownerNode),
       param_(param),
@@ -41,6 +42,7 @@ AudioParamHostObject::~AudioParamHostObject() {
     // Remove the bridge node itself
     (void)graph_->removeNode(bridgeNode_);
     bridgeNode_ = nullptr;
+    ownerNode_ = nullptr;
   }
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp
index ee9fee5ef..189f88f93 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp
@@ -31,6 +31,7 @@ OfflineAudioContextHostObject::OfflineAudioContextHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, resume) {
+  context_->getGraph()->collectDisposedNodes();
   auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
   auto promise = promiseVendor_->createAsyncPromise([audioContext]() {
     audioContext->resume();
@@ -43,6 +44,7 @@ JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, resume) {
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
+  context_->getGraph()->collectDisposedNodes();
   double when = args[0].getNumber();
   auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
index f3c2a47d9..ae974b502 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/WorkletProcessingNode.cpp
@@ -1,5 +1,6 @@
 #include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <algorithm>
 #include <memory>
 #include <utility>
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 5590c2461..586bf80f7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -122,7 +122,7 @@ class Graph {
   /// @param audioNode the audio processing node to add (ownership transferred)
   /// @return pointer to the newly added HostGraph::Node
   HNode *addNode(std::unique_ptr<GraphObject> audioNode = nullptr) {
-    hostGraph.collectDisposedNodes();
+    collectDisposedNodes();
 
     auto handle = std::make_shared<NodeHandle>(0, std::move(audioNode));
     auto [hostNode, event] = hostGraph.addNode(handle);
@@ -141,7 +141,7 @@ class Graph {
   /// @brief Removes a node (marks as ghost). Pointer remains valid until
   /// the ghost is collected after AudioGraph releases its shared_ptr.
   Res removeNode(HNode *node) {
-    hostGraph.collectDisposedNodes();
+    collectDisposedNodes();
     return hostGraph.removeNode(node).map([&](AGEvent event) {
       eventSender_.send(std::move(event));
       return NoneType{};
@@ -150,7 +150,7 @@ class Graph {
 
   /// @brief Adds a directed edge from → to. Rejects cycles and duplicates.
   Res addEdge(HNode *from, HNode *to) {
-    hostGraph.collectDisposedNodes();
+    collectDisposedNodes();
     return hostGraph.addEdge(from, to).map([&](AGEvent event) {
       sendPoolGrowIfNeeded();
       eventSender_.send(std::move(event));
@@ -160,7 +160,7 @@ class Graph {
 
   /// @brief Removes a directed edge from → to.
   Res removeEdge(HNode *from, HNode *to) {
-    hostGraph.collectDisposedNodes();
+    collectDisposedNodes();
     return hostGraph.removeEdge(from, to).map([&](AGEvent event) {
       eventSender_.send(std::move(event));
       return NoneType{};
@@ -169,13 +169,17 @@ class Graph {
 
   /// @brief Removes all outgoing edges from `from`.
   Res removeAllEdges(HNode *from) {
-    hostGraph.collectDisposedNodes();
+    collectDisposedNodes();
     return hostGraph.removeAllEdges(from).map([&](AGEvent event) {
       eventSender_.send(std::move(event));
       return NoneType{};
     });
   }
 
+  void collectDisposedNodes() {
+    hostGraph.collectDisposedNodes();
+  }
+
  private:
   using OwnedSlotBuffer = std::unique_ptr<InputPool::Slot[]>;
 

From f12fb88ab72a84f380f77ce1ee38afebeaabb8e0 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 16:14:41 +0200
Subject: [PATCH 28/38] refactor: bring back recorder connect with recorder
 adapter

---
 .../android/core/AndroidAudioRecorder.cpp     | 17 ++++++------
 .../android/core/AndroidAudioRecorder.h       |  2 +-
 .../inputs/AudioRecorderHostObject.cpp        |  3 +--
 .../cpp/audioapi/core/inputs/AudioRecorder.h  |  6 ++---
 .../ios/audioapi/ios/core/IOSAudioRecorder.h  |  5 ++--
 .../ios/audioapi/ios/core/IOSAudioRecorder.mm | 26 ++++++++++---------
 6 files changed, 30 insertions(+), 29 deletions(-)

diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
index e3d35c337..e3aeae15f 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
@@ -49,7 +49,7 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
 
     if (isConnected()) {
       isConnected_.store(false, std::memory_order_release);
-      adapterNode_->adapterCleanup();
+      static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
     }
   }
 
@@ -143,7 +143,7 @@ Result<std::string, std::string> AndroidAudioRecorder::start(const std::string &
   if (isConnected()) {
     deinterleavingBuffer_ = std::make_shared<AudioBuffer>(
         streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
-    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
+    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
   }
 
   auto result = mStream_->requestStart();
@@ -198,7 +198,7 @@ Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorde
   }
 
   if (isConnected()) {
-    adapterNode_->adapterCleanup();
+    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
   }
 
   filePath_ = "";
@@ -318,14 +318,14 @@ void AndroidAudioRecorder::clearOnAudioReadyCallback() {
 /// If the recorder is already active, it will initialize the adapter node immediately.
 /// This method should be called from the JS thread only.
 /// @param node Shared pointer to the RecorderAdapterNode to connect.
-void AndroidAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
+void AndroidAudioRecorder::connect(const std::shared_ptr<utils::graph::NodeHandle> &node) {
   std::scoped_lock adapterLock(adapterNodeMutex_);
-  adapterNode_ = node;
+  adapterNodeHandle_ = node;
 
   if (!isIdle()) {
     deinterleavingBuffer_ = std::make_shared<AudioBuffer>(
         streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
-    adapterNode_->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
+    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
   }
 
   isConnected_.store(true, std::memory_order_release);
@@ -338,7 +338,7 @@ void AndroidAudioRecorder::disconnect() {
   std::scoped_lock adapterLock(adapterNodeMutex_);
   isConnected_.store(false, std::memory_order_release);
   deinterleavingBuffer_ = nullptr;
-  adapterNode_ = nullptr;
+  adapterNodeHandle_ = nullptr;
 }
 
 /// @brief onAudioReady callback that is invoked by the Oboe stream when new audio data is available.
@@ -376,9 +376,10 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
     if (auto adapterLock = Locker::tryLock(adapterNodeMutex_)) {
       auto const data = static_cast<float *>(audioData);
       deinterleavingBuffer_->deinterleaveFrom(data, numFrames);
+      auto *adapterNode = static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get());
 
       for (size_t ch = 0; ch < streamChannelCount_; ++ch) {
-        adapterNode_->buff_[ch]->write(*deinterleavingBuffer_->getChannel(ch), numFrames);
+        adapterNode->buff_[ch]->write(*deinterleavingBuffer_->getChannel(ch), numFrames);
       }
     }
   }
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
index 4de0b5049..9c82912b2 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
@@ -43,7 +43,7 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback, public AudioRecor
       uint64_t callbackId) override;
   void clearOnAudioReadyCallback() override;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node) override;
+  void connect(const std::shared_ptr<utils::graph::NodeHandle> &node) override;
   void disconnect() override;
 
   oboe::DataCallbackResult
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
index 66bf8ce72..86ca7b93a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
@@ -133,8 +133,7 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
   auto adapterNodeHostObject =
       args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(runtime);
 
-  // TODO
-  // audioRecorder_->connect(adapterNodeHostObject->adapterNode_);
+  audioRecorder_->connect(adapterNodeHostObject->node_->handle);
   return jsi::Value::undefined();
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
index bd725a434..c5b6730be 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <audioapi/core/utils/graph/NodeHandle.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/Result.hpp>
 #include <atomic>
@@ -11,7 +12,6 @@
 namespace audioapi {
 
 class AudioFileWriter;
-class RecorderAdapterNode;
 class AudioFileProperties;
 class AudioRecorderCallback;
 class AudioEventHandlerRegistry;
@@ -38,7 +38,7 @@ class AudioRecorder {
   virtual void pause() = 0;
   virtual void resume() = 0;
 
-  virtual void connect(const std::shared_ptr<RecorderAdapterNode> &node) = 0;
+  virtual void connect(const std::shared_ptr<utils::graph::NodeHandle> &node) = 0;
   virtual void disconnect() = 0;
 
   virtual Result<NoneType, std::string> setOnAudioReadyCallback(
@@ -77,7 +77,7 @@ class AudioRecorder {
 
   std::string filePath_;
   std::shared_ptr<AudioFileWriter> fileWriter_ = nullptr;
-  std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
+  std::shared_ptr<utils::graph::NodeHandle> adapterNodeHandle_ = nullptr;
   std::shared_ptr<AudioRecorderCallback> dataCallback_ = nullptr;
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 };
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
index 9137b9405..4f346022f 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
@@ -10,10 +10,9 @@ typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
 #include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/core/utils/graph/NodeHandle.hpp>
 #include <audioapi/utils/Result.hpp>
 
-#include <mutex>
-
 namespace audioapi {
 
 class FileWriter;
@@ -34,7 +33,7 @@ class IOSAudioRecorder : public AudioRecorder {
       std::shared_ptr<AudioFileProperties> properties) override;
   void disableFileOutput() override;
 
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node) override;
+  void connect(const std::shared_ptr<utils::graph::NodeHandle> &node) override;
   void disconnect() override;
 
   void pause() override;
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
index a8aaea27c..11d9288e2 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
@@ -4,6 +4,7 @@
 #import <Foundation/Foundation.h>
 
 #include <unordered_map>
+#include <mutex>
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/AudioFileWriter.h>
@@ -50,10 +51,10 @@
 
     if (isConnected()) {
       if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
-        for (size_t channel = 0; channel < adapterNode_->getChannelCount(); ++channel) {
-          auto data = (float *)inputBuffer->mBuffers[channel].mData;
-
-          adapterNode_->buff_[channel]->write(data, numFrames);
+        auto *adapterNode = static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get());
+        for (size_t channel = 0; channel < adapterNode->getChannelCount(); ++channel) {
+          auto *data = static_cast<float *>(inputBuffer->mBuffers[channel].mData);
+          adapterNode->buff_[channel]->write(data, numFrames);
         }
       }
     }
@@ -125,7 +126,7 @@
   }
 
   if (isConnected()) {
-    adapterNode_->init(maxInputBufferLength, inputFormat.channelCount, inputFormat.sampleRate);
+    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(maxInputBufferLength, inputFormat.channelCount, inputFormat.sampleRate);
   }
 
   [nativeRecorder_ start];
@@ -170,7 +171,7 @@
   }
 
   if (isConnected()) {
-    adapterNode_->adapterCleanup();
+    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
   }
 
   filePath_ = "";
@@ -219,16 +220,17 @@
 /// If the recorder is already active, it will initialize the adapter node immediately.
 /// This method should be called from the JS thread only.
 /// @param node Shared pointer to the RecorderAdapterNode to connect.
-void IOSAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node)
+void IOSAudioRecorder::connect(const std::shared_ptr<utils::graph::NodeHandle> &node)
 {
   std::scoped_lock lock(adapterNodeMutex_);
-  adapterNode_ = node;
+  adapterNodeHandle_ = node;
 
   if (!isIdle()) {
-    adapterNode_->init(
+    auto inputFormat = [nativeRecorder_ getInputFormat];
+    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(
         [nativeRecorder_ getBufferSize],
-        [nativeRecorder_ getInputFormat].channelCount,
-        [nativeRecorder_ getInputFormat].sampleRate);
+        inputFormat.channelCount,
+        inputFormat.sampleRate);
   }
 
   isConnected_.store(true, std::memory_order_release);
@@ -240,7 +242,7 @@
 void IOSAudioRecorder::disconnect()
 {
   std::scoped_lock lock(adapterNodeMutex_);
-  adapterNode_ = nullptr;
+  adapterNodeHandle_ = nullptr;
   isConnected_.store(false, std::memory_order_release);
 }
 

From a985577a140437514533bb7d3dbcdc72a58b6a75 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 16:15:26 +0200
Subject: [PATCH 29/38] ci: format

---
 .../android/core/AndroidAudioRecorder.cpp         | 12 +++++++-----
 .../ios/audioapi/ios/core/IOSAudioRecorder.mm     | 15 +++++++--------
 2 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
index e3aeae15f..517f12b7f 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
@@ -49,7 +49,7 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
 
     if (isConnected()) {
       isConnected_.store(false, std::memory_order_release);
-      static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
+      static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
     }
   }
 
@@ -143,7 +143,8 @@ Result<std::string, std::string> AndroidAudioRecorder::start(const std::string &
   if (isConnected()) {
     deinterleavingBuffer_ = std::make_shared<AudioBuffer>(
         streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
-    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
   }
 
   auto result = mStream_->requestStart();
@@ -198,7 +199,7 @@ Result<std::tuple<std::string, double, double>, std::string> AndroidAudioRecorde
   }
 
   if (isConnected()) {
-    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
   }
 
   filePath_ = "";
@@ -325,7 +326,8 @@ void AndroidAudioRecorder::connect(const std::shared_ptr<utils::graph::NodeHandl
   if (!isIdle()) {
     deinterleavingBuffer_ = std::make_shared<AudioBuffer>(
         streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
-    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(streamMaxBufferSizeInFrames_, streamChannelCount_, streamSampleRate_);
   }
 
   isConnected_.store(true, std::memory_order_release);
@@ -376,7 +378,7 @@ oboe::DataCallbackResult AndroidAudioRecorder::onAudioReady(
     if (auto adapterLock = Locker::tryLock(adapterNodeMutex_)) {
       auto const data = static_cast<float *>(audioData);
       deinterleavingBuffer_->deinterleaveFrom(data, numFrames);
-      auto *adapterNode = static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get());
+      auto *adapterNode = static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get());
 
       for (size_t ch = 0; ch < streamChannelCount_; ++ch) {
         adapterNode->buff_[ch]->write(*deinterleavingBuffer_->getChannel(ch), numFrames);
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
index 11d9288e2..43b768c72 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
@@ -3,8 +3,8 @@
 #import <AudioSessionManager.h>
 #import <Foundation/Foundation.h>
 
-#include <unordered_map>
 #include <mutex>
+#include <unordered_map>
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/AudioFileWriter.h>
@@ -51,7 +51,7 @@
 
     if (isConnected()) {
       if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
-        auto *adapterNode = static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get());
+        auto *adapterNode = static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get());
         for (size_t channel = 0; channel < adapterNode->getChannelCount(); ++channel) {
           auto *data = static_cast<float *>(inputBuffer->mBuffers[channel].mData);
           adapterNode->buff_[channel]->write(data, numFrames);
@@ -126,7 +126,8 @@
   }
 
   if (isConnected()) {
-    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(maxInputBufferLength, inputFormat.channelCount, inputFormat.sampleRate);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(maxInputBufferLength, inputFormat.channelCount, inputFormat.sampleRate);
   }
 
   [nativeRecorder_ start];
@@ -171,7 +172,7 @@
   }
 
   if (isConnected()) {
-    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())->adapterCleanup();
   }
 
   filePath_ = "";
@@ -227,10 +228,8 @@
 
   if (!isIdle()) {
     auto inputFormat = [nativeRecorder_ getInputFormat];
-    static_cast<RecorderAdapterNode*>(adapterNodeHandle_->audioNode.get())->init(
-        [nativeRecorder_ getBufferSize],
-        inputFormat.channelCount,
-        inputFormat.sampleRate);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init([nativeRecorder_ getBufferSize], inputFormat.channelCount, inputFormat.sampleRate);
   }
 
   isConnected_.store(true, std::memory_order_release);

From d7f53d156b4b1c64084e19ebd57a2a13788d9278 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 31 Mar 2026 16:32:39 +0200
Subject: [PATCH 30/38] refactor: implemented disable() for
 AudioBufferSourceNode to dispose buffer on disable

---
 .../cpp/audioapi/core/sources/AudioBufferSourceNode.cpp  | 9 +++++++++
 .../cpp/audioapi/core/sources/AudioBufferSourceNode.h    | 3 +++
 2 files changed, 12 insertions(+)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index f82c09fca..0ca0fb867 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -93,6 +93,15 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
   vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
 }
 
+void AudioBufferSourceNode::disable() {
+  AudioScheduledSourceNode::disable();
+
+  if (auto context = context_.lock()) {
+    context->getDisposer()->dispose(std::move(buffer_));
+  }
+  buffer_ = nullptr;
+}
+
 void AudioBufferSourceNode::setOnLoopEndedCallbackId(uint64_t callbackId) {
   onLoopEndedCallbackId_ = callbackId;
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h
index 00a3643c7..af8bd4812 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h
@@ -39,6 +39,9 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode {
   /// @note Audio Thread only
   void start(double when, double offset, double duration = -1);
 
+  /// @note Audio Thread only
+  void disable() override;
+
   /// @note Audio Thread only
   void setOnLoopEndedCallbackId(uint64_t callbackId);
 

From cb9d31221af875e5be12184eb9b0d01156047ae0 Mon Sep 17 00:00:00 2001
From: poneciak <poneciak@gmail.com>
Date: Thu, 2 Apr 2026 12:43:31 +0200
Subject: [PATCH 31/38] fix: fixed allocation when adding nodes

---
 .../audioapi/core/utils/graph/AudioGraph.hpp  |  41 ++++++
 .../cpp/audioapi/core/utils/graph/Graph.hpp   |  15 +-
 .../common/cpp/test/RunTestsGraph.sh          |   2 +-
 .../cpp/test/src/graph/AudioThreadGuard.cpp   |  15 ++
 .../cpp/test/src/graph/AudioThreadGuard.h     |   8 ++
 .../test/src/graph/GraphNodeGrowthTest.cpp    | 129 ++++++++++++++++++
 6 files changed, 206 insertions(+), 4 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
index b3f712573..15ba4b5ed 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
@@ -56,6 +56,47 @@ class AudioGraph {
   AudioGraph(AudioGraph &&) noexcept = default;
   AudioGraph &operator=(AudioGraph &&) noexcept = default;
 
+  // ── Node buffer pre-allocation (main-thread → audio-thread handoff) ─────
+
+  /// @brief Opaque pre-allocated node storage.
+  ///
+  /// Created on the main thread via makeNodeBuffer(), then handed to the
+  /// audio thread via adoptNodeBuffer(). The returned (old) buffer must be
+  /// disposed off the audio thread.
+  struct NodeBuffer {
+    std::vector<Node> data;
+    explicit NodeBuffer(std::uint32_t capacity) {
+      data.reserve(capacity);
+    }
+    NodeBuffer() = default;
+  };
+
+  /// @brief Allocates a node buffer with the given capacity on the calling thread.
+  [[nodiscard]] static NodeBuffer makeNodeBuffer(std::uint32_t capacity) {
+    return NodeBuffer(capacity);
+  }
+
+  /// @brief Installs a pre-allocated node buffer on the audio thread.
+  ///
+  /// Moves all live nodes into the pre-allocated buffer (allocation-free:
+  /// capacity was ensured on the main thread), swaps it in, and returns
+  /// the old buffer for disposal off the audio thread.
+  ///
+  /// @note Must be called only from the audio thread.
+  [[nodiscard]] NodeBuffer adoptNodeBuffer(NodeBuffer preAllocated) {
+    // Move live nodes into the pre-allocated (empty, large-capacity) buffer.
+    // No reallocation: preAllocated.data.capacity() >= nodes.size() guaranteed
+    // by the main thread before sending this event.
+    preAllocated.data.insert(
+        preAllocated.data.end(),
+        std::make_move_iterator(nodes.begin()),
+        std::make_move_iterator(nodes.end()));
+    std::swap(nodes, preAllocated.data);
+    // preAllocated.data now holds the old (small) buffer with moved-from nodes.
+    // Caller disposes it off the audio thread.
+    return preAllocated;
+  }
+
   /// @brief Entry returned by iter() — a reference to the graph object and a view of its inputs.
   template <typename InputsView>
   struct Entry {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
index 586bf80f7..050c1450e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
@@ -182,6 +182,7 @@ class Graph {
 
  private:
   using OwnedSlotBuffer = std::unique_ptr<InputPool::Slot[]>;
+  using OwnedNodeBuffer = AudioGraph::NodeBuffer;
 
   // Aligning to cache line size to prevent false sharing between audio and main thread
   alignas(hardware_destructive_interference_size) AudioGraph audioGraph;
@@ -226,13 +227,21 @@ class Graph {
   }
 
   /// @brief Pre-reserves the AudioGraph node vector when node count exceeds
-  /// the last ensured capacity. Queries HostGraph::nodeCount() for the
-  /// current truth. Sends a grow event through the event channel.
+  /// the last ensured capacity. Allocates a new node buffer on the main
+  /// thread and sends it as an AGEvent through the event channel. The old
+  /// buffer is sent to the Disposer for deallocation on a separate thread —
+  /// never on the audio thread.
   void sendNodeGrowIfNeeded() {
     auto nodes = static_cast<std::uint32_t>(hostGraph.nodeCount());
     if (nodes > nodeCapacity_) {
       std::uint32_t newCap = std::max(static_cast<std::uint32_t>(nodes * 2), std::uint32_t{64});
-      eventSender_.send([newCap](AudioGraph &graph, auto &) { graph.reserveNodes(newCap); });
+      auto buf = AudioGraph::makeNodeBuffer(newCap);
+      eventSender_.send(
+          [buf = std::move(buf)](
+              AudioGraph &graph, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &disposer) mutable {
+            auto old = graph.adoptNodeBuffer(std::move(buf));
+            disposer.dispose(std::move(old));
+          });
       nodeCapacity_ = newCap;
     }
   }
diff --git a/packages/react-native-audio-api/common/cpp/test/RunTestsGraph.sh b/packages/react-native-audio-api/common/cpp/test/RunTestsGraph.sh
index 8088a3d09..658fc72c9 100755
--- a/packages/react-native-audio-api/common/cpp/test/RunTestsGraph.sh
+++ b/packages/react-native-audio-api/common/cpp/test/RunTestsGraph.sh
@@ -14,7 +14,7 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 cd "$SCRIPT_DIR"
 
 # Allow override of GRAPH_FILTER via environment variable
-GRAPH_FILTER="${GRAPH_FILTER:-AudioGraphTest.*:AudioGraphFuzzTest.*:GraphTest.*:GraphFuzzTest.*:GraphCycleDebugTest.*:HostGraphTest.*:Seeds/*}"
+GRAPH_FILTER="${GRAPH_FILTER:-AudioGraphTest.*:AudioGraphFuzzTest.*:GraphTest.*:GraphFuzzTest.*:GraphCycleDebugTest.*:HostGraphTest.*:GraphNodeGrowthTest.*:Seeds/*}"
 
 cmake -S . -B build -Wno-dev
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.cpp
index eb2d96d47..e0917f449 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.cpp
@@ -100,6 +100,21 @@ bool AudioThreadGuard::Scope::clean() const {
 #define __has_feature(x) 0
 #endif
 
+#if !defined(__SANITIZE_ADDRESS__) && !defined(__SANITIZE_THREAD__) && \
+    !__has_feature(address_sanitizer) && !__has_feature(thread_sanitizer)
+
+bool audioapi::test::AudioThreadGuard::isEnabled() {
+  return true;
+}
+
+#else
+
+bool audioapi::test::AudioThreadGuard::isEnabled() {
+  return false;
+}
+
+#endif
+
 #if !defined(__SANITIZE_ADDRESS__) && !defined(__SANITIZE_THREAD__) && \
     !__has_feature(address_sanitizer) && !__has_feature(thread_sanitizer)
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.h b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.h
index 332c5c77e..0bce89fc9 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioThreadGuard.h
@@ -54,6 +54,14 @@ class AudioThreadGuard {
   /// Takes a snapshot of context-switch counters.
   static ContextSwitchSnapshot contextSwitches();
 
+  // ── Sanitizer-awareness ─────────────────────────────────────────────────
+
+  /// Returns true if the operator new/delete overrides are active.
+  /// When building with ASan or TSan the overrides are disabled (the
+  /// sanitizer provides its own interceptors), so allocation tracking
+  /// is unavailable and any test relying on it should be skipped.
+  static bool isEnabled();
+
   // ── Internal — called by operator new/delete overrides ──────────────────
 
   static void recordAllocation();
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp
new file mode 100644
index 000000000..4b9325ab8
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp
@@ -0,0 +1,129 @@
+#include <audioapi/core/utils/graph/Graph.hpp>
+#include <gtest/gtest.h>
+#include <chrono>
+#include <memory>
+#include <thread>
+#include <vector>
+#include "AudioThreadGuard.h"
+#include "MockGraphProcessor.h"
+#include "TestGraphUtils.h"
+
+using namespace audioapi::utils::graph;
+using audioapi::test::AudioThreadGuard;
+using audioapi::test::MockGraphProcessor;
+using audioapi::utils::DisposerImpl;
+
+// =========================================================================
+// GraphNodeGrowthTest
+//
+// Verifies the allocation behaviour of sendNodeGrowIfNeeded().
+//
+// The method sends a lambda [newCap](...){ graph.reserveNodes(newCap); }
+// through the SPSC event channel. That lambda is executed by the audio
+// thread inside processEvents() → AudioGraph::reserveNodes() →
+// std::vector::reserve(), which allocates heap memory ON the audio thread.
+//
+// The tests below expose this by running a MockGraphProcessor (audio thread
+// instrumented with AudioThreadGuard) while the main thread adds nodes.
+// =========================================================================
+
+class GraphNodeGrowthTest : public ::testing::Test {
+ protected:
+  using PNode = ProcessableMockNode;
+  using HNode = HostGraph::Node;
+
+  static constexpr size_t kPayloadSize = audioapi::DISPOSER_PAYLOAD_SIZE;
+  DisposerImpl<kPayloadSize> disposer_{64};
+};
+
+// ── Test 1: Node grow events must not allocate on the audio thread ─────────
+//
+// Creates a Graph WITHOUT pre-reserved node capacity (nodeCapacity_ == 0).
+// Adding 1000 nodes triggers multiple sendNodeGrowIfNeeded() calls, each
+// sending a grow event that the audio thread executes inside processEvents().
+//
+// Currently FAILS because the grow event lambda calls reserveNodes() on the
+// audio thread → std::vector::reserve() → heap allocation.
+// The fix: pre-allocate the buffer on the main thread (same pattern as
+// sendPoolGrowIfNeeded) and only hand off the ready buffer via the event.
+TEST_F(GraphNodeGrowthTest, NodeGrowEventsDoNotAllocateOnAudioThread) {
+  if (!audioapi::test::AudioThreadGuard::isEnabled()) {
+    GTEST_SKIP() << "AudioThreadGuard operator new/delete overrides are disabled "
+                    "under ASan/TSan — allocation tracking unavailable";
+  }
+
+  // No initial capacity → nodeCapacity_ = 0, every threshold triggers a grow
+  auto graph = std::make_unique<Graph>(4096, &disposer_);
+
+  MockGraphProcessor<PNode> processor(*graph);
+  processor.start();
+
+  constexpr size_t kNodeCount = 1000;
+  std::vector<HNode *> nodes;
+  nodes.reserve(kNodeCount);
+
+  for (size_t i = 0; i < kNodeCount; ++i) {
+    nodes.push_back(graph->addNode(std::make_unique<PNode>()));
+
+    // Periodic yield so the audio thread can process grow events
+    // while the main thread is still adding nodes.
+    if (i % 50 == 0) {
+      std::this_thread::sleep_for(std::chrono::microseconds(500));
+    }
+  }
+
+  // Drain all pending events
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  processor.stop();
+
+  EXPECT_GT(processor.cyclesCompleted(), 0u)
+      << "Audio thread should have completed at least one cycle";
+
+  EXPECT_TRUE(processor.allocationClean())
+      << "Audio thread allocated " << processor.allocationViolations() << " times across "
+      << processor.cyclesCompleted()
+      << " cycles — sendNodeGrowIfNeeded() must not allocate on the audio thread";
+}
+
+// ── Test 2: Pre-reserved capacity prevents audio-thread allocations ────────
+//
+// When the Graph is constructed with sufficient initial capacity
+// (4-arg constructor), sendNodeGrowIfNeeded() never fires and the audio
+// thread stays allocation-free — even for 1000 nodes.
+// This serves as a control / regression baseline.
+TEST_F(GraphNodeGrowthTest, PreReservedCapacityKeepsAudioThreadAllocationFree) {
+  if (!audioapi::test::AudioThreadGuard::isEnabled()) {
+    GTEST_SKIP() << "AudioThreadGuard operator new/delete overrides are disabled "
+                    "under ASan/TSan — allocation tracking unavailable";
+  }
+
+  constexpr size_t kNodeCount = 1000;
+
+  // Reserve enough upfront so sendNodeGrowIfNeeded() never fires
+  const auto maxNodes = static_cast<std::uint32_t>(kNodeCount + 64);
+  const std::uint32_t maxEdges = 64;
+  auto graph = std::make_unique<Graph>(4096, &disposer_, maxNodes, maxEdges);
+
+  MockGraphProcessor<PNode> processor(*graph);
+  processor.start();
+
+  std::vector<HNode *> nodes;
+  nodes.reserve(kNodeCount);
+
+  for (size_t i = 0; i < kNodeCount; ++i) {
+    nodes.push_back(graph->addNode(std::make_unique<PNode>()));
+    if (i % 50 == 0) {
+      std::this_thread::sleep_for(std::chrono::microseconds(500));
+    }
+  }
+
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  processor.stop();
+
+  EXPECT_GT(processor.cyclesCompleted(), 0u)
+      << "Audio thread should have completed at least one cycle";
+
+  EXPECT_TRUE(processor.allocationClean())
+      << "Audio thread allocated " << processor.allocationViolations() << " times across "
+      << processor.cyclesCompleted() << " cycles despite pre-reserved capacity";
+}

From 3024c994da2e16157e1c9976b07d12142edb6fcf Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Thu, 2 Apr 2026 10:20:38 +0200
Subject: [PATCH 32/38] fix: convolver initialization

---
 apps/common-app/src/demos/PedalBoard/ReverbPedal.tsx  |  2 +-
 apps/fabric-example/ios/Podfile.lock                  |  6 +++---
 .../HostObjects/effects/ConvolverNodeHostObject.cpp   |  6 +++---
 .../cpp/audioapi/core/effects/ConvolverNode.cpp       |  3 +++
 .../cpp/audioapi/core/utils/graph/AudioGraph.hpp      | 10 +++++-----
 .../cpp/audioapi/core/utils/graph/InputPool.hpp       | 11 +++++------
 packages/react-native-audio-api/src/core/AudioNode.ts |  4 +---
 7 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/apps/common-app/src/demos/PedalBoard/ReverbPedal.tsx b/apps/common-app/src/demos/PedalBoard/ReverbPedal.tsx
index ed58844eb..23ed7a9d2 100644
--- a/apps/common-app/src/demos/PedalBoard/ReverbPedal.tsx
+++ b/apps/common-app/src/demos/PedalBoard/ReverbPedal.tsx
@@ -47,7 +47,7 @@ export default function ReverbPedal({
     } else if (level < 0.66) {
       desiredDuration = 0.7;
     } else {
-      desiredDuration = 1;
+      desiredDuration = 5;
     }
     if (convolverNodeRef.current?.buffer) {
       if (convolverNodeRef.current.buffer.duration === desiredDuration) {
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index a344b24dc..0ff51c1dc 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2514,7 +2514,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: e97c19a5a442429d1988f182a1940fb08df514da
-  hermes-engine: ca0c1d4fe0200e05fedd8d7c0c283b54cd461436
+  hermes-engine: 471e81260adadffc041e40c5eea01333addabb53
   RCTDeprecation: af44b104091a34482596cd9bd7e8d90c4e9b4bd7
   RCTRequired: bb77b070f75f53398ce43c0aaaa58337cebe2bf6
   RCTSwiftUI: afc0a0a635860da1040a0b894bfd529da06d7810
@@ -2523,7 +2523,7 @@ SPEC CHECKSUMS:
   React: 1ba7d364ade7d883a1ec055bfc3606f35fdee17b
   React-callinvoker: bc2a26f8d84fb01f003fc6de6c9337b64715f95b
   React-Core: 7840d3a80b43a95c5e80ef75146bd70925ebab0f
-  React-Core-prebuilt: e44365cf4785c3aa56ababc9ab204fe8bc6b17d0
+  React-Core-prebuilt: 6586031f606ff8ab466cac9e8284053a91342881
   React-CoreModules: 2eb010400b63b89e53a324ffb3c112e4c7c3ce42
   React-cxxreact: a558e92199d26f145afa9e62c4233cf8e7950efe
   React-debug: 755200a6e7f5e6e0a40ff8d215493d43cce285fc
@@ -2587,7 +2587,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: e96e93b493d8d86eeaee3e590ba0be53f6abe46f
   ReactCodegen: f66521b131699d6af0790f10653933b3f1f79a6f
   ReactCommon: 07572bf9e687c8a52fbe4a3641e9e3a1a477c78e
-  ReactNativeDependencies: 3467a1fea6f7a524df13b30430bebcc254d9aee2
+  ReactNativeDependencies: a5d71d95f2654107eb45e6ece04caba36beac2bd
   RNAudioAPI: fa5c075d2fcdb1ad9a695754b38f07c8c3074396
   RNGestureHandler: 07de6f059e0ee5744ae9a56feb07ee345338cc31
   RNReanimated: d75c81956bf7531fe08ba4390149002ab8bdd127
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
index 0e66a51d0..52d4e124f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp
@@ -33,7 +33,7 @@ ConvolverNodeHostObject::ConvolverNodeHostObject(
 }
 
 JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, normalize) {
-  return jsi::Value(normalize_);
+  return {normalize_};
 }
 
 JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, normalize) {
@@ -61,7 +61,7 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
   }
 
   auto handle = node_->handle;
-  auto convolverNode = static_cast<ConvolverNode *>(handle->audioNode->asAudioNode());
+  auto *convolverNode = static_cast<ConvolverNode *>(handle->audioNode->asAudioNode());
 
   auto copiedBuffer = std::make_shared<AudioBuffer>(*buffer);
 
@@ -107,7 +107,7 @@ void ConvolverNodeHostObject::setBuffer(const std::shared_ptr<AudioBuffer> &buff
       .scaleFactor = scaleFactor});
 
   auto event = [handle, setupData](BaseAudioContext &) {
-    auto convolverNode = static_cast<ConvolverNode *>(handle->audioNode->asAudioNode());
+    auto *convolverNode = static_cast<ConvolverNode *>(handle->audioNode->asAudioNode());
     convolverNode->setBuffer(
         setupData->buffer,
         std::move(setupData->convolvers),
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index 550319bdd..1f3964a81 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -91,6 +91,9 @@ float ConvolverNode::calculateNormalizationScale(const std::shared_ptr<AudioBuff
 
 // processing pipeline: audioBuffer_ (input) -> intermediateBuffer_ -> audioBuffer_ (output)
 void ConvolverNode::processNode(int framesToProcess) {
+  if (buffer_ == nullptr) {
+    return;
+  }
   if (signalledToStop_) {
     if (remainingSegments_ > 0) {
       remainingSegments_--;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
index 15ba4b5ed..5f56dcaee 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
@@ -8,7 +8,6 @@
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
-#include <iterator>
 #include <memory>
 #include <ranges>
 #include <utility>
@@ -28,7 +27,7 @@ class AudioGraph {
 
   struct Node {
     Node() = default;
-    explicit Node(std::shared_ptr<NodeHandle> handle) : handle(handle) {}
+    explicit Node(std::shared_ptr<NodeHandle> handle) : handle(std::move(handle)) {}
 
     std::shared_ptr<NodeHandle> handle = nullptr; // owned handle bridging to HostGraph
     std::uint32_t input_head = InputPool::kNull;  // head of input linked list in pool_
@@ -213,11 +212,12 @@ inline auto AudioGraph::iter() {
       std::views::filter([](const Node &n) { return n.handle->audioNode->isProcessable(); }) |
       std::views::transform([this](Node &node) {
            return Entry{
-               *node.handle->audioNode,
-               pool_.view(node.input_head) |
+            .graphObject = *node.handle->audioNode,
+            .inputs = pool_.view(node.input_head) |
                    std::views::transform([this](std::uint32_t idx) -> const GraphObject & {
                      return *nodes[idx].handle->audioNode;
-                   })};
+                   }),
+           };
          });
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp
index 000b258e4..93b80821b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp
@@ -3,7 +3,6 @@
 #include <cstdint>
 #include <cstring>
 #include <iterator>
-#include <new>
 #include <type_traits>
 
 namespace audioapi::utils::graph {
@@ -184,12 +183,12 @@ bool InputPool::Iterator<Const>::operator!=(const Iterator &other) const {
 
 template <bool Const>
 auto InputPool::InputView<Const>::begin() const -> Iterator<Const> {
-  return {slots, head};
+  return {.slots = slots, .current = head};
 }
 
 template <bool Const>
 auto InputPool::InputView<Const>::end() const -> Iterator<Const> {
-  return {slots, kNull};
+  return {.slots = slots, .current = kNull};
 }
 
 // ── Lifecycle ─────────────────────────────────────────────────────────────
@@ -290,11 +289,11 @@ inline bool InputPool::isEmpty(std::uint32_t head) {
 // ── Iteration ─────────────────────────────────────────────────────────────
 
 inline InputPool::InputView<true> InputPool::view(std::uint32_t head) const {
-  return {slots_, head};
+  return {.slots = slots_, .head = head};
 }
 
 inline InputPool::InputView<false> InputPool::mutableView(std::uint32_t head) {
-  return {slots_, head};
+  return {.slots = slots_, .head = head};
 }
 
 // ── Pool management ───────────────────────────────────────────────────────
@@ -304,7 +303,7 @@ inline std::uint32_t InputPool::capacity() const {
 }
 
 inline InputPool::Slot *InputPool::adoptBuffer(Slot *newSlots, std::uint32_t newCapacity) {
-  if (slots_) {
+  if (slots_ != nullptr) {
     std::memcpy(newSlots, slots_, capacity_ * sizeof(Slot));
   }
   for (std::uint32_t i = capacity_; i < newCapacity; i++) {
diff --git a/packages/react-native-audio-api/src/core/AudioNode.ts b/packages/react-native-audio-api/src/core/AudioNode.ts
index e11594798..2733e4673 100644
--- a/packages/react-native-audio-api/src/core/AudioNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioNode.ts
@@ -53,10 +53,8 @@ export default class AudioNode {
   public disconnect(destination?: AudioNode | AudioParam): void {
     if (destination instanceof AudioParam) {
       this.node.disconnect(destination.audioParam);
-    } else if (destination) {
-      this.node.disconnect(destination.node);
     } else {
-      this.node.disconnect();
+      this.node.disconnect(destination?.node);
     }
   }
 }

From 465ebe34d2f7e86ca6cbd4af41d1c85bdb7f6444 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 3 Apr 2026 14:38:45 +0200
Subject: [PATCH 33/38] refactor: removed .hpp files

---
 .../HostObjects/AudioNodeHostObject.h         |   4 +-
 .../HostObjects/AudioParamHostObject.cpp      |   2 +-
 .../HostObjects/AudioParamHostObject.h        |   2 +-
 .../effects/WorkletNodeHostObject.h           |   2 +-
 .../effects/WorkletProcessingNodeHostObject.h |   2 +-
 .../sources/RecorderAdapterNodeHostObject.h   |   2 +-
 .../sources/WorkletSourceNodeHostObject.h     |   2 +-
 .../common/cpp/audioapi/core/AudioNode.h      |   7 +-
 .../cpp/audioapi/core/BaseAudioContext.h      |   2 +-
 .../audioapi/core/analysis/AnalyserNode.cpp   |   1 +
 .../core/destinations/AudioDestinationNode.h  |   6 +-
 .../cpp/audioapi/core/inputs/AudioRecorder.h  |   2 +-
 .../audioapi/core/utils/graph/AudioGraph.cpp  | 210 ++++++++++
 .../audioapi/core/utils/graph/AudioGraph.h    | 190 +++++++++
 .../audioapi/core/utils/graph/AudioGraph.hpp  | 396 ------------------
 .../audioapi/core/utils/graph/BridgeNode.cpp  |  36 ++
 .../graph/{BridgeNode.hpp => BridgeNode.h}    |  36 +-
 .../cpp/audioapi/core/utils/graph/Graph.cpp   | 127 ++++++
 .../core/utils/graph/{Graph.hpp => Graph.h}   | 112 +----
 .../audioapi/core/utils/graph/GraphObject.cpp |  36 ++
 .../graph/{GraphObject.hpp => GraphObject.h}  |  41 +-
 .../audioapi/core/utils/graph/HostGraph.cpp   | 280 +++++++++++++
 .../cpp/audioapi/core/utils/graph/HostGraph.h | 134 ++++++
 .../audioapi/core/utils/graph/HostGraph.hpp   | 344 ---------------
 .../audioapi/core/utils/graph/HostNode.cpp    |  55 +++
 .../utils/graph/{HostNode.hpp => HostNode.h}  |  60 +--
 .../audioapi/core/utils/graph/InputPool.cpp   | 123 ++++++
 .../graph/{InputPool.hpp => InputPool.h}      | 124 +-----
 .../audioapi/core/utils/graph/NodeHandle.cpp  |  10 +
 .../graph/{NodeHandle.hpp => NodeHandle.h}    |   6 +-
 .../cpp/test/src/graph/AudioGraphFuzzTest.cpp |   4 +-
 .../cpp/test/src/graph/AudioGraphTest.cpp     |   4 +-
 .../cpp/test/src/graph/BridgeNodeTest.cpp     |  52 ++-
 .../test/src/graph/GraphCycleDebugTest.cpp    |   2 +-
 .../cpp/test/src/graph/GraphFuzzTest.cpp      |   2 +-
 .../common/cpp/test/src/graph/GraphTest.cpp   |   2 +-
 .../cpp/test/src/graph/HostGraphTest.cpp      |   6 +-
 .../cpp/test/src/graph/MockGraphProcessor.h   |   2 +-
 .../cpp/test/src/graph/TestGraphUtils.h       |  16 +-
 .../ios/audioapi/ios/core/IOSAudioRecorder.h  |   2 +-
 40 files changed, 1339 insertions(+), 1107 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.h
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/{BridgeNode.hpp => BridgeNode.h} (67%)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/{Graph.hpp => Graph.h} (68%)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.cpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/{GraphObject.hpp => GraphObject.h} (79%)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
 delete mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/{HostNode.hpp => HostNode.h} (67%)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.cpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/{InputPool.hpp => InputPool.h} (63%)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.cpp
 rename packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/{NodeHandle.hpp => NodeHandle.h} (89%)

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
index 60118a384..e09021a5e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
@@ -2,8 +2,8 @@
 
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
-#include <audioapi/core/utils/graph/Graph.hpp>
-#include <audioapi/core/utils/graph/HostNode.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/HostNode.h>
 #include <audioapi/jsi/JsiHostObject.h>
 #include <audioapi/types/NodeOptions.h>
 
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
index 24689e48c..9daf7cf30 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp
@@ -1,7 +1,7 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 
 #include <audioapi/core/AudioParam.h>
-#include <audioapi/core/utils/graph/BridgeNode.hpp>
+#include <audioapi/core/utils/graph/BridgeNode.h>
 #include <audioapi/utils/AudioArray.hpp>
 
 #include <memory>
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
index 2730cde9f..1c88617f2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <audioapi/core/utils/graph/HostNode.hpp>
+#include <audioapi/core/utils/graph/HostNode.h>
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h
index a6ba1448a..e3d16ef1a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletNodeHostObject.h
@@ -2,7 +2,7 @@
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/effects/WorkletNode.h>
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 
 #include <memory>
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h
index 2a7635b52..c74f55e0d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/WorkletProcessingNodeHostObject.h
@@ -2,7 +2,7 @@
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/effects/WorkletProcessingNode.h>
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 
 #include <memory>
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h
index a6b8fefe6..4da28fb5b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h
@@ -2,7 +2,7 @@
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 
 #include <memory>
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h
index fb8616c56..a9ae0e484 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h
@@ -2,7 +2,7 @@
 
 #include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
 #include <audioapi/core/sources/WorkletSourceNode.h>
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include <audioapi/types/NodeOptions.h>
 
 #include <memory>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index ec25d95ea..f0f3bd194 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -4,7 +4,7 @@
 #include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
 #include <audioapi/core/utils/Constants.h>
-#include <audioapi/core/utils/graph/GraphObject.hpp>
+#include <audioapi/core/utils/graph/GraphObject.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/Macros.h>
@@ -66,6 +66,10 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
     return audioBuffer_;
   }
 
+  virtual void setOutputBuffer(const std::shared_ptr<DSPAudioBuffer> &buffer) {
+    audioBuffer_ = buffer;
+  }
+
   /// @note JS Thread only
   [[nodiscard]] bool requiresTailProcessing() const;
 
@@ -90,6 +94,7 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
 
  protected:
   friend class DelayNodeHostObject;
+  friend class utils::graph::HostGraph;
 
   std::weak_ptr<BaseAudioContext> context_;
   std::shared_ptr<DSPAudioBuffer> audioBuffer_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 00a538e91..21ef94a79 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -4,7 +4,7 @@
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Disposer.hpp>
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
index 991324672..d6ec30849 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/analysis/AnalyserNode.cpp
@@ -21,6 +21,7 @@ AnalyserNode::AnalyserNode(
       maxDecibels_(options.maxDecibels),
       smoothingTimeConstant_(options.smoothingTimeConstant) {
   setFFTSize(options.fftSize);
+  setProcessableState(GraphObject::PROCESSABLE_STATE::ALWAYS_PROCESSABLE);
 }
 
 void AnalyserNode::setFFTSize(int fftSize) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
index 57ea2a975..221726113 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/destinations/AudioDestinationNode.h
@@ -14,10 +14,8 @@ class BaseAudioContext;
 class AudioDestinationNode : public AudioNode {
  public:
   explicit AudioDestinationNode(const std::shared_ptr<BaseAudioContext> &context)
-      : AudioNode(context, AudioDestinationOptions()) {}
-
-  bool canBeDestructed() const override {
-    return false;
+      : AudioNode(context, AudioDestinationOptions()) {
+    processableState_ = GraphObject::PROCESSABLE_STATE::ALWAYS_PROCESSABLE;
   }
 
  protected:
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
index c5b6730be..b87c00318 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <audioapi/core/utils/graph/NodeHandle.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/Result.hpp>
 #include <atomic>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.cpp
new file mode 100644
index 000000000..9b470092e
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.cpp
@@ -0,0 +1,210 @@
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <utility>
+
+namespace audioapi::utils::graph {
+
+// ── Accessors ─────────────────────────────────────────────────────────────
+
+auto AudioGraph::operator[](std::uint32_t index) -> Node & {
+  return nodes[index];
+}
+
+auto AudioGraph::operator[](std::uint32_t index) const -> const Node & {
+  return nodes[index];
+}
+
+size_t AudioGraph::size() const {
+  return nodes.size();
+}
+
+bool AudioGraph::empty() const {
+  return nodes.empty();
+}
+
+InputPool &AudioGraph::pool() {
+  return pool_;
+}
+
+const InputPool &AudioGraph::pool() const {
+  return pool_;
+}
+
+// ── Mutators & processing ─────────────────────────────────────────────────
+
+void AudioGraph::reserveNodes(std::uint32_t capacity) {
+  nodes.reserve(capacity);
+}
+
+void AudioGraph::markDirty() {
+  topo_order_dirty = true;
+}
+
+void AudioGraph::addNode(std::shared_ptr<NodeHandle> handle) {
+  handle->index = static_cast<std::uint32_t>(nodes.size());
+  nodes.emplace_back(std::move(handle));
+}
+
+void AudioGraph::process() {
+  if (topo_order_dirty) {
+    topo_order_dirty = false;
+    kahn_toposort();
+    if (topo_order_dirty) {
+      return;
+    }
+  }
+
+  const auto n = static_cast<std::uint32_t>(nodes.size());
+
+  // ── Pass 1: mark deletions (cascading, left-to-right in topo order) ────
+  // A node is deleted when: orphaned && no live inputs && canBeDestructed().
+  // Because the array is topologically sorted, removing a source first lets
+  // its dependents see the updated input set and potentially cascade.
+  for (auto &node : nodes) {
+    pool_.removeIf(
+        node.input_head, [this](std::uint32_t inp) { return nodes[inp].will_be_deleted; });
+
+    if (node.orphaned && InputPool::isEmpty(node.input_head) &&
+        node.handle->audioNode->canBeDestructed()) {
+      node.will_be_deleted = true;
+    }
+  }
+
+  // ── Compute new-position remap (stored in after_compaction_ind) ─────────
+  std::uint32_t new_pos = 0;
+  for (std::uint32_t i = 0; i < n; i++) {
+    if (!nodes[i].will_be_deleted) {
+      nodes[i].after_compaction_ind = static_cast<std::int32_t>(new_pos);
+      new_pos++;
+    }
+    // deleted nodes keep after_compaction_ind == -1 (default)
+  }
+
+  // ── Pass 2a: remap inputs to post-compaction indices ─────────────────────
+  // Must happen BEFORE shifting nodes, because shifting invalidates source
+  // positions that later nodes' inputs may still reference.
+  for (std::uint32_t e = 0; e < n; e++) {
+    if (nodes[e].will_be_deleted) {
+      continue;
+    }
+    for (auto &inp : pool_.mutableView(nodes[e].input_head)) {
+      inp = static_cast<std::uint32_t>(nodes[inp].after_compaction_ind);
+    }
+  }
+
+  // ── Pass 2b: compact — shift kept nodes left ───────────────────────────
+  std::uint32_t b = 0;
+  for (std::uint32_t e = 0; e < n; e++) {
+    if (nodes[e].will_be_deleted) {
+      continue;
+    }
+    if (b != e) {
+      nodes[b] = std::move(nodes[e]);
+      nodes[e].input_head = InputPool::kNull; // prevent double-free in truncation
+    }
+    nodes[b].handle->index = b;
+    b++;
+  }
+
+  // Truncate — dropping shared_ptr decrements refcount (2 → 1);
+  // HostGraph detects this and destroys the ghost on the main thread.
+  for (std::uint32_t i = b; i < n; i++) {
+    // Free any lingering pool slots (should already be empty for deleted nodes)
+    pool_.freeAll(nodes[i].input_head);
+    // Handle may have been moved-from during compaction, so just null it
+    nodes[i].handle = nullptr;
+  }
+  nodes.resize(b);
+
+  // Reset scratch fields for next compaction
+  for (auto &node : nodes) {
+    node.after_compaction_ind = -1;
+    node.will_be_deleted = false;
+  }
+}
+
+// ── Kahn's toposort ───────────────────────────────────────────────────────
+
+void AudioGraph::kahn_toposort() {
+  const auto n = static_cast<std::uint32_t>(nodes.size());
+  if (n <= 1) {
+    return;
+  }
+
+  // Phase 1: compute out-degree
+  for (const auto &nd : nodes) {
+    for (std::uint32_t inp : pool_.view(nd.input_head)) {
+      nodes[inp].topo_out_degree++;
+    }
+  }
+
+  // Phase 2: reverse Kahn BFS — sinks first, sources last in dequeue order.
+  // FIFO queue embedded as a linked list through after_compaction_ind.
+  std::int32_t qh = -1, qt = -1;
+  auto enq = [&](std::uint32_t i) {
+    nodes[i].after_compaction_ind = -1;
+    if (qh == -1) [[unlikely]] {
+      qh = qt = static_cast<std::int32_t>(i);
+    } else {
+      nodes[qt].after_compaction_ind = static_cast<std::int32_t>(i);
+      qt = static_cast<std::int32_t>(i);
+    }
+  };
+
+  for (std::uint32_t i = 0; i < n; i++) {
+    if (nodes[i].topo_out_degree == 0) {
+      enq(i);
+    }
+  }
+
+  std::uint32_t write = n;
+  while (qh != -1) {
+    auto idx = static_cast<std::uint32_t>(qh);
+    qh = nodes[idx].after_compaction_ind;
+    nodes[idx].after_compaction_ind = static_cast<std::int32_t>(--write);
+
+    for (std::uint32_t inp : pool_.view(nodes[idx].input_head)) {
+      if (--nodes[inp].topo_out_degree == 0) {
+        enq(inp);
+      }
+    }
+  }
+
+  // Phase 3: remap input indices to new positions (before nodes move)
+  for (auto &nd : nodes) {
+    for (std::uint32_t &inp : pool_.mutableView(nd.input_head)) {
+      inp = static_cast<std::uint32_t>(nodes[inp].after_compaction_ind);
+    }
+  }
+
+  // Phase 4: apply permutation in place via cycle sort
+  for (std::uint32_t i = 0; i < n; i++) {
+    while (nodes[i].after_compaction_ind != static_cast<std::int32_t>(i)) {
+      auto t = static_cast<std::uint32_t>(nodes[i].after_compaction_ind);
+      std::swap(nodes[i], nodes[t]);
+    }
+  }
+
+  // Phase 5: update handle indices & reset scratch
+  for (std::uint32_t i = 0; i < n; i++) {
+    if (nodes[i].handle) {
+      nodes[i].handle->index = i;
+    }
+    nodes[i].after_compaction_ind = -1;
+  }
+}
+
+AudioGraph::NodeBuffer AudioGraph::adoptNodeBuffer(NodeBuffer preAllocated) {
+  // Move live nodes into the pre-allocated (empty, large-capacity) buffer.
+  // No reallocation: preAllocated.data.capacity() >= nodes.size() guaranteed
+  // by the main thread before sending this event.
+  preAllocated.data.insert(
+      preAllocated.data.end(),
+      std::make_move_iterator(nodes.begin()),
+      std::make_move_iterator(nodes.end()));
+  std::swap(nodes, preAllocated.data);
+  // preAllocated.data now holds the old (small) buffer with moved-from nodes.
+  // Caller disposes it off the audio thread.
+  return preAllocated;
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.h
new file mode 100644
index 000000000..da96b08c2
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.h
@@ -0,0 +1,190 @@
+#pragma once
+
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/graph/GraphObject.h>
+#include <audioapi/core/utils/graph/InputPool.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+namespace audioapi::utils::graph {
+
+/// @brief Cache-friendly, index-stable node storage with in-place topological sort.
+///
+/// Nodes are stored in a flat vector that is kept topologically sorted
+/// (sources first, sinks last). The graph supports O(V+E) compaction of
+/// orphaned nodes and O(1)-extra-space Kahn's toposort.
+///
+/// @note Can store at most 2^30 nodes due to bit-packed indices (~10^9).
+class AudioGraph {
+  // ── Node ────────────────────────────────────────────────────────────────
+
+  struct Node {
+    Node() = default;
+    explicit Node(std::shared_ptr<NodeHandle> handle) : handle(std::move(handle)) {}
+
+    std::shared_ptr<NodeHandle> handle = nullptr; // owned handle bridging to HostGraph
+    std::uint32_t input_head = InputPool::kNull;  // head of input linked list in pool_
+
+    std::uint32_t topo_out_degree : 31 = 0; // scratch — Kahn's out-degree counter
+    unsigned will_be_deleted : 1 = 0;       // scratch — marked for compaction removal
+    std::int32_t after_compaction_ind : 31 =
+        -1; // scratch — new index after compaction / BFS linked-list next
+
+    /// Node is removed when: orphaned && inputs.empty() && canBeDestructed()
+    unsigned orphaned : 1 = 0; // means this node was removed from host graph
+
+#if RN_AUDIO_API_TEST
+    size_t test_node_identifier__ = 0;
+#endif
+  };
+
+ public:
+  AudioGraph() = default;
+  ~AudioGraph() = default;
+
+  AudioGraph(const AudioGraph &) = delete;
+  AudioGraph &operator=(const AudioGraph &) = delete;
+
+  AudioGraph(AudioGraph &&) noexcept = default;
+  AudioGraph &operator=(AudioGraph &&) noexcept = default;
+
+  // ── Node buffer pre-allocation (main-thread → audio-thread handoff) ─────
+
+  /// @brief Opaque pre-allocated node storage.
+  ///
+  /// Created on the main thread via makeNodeBuffer(), then handed to the
+  /// audio thread via adoptNodeBuffer(). The returned (old) buffer must be
+  /// disposed off the audio thread.
+  struct NodeBuffer {
+    std::vector<Node> data;
+    explicit NodeBuffer(std::uint32_t capacity) {
+      data.reserve(capacity);
+    }
+    NodeBuffer() = default;
+  };
+
+  /// @brief Allocates a node buffer with the given capacity on the calling thread.
+  [[nodiscard]] static NodeBuffer makeNodeBuffer(std::uint32_t capacity) {
+    return NodeBuffer(capacity);
+  }
+
+  /// @brief Installs a pre-allocated node buffer on the audio thread.
+  ///
+  /// Moves all live nodes into the pre-allocated buffer (allocation-free:
+  /// capacity was ensured on the main thread), swaps it in, and returns
+  /// the old buffer for disposal off the audio thread.
+  ///
+  /// @note Must be called only from the audio thread.
+  [[nodiscard]] NodeBuffer adoptNodeBuffer(NodeBuffer preAllocated);
+
+  /// @brief Entry returned by iter() — a reference to the graph object and a view of its inputs.
+  template <typename InputsView>
+  struct Entry {
+    GraphObject &graphObject;
+    InputsView inputs;
+  };
+
+  // ── Accessors ───────────────────────────────────────────────────────────
+
+  /// @brief Access node by flat-vector index.
+  [[nodiscard]] Node &operator[](std::uint32_t index);
+
+  /// @brief Access node by flat-vector index (const).
+  [[nodiscard]] const Node &operator[](std::uint32_t index) const;
+
+  /// @brief Number of live nodes in the graph.
+  [[nodiscard]] size_t size() const;
+
+  /// @brief Whether the graph is empty.
+  [[nodiscard]] bool empty() const;
+
+  /// @brief Provides an iterable view of the nodes in topological order.
+  ///
+  /// Each entry contains a reference to the GraphObject and an immutable view
+  /// of its inputs (as references to GraphObject).
+  ///
+  /// ## Example usage:
+  /// ```cpp
+  /// for (auto [graphObject, inputs] : graph.iter()) {
+  ///   // process graphObject and its inputs
+  /// }
+  /// ```
+  /// @note Lifetime of entries is bound to this graph — they are not owned.
+  /// @note Using this iterator after modifying the graph is undefined behavior.
+  [[nodiscard]] auto iter();
+
+  /// @brief Returns a reference to the input pool used for edge storage.
+  [[nodiscard]] InputPool &pool();
+  [[nodiscard]] const InputPool &pool() const;
+
+  /// @brief Pre-reserves the internal node vector to at least `capacity`.
+  ///
+  /// Call from `processGrowEvents()` (outside the allocation-free zone)
+  /// so that subsequent `addNode` calls within `processEvents()` do not
+  /// trigger vector reallocation.
+  void reserveNodes(std::uint32_t capacity);
+
+  // ── Mutators ────────────────────────────────────────────────────────────
+
+  /// @brief Marks the topological ordering as dirty so the next process()
+  /// recomputes it.
+  void markDirty();
+
+  /// @brief Adds a new node. AudioGraph takes shared ownership of the handle.
+  /// @param handle shared NodeHandle bridging to HostGraph
+  void addNode(std::shared_ptr<NodeHandle> handle);
+
+  /// @brief Recomputes topological order (if dirty), then compacts the graph
+  /// by removing orphaned, input-free, destructible nodes.
+  ///
+  /// When a node is compacted out its `shared_ptr<NodeHandle>` is released
+  /// (refcount drops 2 → 1). HostGraph detects this via `use_count() == 1`
+  /// and destroys the ghost + GraphObject on the main thread.
+  ///
+  /// Uses a two-pass approach: pass 1 marks deletions (cascading in topo
+  /// order) and computes index remapping; pass 2 remaps inputs and shifts
+  /// kept nodes left.
+  ///
+  /// Time: O(V + E)
+  ///
+  /// Extra space: O(1) — everything in place.
+  void process();
+
+ private:
+  std::vector<Node> nodes;       // always kept topologically sorted
+  InputPool pool_;               // pool backing all input linked lists
+  bool topo_order_dirty = false; // set by markDirty(), cleared by process()
+
+  /// @brief In-place Kahn's toposort (sources first, sinks last).
+  ///
+  /// Uses `after_compaction_ind` as an embedded FIFO linked-list for the
+  /// BFS queue, and cycle-sort for the final permutation.
+  ///
+  /// Time: O(V + E)
+  ///
+  /// Extra space: O(1).
+  void kahn_toposort();
+};
+
+inline auto AudioGraph::iter() {
+  return nodes |
+      std::views::filter([](const Node &n) { return n.handle->audioNode->isProcessable(); }) |
+      std::views::transform([this](Node &node) {
+           return Entry{
+               .graphObject = *node.handle->audioNode,
+               .inputs = pool_.view(node.input_head) |
+                   std::views::transform([this](std::uint32_t idx) -> const GraphObject & {
+                           return *nodes[idx].handle->audioNode;
+                         }),
+           };
+         });
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
deleted file mode 100644
index 5f56dcaee..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/AudioGraph.hpp
+++ /dev/null
@@ -1,396 +0,0 @@
-#pragma once
-
-#include <audioapi/core/utils/Constants.h>
-#include <audioapi/core/utils/Disposer.hpp>
-#include <audioapi/core/utils/graph/InputPool.hpp>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
-
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <memory>
-#include <ranges>
-#include <utility>
-#include <vector>
-
-namespace audioapi::utils::graph {
-
-/// @brief Cache-friendly, index-stable node storage with in-place topological sort.
-///
-/// Nodes are stored in a flat vector that is kept topologically sorted
-/// (sources first, sinks last). The graph supports O(V+E) compaction of
-/// orphaned nodes and O(1)-extra-space Kahn's toposort.
-///
-/// @note Can store at most 2^30 nodes due to bit-packed indices (~10^9).
-class AudioGraph {
-  // ── Node ────────────────────────────────────────────────────────────────
-
-  struct Node {
-    Node() = default;
-    explicit Node(std::shared_ptr<NodeHandle> handle) : handle(std::move(handle)) {}
-
-    std::shared_ptr<NodeHandle> handle = nullptr; // owned handle bridging to HostGraph
-    std::uint32_t input_head = InputPool::kNull;  // head of input linked list in pool_
-
-    std::uint32_t topo_out_degree : 31 = 0; // scratch — Kahn's out-degree counter
-    unsigned will_be_deleted : 1 = 0;       // scratch — marked for compaction removal
-    std::int32_t after_compaction_ind : 31 =
-        -1; // scratch — new index after compaction / BFS linked-list next
-
-    /// Node is removed when: orphaned && inputs.empty() && canBeDestructed()
-    unsigned orphaned : 1 = 0; // means this node was removed from host graph
-
-#if RN_AUDIO_API_TEST
-    size_t test_node_identifier__ = 0;
-#endif
-  };
-
- public:
-  AudioGraph() = default;
-  ~AudioGraph() = default;
-
-  AudioGraph(const AudioGraph &) = delete;
-  AudioGraph &operator=(const AudioGraph &) = delete;
-
-  AudioGraph(AudioGraph &&) noexcept = default;
-  AudioGraph &operator=(AudioGraph &&) noexcept = default;
-
-  // ── Node buffer pre-allocation (main-thread → audio-thread handoff) ─────
-
-  /// @brief Opaque pre-allocated node storage.
-  ///
-  /// Created on the main thread via makeNodeBuffer(), then handed to the
-  /// audio thread via adoptNodeBuffer(). The returned (old) buffer must be
-  /// disposed off the audio thread.
-  struct NodeBuffer {
-    std::vector<Node> data;
-    explicit NodeBuffer(std::uint32_t capacity) {
-      data.reserve(capacity);
-    }
-    NodeBuffer() = default;
-  };
-
-  /// @brief Allocates a node buffer with the given capacity on the calling thread.
-  [[nodiscard]] static NodeBuffer makeNodeBuffer(std::uint32_t capacity) {
-    return NodeBuffer(capacity);
-  }
-
-  /// @brief Installs a pre-allocated node buffer on the audio thread.
-  ///
-  /// Moves all live nodes into the pre-allocated buffer (allocation-free:
-  /// capacity was ensured on the main thread), swaps it in, and returns
-  /// the old buffer for disposal off the audio thread.
-  ///
-  /// @note Must be called only from the audio thread.
-  [[nodiscard]] NodeBuffer adoptNodeBuffer(NodeBuffer preAllocated) {
-    // Move live nodes into the pre-allocated (empty, large-capacity) buffer.
-    // No reallocation: preAllocated.data.capacity() >= nodes.size() guaranteed
-    // by the main thread before sending this event.
-    preAllocated.data.insert(
-        preAllocated.data.end(),
-        std::make_move_iterator(nodes.begin()),
-        std::make_move_iterator(nodes.end()));
-    std::swap(nodes, preAllocated.data);
-    // preAllocated.data now holds the old (small) buffer with moved-from nodes.
-    // Caller disposes it off the audio thread.
-    return preAllocated;
-  }
-
-  /// @brief Entry returned by iter() — a reference to the graph object and a view of its inputs.
-  template <typename InputsView>
-  struct Entry {
-    GraphObject &graphObject;
-    InputsView inputs;
-  };
-
-  // ── Accessors ───────────────────────────────────────────────────────────
-
-  /// @brief Access node by flat-vector index.
-  [[nodiscard]] Node &operator[](std::uint32_t index);
-
-  /// @brief Access node by flat-vector index (const).
-  [[nodiscard]] const Node &operator[](std::uint32_t index) const;
-
-  /// @brief Number of live nodes in the graph.
-  [[nodiscard]] size_t size() const;
-
-  /// @brief Whether the graph is empty.
-  [[nodiscard]] bool empty() const;
-
-  /// @brief Provides an iterable view of the nodes in topological order.
-  ///
-  /// Each entry contains a reference to the GraphObject and an immutable view
-  /// of its inputs (as references to GraphObject).
-  ///
-  /// ## Example usage:
-  /// ```cpp
-  /// for (auto [graphObject, inputs] : graph.iter()) {
-  ///   // process graphObject and its inputs
-  /// }
-  /// ```
-  /// @note Lifetime of entries is bound to this graph — they are not owned.
-  /// @note Using this iterator after modifying the graph is undefined behavior.
-  [[nodiscard]] auto iter();
-
-  /// @brief Returns a reference to the input pool used for edge storage.
-  [[nodiscard]] InputPool &pool();
-  [[nodiscard]] const InputPool &pool() const;
-
-  /// @brief Pre-reserves the internal node vector to at least `capacity`.
-  ///
-  /// Call from `processGrowEvents()` (outside the allocation-free zone)
-  /// so that subsequent `addNode` calls within `processEvents()` do not
-  /// trigger vector reallocation.
-  void reserveNodes(std::uint32_t capacity);
-
-  // ── Mutators ────────────────────────────────────────────────────────────
-
-  /// @brief Marks the topological ordering as dirty so the next process()
-  /// recomputes it.
-  void markDirty();
-
-  /// @brief Adds a new node. AudioGraph takes shared ownership of the handle.
-  /// @param handle shared NodeHandle bridging to HostGraph
-  void addNode(std::shared_ptr<NodeHandle> handle);
-
-  /// @brief Recomputes topological order (if dirty), then compacts the graph
-  /// by removing orphaned, input-free, destructible nodes.
-  ///
-  /// When a node is compacted out its `shared_ptr<NodeHandle>` is released
-  /// (refcount drops 2 → 1). HostGraph detects this via `use_count() == 1`
-  /// and destroys the ghost + GraphObject on the main thread.
-  ///
-  /// Uses a two-pass approach: pass 1 marks deletions (cascading in topo
-  /// order) and computes index remapping; pass 2 remaps inputs and shifts
-  /// kept nodes left.
-  ///
-  /// Time: O(V + E)
-  ///
-  /// Extra space: O(1) — everything in place.
-  void process();
-
- private:
-  std::vector<Node> nodes;       // always kept topologically sorted
-  InputPool pool_;               // pool backing all input linked lists
-  bool topo_order_dirty = false; // set by markDirty(), cleared by process()
-
-  /// @brief In-place Kahn's toposort (sources first, sinks last).
-  ///
-  /// Uses `after_compaction_ind` as an embedded FIFO linked-list for the
-  /// BFS queue, and cycle-sort for the final permutation.
-  ///
-  /// Time: O(V + E)
-  ///
-  /// Extra space: O(1).
-  void kahn_toposort();
-};
-
-// =========================================================================
-// Implementation
-// =========================================================================
-
-// ── Accessors ─────────────────────────────────────────────────────────────
-
-inline auto AudioGraph::operator[](std::uint32_t index) -> Node & {
-  return nodes[index];
-}
-
-inline auto AudioGraph::operator[](std::uint32_t index) const -> const Node & {
-  return nodes[index];
-}
-
-inline size_t AudioGraph::size() const {
-  return nodes.size();
-}
-
-inline bool AudioGraph::empty() const {
-  return nodes.empty();
-}
-
-inline auto AudioGraph::iter() {
-  return nodes |
-      std::views::filter([](const Node &n) { return n.handle->audioNode->isProcessable(); }) |
-      std::views::transform([this](Node &node) {
-           return Entry{
-            .graphObject = *node.handle->audioNode,
-            .inputs = pool_.view(node.input_head) |
-                   std::views::transform([this](std::uint32_t idx) -> const GraphObject & {
-                     return *nodes[idx].handle->audioNode;
-                   }),
-           };
-         });
-}
-
-inline InputPool &AudioGraph::pool() {
-  return pool_;
-}
-
-inline const InputPool &AudioGraph::pool() const {
-  return pool_;
-}
-
-inline void AudioGraph::reserveNodes(std::uint32_t capacity) {
-  nodes.reserve(capacity);
-}
-
-// ── Mutators ──────────────────────────────────────────────────────────────
-
-inline void AudioGraph::markDirty() {
-  topo_order_dirty = true;
-}
-
-inline void AudioGraph::addNode(std::shared_ptr<NodeHandle> handle) {
-  handle->index = static_cast<std::uint32_t>(nodes.size());
-  nodes.emplace_back(std::move(handle));
-}
-
-inline void AudioGraph::process() {
-  if (topo_order_dirty) {
-    topo_order_dirty = false;
-    kahn_toposort();
-    if (topo_order_dirty) {
-      return;
-    }
-  }
-
-  const auto n = static_cast<std::uint32_t>(nodes.size());
-
-  // ── Pass 1: mark deletions (cascading, left-to-right in topo order) ────
-  // A node is deleted when: orphaned && no live inputs && canBeDestructed().
-  // Because the array is topologically sorted, removing a source first lets
-  // its dependents see the updated input set and potentially cascade.
-  for (auto &node : nodes) {
-    pool_.removeIf(
-        node.input_head, [this](std::uint32_t inp) { return nodes[inp].will_be_deleted; });
-
-    if (node.orphaned && InputPool::isEmpty(node.input_head) &&
-        node.handle->audioNode->canBeDestructed()) {
-      node.will_be_deleted = true;
-    }
-  }
-
-  // ── Compute new-position remap (stored in after_compaction_ind) ─────────
-  std::uint32_t new_pos = 0;
-  for (std::uint32_t i = 0; i < n; i++) {
-    if (!nodes[i].will_be_deleted) {
-      nodes[i].after_compaction_ind = static_cast<std::int32_t>(new_pos);
-      new_pos++;
-    }
-    // deleted nodes keep after_compaction_ind == -1 (default)
-  }
-
-  // ── Pass 2a: remap inputs to post-compaction indices ─────────────────────
-  // Must happen BEFORE shifting nodes, because shifting invalidates source
-  // positions that later nodes' inputs may still reference.
-  for (std::uint32_t e = 0; e < n; e++) {
-    if (nodes[e].will_be_deleted) {
-      continue;
-    }
-    for (auto &inp : pool_.mutableView(nodes[e].input_head)) {
-      inp = static_cast<std::uint32_t>(nodes[inp].after_compaction_ind);
-    }
-  }
-
-  // ── Pass 2b: compact — shift kept nodes left ───────────────────────────
-  std::uint32_t b = 0;
-  for (std::uint32_t e = 0; e < n; e++) {
-    if (nodes[e].will_be_deleted) {
-      continue;
-    }
-    if (b != e) {
-      nodes[b] = std::move(nodes[e]);
-      nodes[e].input_head = InputPool::kNull; // prevent double-free in truncation
-    }
-    nodes[b].handle->index = b;
-    b++;
-  }
-
-  // Truncate — dropping shared_ptr decrements refcount (2 → 1);
-  // HostGraph detects this and destroys the ghost on the main thread.
-  for (std::uint32_t i = b; i < n; i++) {
-    // Free any lingering pool slots (should already be empty for deleted nodes)
-    pool_.freeAll(nodes[i].input_head);
-    // Handle may have been moved-from during compaction, so just null it
-    nodes[i].handle = nullptr;
-  }
-  nodes.resize(b);
-
-  // Reset scratch fields for next compaction
-  for (auto &node : nodes) {
-    node.after_compaction_ind = -1;
-    node.will_be_deleted = false;
-  }
-}
-
-// ── Kahn's toposort ───────────────────────────────────────────────────────
-
-inline void AudioGraph::kahn_toposort() {
-  const auto n = static_cast<std::uint32_t>(nodes.size());
-  if (n <= 1) {
-    return;
-  }
-
-  // Phase 1: compute out-degree
-  for (const auto &nd : nodes) {
-    for (std::uint32_t inp : pool_.view(nd.input_head)) {
-      nodes[inp].topo_out_degree++;
-    }
-  }
-
-  // Phase 2: reverse Kahn BFS — sinks first, sources last in dequeue order.
-  // FIFO queue embedded as a linked list through after_compaction_ind.
-  std::int32_t qh = -1, qt = -1;
-  auto enq = [&](std::uint32_t i) {
-    nodes[i].after_compaction_ind = -1;
-    if (qh == -1) [[unlikely]] {
-      qh = qt = static_cast<std::int32_t>(i);
-    } else {
-      nodes[qt].after_compaction_ind = static_cast<std::int32_t>(i);
-      qt = static_cast<std::int32_t>(i);
-    }
-  };
-
-  for (std::uint32_t i = 0; i < n; i++) {
-    if (nodes[i].topo_out_degree == 0) {
-      enq(i);
-    }
-  }
-
-  std::uint32_t write = n;
-  while (qh != -1) {
-    auto idx = static_cast<std::uint32_t>(qh);
-    qh = nodes[idx].after_compaction_ind;
-    nodes[idx].after_compaction_ind = static_cast<std::int32_t>(--write);
-
-    for (std::uint32_t inp : pool_.view(nodes[idx].input_head)) {
-      if (--nodes[inp].topo_out_degree == 0) {
-        enq(inp);
-      }
-    }
-  }
-
-  // Phase 3: remap input indices to new positions (before nodes move)
-  for (auto &nd : nodes) {
-    for (std::uint32_t &inp : pool_.mutableView(nd.input_head)) {
-      inp = static_cast<std::uint32_t>(nodes[inp].after_compaction_ind);
-    }
-  }
-
-  // Phase 4: apply permutation in place via cycle sort
-  for (std::uint32_t i = 0; i < n; i++) {
-    while (nodes[i].after_compaction_ind != static_cast<std::int32_t>(i)) {
-      auto t = static_cast<std::uint32_t>(nodes[i].after_compaction_ind);
-      std::swap(nodes[i], nodes[t]);
-    }
-  }
-
-  // Phase 5: update handle indices & reset scratch
-  for (std::uint32_t i = 0; i < n; i++) {
-    if (nodes[i].handle) {
-      nodes[i].handle->index = i;
-    }
-    nodes[i].after_compaction_ind = -1;
-  }
-}
-
-} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
new file mode 100644
index 000000000..e52c0cbd0
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.cpp
@@ -0,0 +1,36 @@
+#include <audioapi/core/utils/graph/BridgeNode.h>
+#include <vector>
+
+namespace audioapi::utils::graph {
+
+BridgeNode::BridgeNode(AudioParam *param) : param_(param) {}
+
+bool BridgeNode::canBeDestructed() const {
+  return true;
+}
+
+const DSPAudioBuffer *BridgeNode::getOutput() const {
+  return nullptr;
+}
+
+AudioParam *BridgeNode::param() const {
+  return param_;
+}
+
+void BridgeNode::processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) {
+  // Skip processing if param is null (e.g., in tests)
+  if (param_ == nullptr) {
+    return;
+  }
+
+  // Get AudioParam's input buffer and fill it with mixed inputs
+  auto inputBuffer = param_->getInputBuffer();
+  inputBuffer->zero();
+
+  for (const DSPAudioBuffer *input : inputs) {
+    inputBuffer->sum(*input, ChannelInterpretation::SPEAKERS);
+  }
+  (void)numFrames;
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.h
similarity index 67%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.h
index daa754581..d88e22f0e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/BridgeNode.h
@@ -2,10 +2,9 @@
 
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/types/ChannelInterpretation.h>
-#include <audioapi/core/utils/graph/GraphObject.hpp>
+#include <audioapi/core/utils/graph/GraphObject.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
-#include <memory>
 #include <vector>
 
 namespace audioapi {
@@ -33,41 +32,18 @@ namespace audioapi::utils::graph {
 /// - canBeDestructed() always returns true, so it's cleaned up on next compaction
 class BridgeNode final : public GraphObject {
  public:
-  explicit BridgeNode(AudioParam *param) : param_(param) {}
+  explicit BridgeNode(AudioParam *param);
 
-  [[nodiscard]] bool isProcessable() const override {
-    return true;
-  }
-
-  [[nodiscard]] bool canBeDestructed() const override {
-    return true;
-  }
+  [[nodiscard]] bool canBeDestructed() const override;
 
   /// @brief Returns nullptr - BridgeNode should not be mixed as input for other nodes.
-  [[nodiscard]] const DSPAudioBuffer *getOutput() const override {
-    return nullptr;
-  }
+  [[nodiscard]] const DSPAudioBuffer *getOutput() const override;
 
   /// @brief Returns the param this bridge represents a connection to.
-  [[nodiscard]] AudioParam *param() const {
-    return param_;
-  }
+  [[nodiscard]] AudioParam *param() const;
 
  protected:
-  void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override {
-    // Skip processing if param is null (e.g., in tests)
-    if (param_ == nullptr) {
-      return;
-    }
-
-    // Get AudioParam's input buffer and fill it with mixed inputs
-    auto inputBuffer = param_->getInputBuffer();
-    inputBuffer->zero();
-
-    for (const DSPAudioBuffer *input : inputs) {
-      inputBuffer->sum(*input, ChannelInterpretation::SPEAKERS);
-    }
-  }
+  void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override;
 
  private:
   AudioParam *param_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
new file mode 100644
index 000000000..f3522e2dd
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
@@ -0,0 +1,127 @@
+// Graph coordinator implementation (formerly inline in Graph.hpp).
+
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+namespace audioapi::utils::graph {
+
+Graph::Graph(size_t eventQueueCapacity, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer)
+    : disposer_(disposer) {
+  using namespace audioapi::channels::spsc;
+
+  auto [es, er] =
+      channel<AGEvent, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::BUSY_LOOP>(eventQueueCapacity);
+  eventSender_ = std::move(es);
+  eventReceiver_ = std::move(er);
+}
+
+Graph::Graph(
+    size_t eventQueueCapacity,
+    Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer,
+    std::uint32_t initialNodeCapacity,
+    std::uint32_t initialEdgeCapacity)
+    : Graph(eventQueueCapacity, disposer) {
+  if (initialNodeCapacity > 0) {
+    audioGraph.reserveNodes(initialNodeCapacity);
+    nodeCapacity_ = initialNodeCapacity;
+  }
+  if (initialEdgeCapacity > 0) {
+    audioGraph.pool().grow(initialEdgeCapacity);
+    poolCapacity_ = initialEdgeCapacity;
+  }
+}
+
+void Graph::processEvents() {
+  AGEvent event;
+  while (eventReceiver_.try_receive(event) == audioapi::channels::spsc::ResponseStatus::SUCCESS) {
+    if (event) {
+      event(audioGraph, *disposer_);
+    }
+  }
+}
+
+void Graph::process() {
+  audioGraph.process();
+}
+
+Graph::HNode *Graph::addNode(std::unique_ptr<GraphObject> audioNode) {
+  collectDisposedNodes();
+
+  auto handle = std::make_shared<NodeHandle>(0, std::move(audioNode));
+  auto [hostNode, event] = hostGraph.addNode(handle);
+
+  sendNodeGrowIfNeeded();
+
+  eventSender_.send(std::move(event));
+  return hostNode;
+}
+
+Graph::Res Graph::removeNode(HNode *node) {
+  collectDisposedNodes();
+  return hostGraph.removeNode(node).map([&](AGEvent event) {
+    eventSender_.send(std::move(event));
+    return NoneType{};
+  });
+}
+
+Graph::Res Graph::addEdge(HNode *from, HNode *to) {
+  collectDisposedNodes();
+  return hostGraph.addEdge(from, to).map([&](AGEvent event) {
+    sendPoolGrowIfNeeded();
+    eventSender_.send(std::move(event));
+    return NoneType{};
+  });
+}
+
+Graph::Res Graph::removeEdge(HNode *from, HNode *to) {
+  collectDisposedNodes();
+  return hostGraph.removeEdge(from, to).map([&](AGEvent event) {
+    eventSender_.send(std::move(event));
+    return NoneType{};
+  });
+}
+
+Graph::Res Graph::removeAllEdges(HNode *from) {
+  collectDisposedNodes();
+  return hostGraph.removeAllEdges(from).map([&](AGEvent event) {
+    eventSender_.send(std::move(event));
+    return NoneType{};
+  });
+}
+
+void Graph::collectDisposedNodes() {
+  hostGraph.collectDisposedNodes();
+}
+
+void Graph::sendPoolGrowIfNeeded() {
+  auto edges = static_cast<std::uint32_t>(hostGraph.edgeCount());
+  // edges > poolCapacity_ / 2 || (poolCapacity_ == 0 && edges > 0) left for clarity
+  if (edges > poolCapacity_ / 2) {
+    std::uint32_t newCap = std::max(static_cast<std::uint32_t>(edges * 2), std::uint32_t{64});
+    auto buf = std::make_unique<InputPool::Slot[]>(newCap);
+    eventSender_.send(
+        [buf = std::move(buf), newCap](
+            AudioGraph &graph, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &disposer) mutable {
+          auto *old = graph.pool().adoptBuffer(buf.release(), newCap);
+          if (old) {
+            disposer.dispose(OwnedSlotBuffer(old));
+          }
+        });
+    poolCapacity_ = newCap;
+  }
+}
+
+void Graph::sendNodeGrowIfNeeded() {
+  auto nodes = static_cast<std::uint32_t>(hostGraph.nodeCount());
+  if (nodes > nodeCapacity_) {
+    std::uint32_t newCap = std::max(static_cast<std::uint32_t>(nodes * 2), std::uint32_t{64});
+    eventSender_.send([newCap](AudioGraph &graph, auto &) { graph.reserveNodes(newCap); });
+    nodeCapacity_ = newCap;
+  }
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
similarity index 68%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
index 050c1450e..1af915236 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
@@ -1,18 +1,18 @@
 #pragma once
 
 #include <audioapi/core/utils/Disposer.hpp>
-#include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/HostGraph.hpp>
-#include <audioapi/core/utils/graph/InputPool.hpp>
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <audioapi/core/utils/graph/HostGraph.h>
+#include <audioapi/core/utils/graph/InputPool.h>
 
 #include <audioapi/utils/FatFunction.hpp>
-#include <audioapi/utils/SpscChannel.hpp>
-
 #include <audioapi/utils/Result.hpp>
+#include <audioapi/utils/SpscChannel.hpp>
 
 #include <algorithm>
 #include <cstdint>
 #include <memory>
+#include <new>
 #include <utility>
 
 namespace audioapi::utils::graph {
@@ -52,31 +52,13 @@ class Graph {
   using ResultError = HostGraph::ResultError;
   using Res = Result<NoneType, ResultError>;
 
-  Graph(size_t eventQueueCapacity, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer)
-      : disposer_(disposer) {
-    using namespace audioapi::channels::spsc;
-
-    auto [es, er] = channel<AGEvent, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::BUSY_LOOP>(
-        eventQueueCapacity);
-    eventSender_ = std::move(es);
-    eventReceiver_ = std::move(er);
-  }
+  Graph(size_t eventQueueCapacity, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer);
 
   Graph(
       size_t eventQueueCapacity,
       Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer,
       std::uint32_t initialNodeCapacity,
-      std::uint32_t initialEdgeCapacity)
-      : Graph(eventQueueCapacity, disposer) {
-    if (initialNodeCapacity > 0) {
-      audioGraph.reserveNodes(initialNodeCapacity);
-      nodeCapacity_ = initialNodeCapacity;
-    }
-    if (initialEdgeCapacity > 0) {
-      audioGraph.pool().grow(initialEdgeCapacity);
-      poolCapacity_ = initialEdgeCapacity;
-    }
-  }
+      std::uint32_t initialEdgeCapacity);
 
   // ── Audio-thread API ────────────────────────────────────────────────────
 
@@ -89,21 +71,12 @@ class Graph {
   /// grow event in the same FIFO.
   ///
   /// @note Should be called only from the audio thread.
-  void processEvents() {
-    AGEvent event;
-    while (eventReceiver_.try_receive(event) == audioapi::channels::spsc::ResponseStatus::SUCCESS) {
-      if (event) {
-        event(audioGraph, *disposer_);
-      }
-    }
-  }
+  void processEvents();
 
   /// @brief Runs toposort + compaction on the audio graph.
   /// Allocation-free.
   /// @note Should be called only from the audio thread.
-  void process() {
-    audioGraph.process();
-  }
+  void process();
 
   /// @brief Returns an iterable view of nodes in topological order.
   ///
@@ -121,17 +94,7 @@ class Graph {
   /// @brief Adds a new node to the graph and returns a pointer to it.
   /// @param audioNode the audio processing node to add (ownership transferred)
   /// @return pointer to the newly added HostGraph::Node
-  HNode *addNode(std::unique_ptr<GraphObject> audioNode = nullptr) {
-    collectDisposedNodes();
-
-    auto handle = std::make_shared<NodeHandle>(0, std::move(audioNode));
-    auto [hostNode, event] = hostGraph.addNode(handle);
-
-    sendNodeGrowIfNeeded();
-
-    eventSender_.send(std::move(event));
-    return hostNode;
-  }
+  HNode *addNode(std::unique_ptr<GraphObject> audioNode = nullptr);
 
   template <std::derived_from<GraphObject> TObject>
   HNode *addNode(std::unique_ptr<TObject> audioNode) {
@@ -140,45 +103,18 @@ class Graph {
 
   /// @brief Removes a node (marks as ghost). Pointer remains valid until
   /// the ghost is collected after AudioGraph releases its shared_ptr.
-  Res removeNode(HNode *node) {
-    collectDisposedNodes();
-    return hostGraph.removeNode(node).map([&](AGEvent event) {
-      eventSender_.send(std::move(event));
-      return NoneType{};
-    });
-  }
+  Res removeNode(HNode *node);
 
   /// @brief Adds a directed edge from → to. Rejects cycles and duplicates.
-  Res addEdge(HNode *from, HNode *to) {
-    collectDisposedNodes();
-    return hostGraph.addEdge(from, to).map([&](AGEvent event) {
-      sendPoolGrowIfNeeded();
-      eventSender_.send(std::move(event));
-      return NoneType{};
-    });
-  }
+  Res addEdge(HNode *from, HNode *to);
 
   /// @brief Removes a directed edge from → to.
-  Res removeEdge(HNode *from, HNode *to) {
-    collectDisposedNodes();
-    return hostGraph.removeEdge(from, to).map([&](AGEvent event) {
-      eventSender_.send(std::move(event));
-      return NoneType{};
-    });
-  }
+  Res removeEdge(HNode *from, HNode *to);
 
   /// @brief Removes all outgoing edges from `from`.
-  Res removeAllEdges(HNode *from) {
-    collectDisposedNodes();
-    return hostGraph.removeAllEdges(from).map([&](AGEvent event) {
-      eventSender_.send(std::move(event));
-      return NoneType{};
-    });
-  }
+  Res removeAllEdges(HNode *from);
 
-  void collectDisposedNodes() {
-    hostGraph.collectDisposedNodes();
-  }
+  void collectDisposedNodes();
 
  private:
   using OwnedSlotBuffer = std::unique_ptr<InputPool::Slot[]>;
@@ -208,23 +144,7 @@ class Graph {
   /// slot buffer on the main thread and sends it as an AGEvent through the
   /// event channel. The old buffer is sent to the Disposer for deallocation
   /// on a separate thread — never on the audio thread.
-  void sendPoolGrowIfNeeded() {
-    auto edges = static_cast<std::uint32_t>(hostGraph.edgeCount());
-    // edges > poolCapacity_ / 2 || (poolCapacity_ == 0 && edges > 0) left for clarity
-    if (edges > poolCapacity_ / 2) {
-      std::uint32_t newCap = std::max(static_cast<std::uint32_t>(edges * 2), std::uint32_t{64});
-      auto buf = std::make_unique<InputPool::Slot[]>(newCap);
-      eventSender_.send(
-          [buf = std::move(buf), newCap](
-              AudioGraph &graph, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &disposer) mutable {
-            auto *old = graph.pool().adoptBuffer(buf.release(), newCap);
-            if (old) {
-              disposer.dispose(OwnedSlotBuffer(old));
-            }
-          });
-      poolCapacity_ = newCap;
-    }
-  }
+  void sendPoolGrowIfNeeded();
 
   /// @brief Pre-reserves the AudioGraph node vector when node count exceeds
   /// the last ensured capacity. Allocates a new node buffer on the main
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.cpp
new file mode 100644
index 000000000..777f593a4
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.cpp
@@ -0,0 +1,36 @@
+#include <audioapi/core/utils/graph/GraphObject.h>
+#include <vector>
+
+namespace audioapi::utils::graph {
+
+bool GraphObject::canBeDestructed() const {
+  return true;
+}
+
+bool GraphObject::isProcessable() const {
+  return processableState_ != PROCESSABLE_STATE::NOT_PROCESSABLE;
+}
+
+void GraphObject::setProcessableState(PROCESSABLE_STATE state) {
+  processableState_ = state;
+}
+
+const DSPAudioBuffer *GraphObject::getOutput() const {
+  return nullptr;
+}
+
+AudioNode *GraphObject::asAudioNode() {
+  return nullptr;
+}
+
+const AudioNode *GraphObject::asAudioNode() const {
+  return nullptr;
+}
+
+void GraphObject::processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) {
+  // Default: do nothing. Subclasses override for actual processing.
+  (void)inputs;
+  (void)numFrames;
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.h
similarity index 79%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.h
index 02e787bbe..c4feb1975 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/GraphObject.h
@@ -1,7 +1,9 @@
 #pragma once
 
 #include <audioapi/utils/AudioBuffer.hpp>
+
 #include <audioapi/utils/Macros.h>
+#include <cstdint>
 
 #include <ranges>
 #include <vector>
@@ -13,6 +15,7 @@ class AudioNode;
 namespace audioapi::utils::graph {
 
 /// @brief Base class for graph objects (AudioNode, BridgeNode, etc.).
+///
 /// GraphObjects are owned by NodeHandles and stored in AudioGraph's flat vector
 ///
 /// ## Lifecycle
@@ -35,21 +38,24 @@ class GraphObject {
   DELETE_COPY_AND_MOVE(GraphObject);
 
   /// @brief Returns whether this graph object can be safely destroyed.
-  [[nodiscard]] virtual bool canBeDestructed() const {
-    return true;
-  }
+  [[nodiscard]] virtual bool canBeDestructed() const;
+
+  /// @brief Controls how `isProcessable()` is derived for nodes that support conditional processing.
+  enum class PROCESSABLE_STATE : std::uint8_t {
+    ALWAYS_PROCESSABLE,
+    NOT_PROCESSABLE,
+    CONDITIONAL_PROCESSABLE,
+  };
 
   /// @brief Returns whether this node should be processed during audio iteration.
-  [[nodiscard]] virtual bool isProcessable() const {
-    return true;
-  }
+  [[nodiscard]] virtual bool isProcessable() const;
+
+  void setProcessableState(PROCESSABLE_STATE state);
 
   /// @brief Returns the output buffer for this node.
   /// @return Pointer to output buffer, or nullptr if this node should not
   ///         contribute to input mixing for other nodes.
-  [[nodiscard]] virtual const DSPAudioBuffer *getOutput() const {
-    return nullptr;
-  }
+  [[nodiscard]] virtual const DSPAudioBuffer *getOutput() const;
 
   /// @brief Processes this node with the given inputs.
   /// Filters inputs to only those with valid output buffers.
@@ -70,24 +76,19 @@ class GraphObject {
   }
 
   /// @brief Downcast helper for JS thread communication with AudioNode.
-  [[nodiscard]] virtual AudioNode *asAudioNode() {
-    return nullptr;
-  }
+  [[nodiscard]] virtual AudioNode *asAudioNode();
 
   /// @brief Downcast helper for JS thread communication with AudioNode.
-  [[nodiscard]] virtual const AudioNode *asAudioNode() const {
-    return nullptr;
-  }
+  [[nodiscard]] virtual const AudioNode *asAudioNode() const;
 
  protected:
+  friend class HostGraph;
   /// @brief Implementation of processing logic with filtered input buffers.
   /// @param inputs Vector of pointers to valid input buffers
   /// @param numFrames Number of audio frames to process
-  virtual void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) {
-    // Default: do nothing. Subclasses override for actual processing.
-    (void)inputs;
-    (void)numFrames;
-  }
+  virtual void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames);
+
+  PROCESSABLE_STATE processableState_ = PROCESSABLE_STATE::NOT_PROCESSABLE;
 
  private:
   // Reusable buffer for collecting inputs (avoids allocation per frame)
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
new file mode 100644
index 000000000..3f234d0e5
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
@@ -0,0 +1,280 @@
+#include <audioapi/core/AudioContext.h>
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/core/utils/graph/GraphObject.h>
+#include <audioapi/core/utils/graph/HostGraph.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+namespace audioapi::utils::graph {
+
+// =========================================================================
+// Implementation
+// =========================================================================
+
+bool HostGraph::TraversalState::visit(size_t currentTerm) {
+  if (term == currentTerm) {
+    return false;
+  }
+  term = currentTerm;
+  return true;
+}
+
+HostGraph::Node::~Node() {
+  for (Node *input : inputs) {
+    auto &outs = input->outputs;
+    outs.erase(std::remove(outs.begin(), outs.end(), this), outs.end());
+  }
+  for (Node *output : outputs) {
+    auto &inps = output->inputs;
+    inps.erase(std::remove(inps.begin(), inps.end(), this), inps.end());
+  }
+}
+
+HostGraph::HostGraph() = default;
+
+HostGraph::~HostGraph() {
+  for (Node *n : nodes) {
+    delete n;
+  }
+  nodes.clear();
+}
+
+HostGraph::HostGraph(HostGraph &&other) noexcept
+    : nodes(std::move(other.nodes)), edgeCount_(other.edgeCount_), last_term(other.last_term) {
+  other.edgeCount_ = 0;
+  other.last_term = 0;
+}
+
+auto HostGraph::operator=(HostGraph &&other) noexcept -> HostGraph & {
+  if (this != &other) {
+    for (Node *n : nodes) {
+      delete n;
+    }
+    nodes = std::move(other.nodes);
+    edgeCount_ = other.edgeCount_;
+    last_term = other.last_term;
+    other.edgeCount_ = 0;
+    other.last_term = 0;
+  }
+  return *this;
+}
+
+auto HostGraph::addNode(std::shared_ptr<NodeHandle> handle) -> std::pair<Node *, AGEvent> {
+  Node *newNode = new Node();
+  newNode->handle = handle;
+  nodes.push_back(newNode);
+
+  auto event = [h = std::move(handle)](auto &graph, auto &) {
+    graph.addNode(h);
+  };
+
+  return {newNode, std::move(event)};
+}
+
+auto HostGraph::removeNode(Node *node) -> Res {
+  auto it = std::ranges::find(nodes, node);
+  if (it == nodes.end()) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+
+  node->ghost = true;
+
+  return Res::Ok(
+      [h = node->handle](AudioGraph &graph, auto &) { graph[h->index].orphaned = true; });
+}
+
+void HostGraph::markNodesAsProcessing(Node *node) {
+  if (node == nullptr) {
+    return;
+  }
+  if (!node->handle->audioNode->isProcessable()) {
+    node->handle->audioNode->setProcessableState(
+        GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE);
+  }
+  if (node->inputs.empty()) {
+    return;
+  }
+
+  for (Node *input : node->inputs) {
+    markNodesAsProcessing(input);
+  }
+}
+
+auto HostGraph::addEdge(Node *from, Node *to) -> Res {
+  if (std::ranges::find(nodes, from) == nodes.end() ||
+      std::ranges::find(nodes, to) == nodes.end()) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+  if (from->ghost || to->ghost) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+
+  for (Node *out : from->outputs) {
+    if (out == to) {
+      return Res::Err(ResultError::EDGE_ALREADY_EXISTS);
+    }
+  }
+
+  if (hasPath(to, from)) {
+    return Res::Err(ResultError::CYCLE_DETECTED);
+  }
+
+  from->outputs.push_back(to);
+  to->inputs.push_back(from);
+  edgeCount_++;
+
+  // could be problematic, since we are passing raw pointers to the lambda
+  return Res::Ok([from, to](AudioGraph &graph, auto &) {
+    if (!from->handle->audioNode->isProcessable() && to->handle->audioNode->isProcessable()) {
+      HostGraph::markNodesAsProcessing(from);
+    }
+    graph.pool().push(graph[to->handle->index].input_head, from->handle->index);
+    graph.markDirty();
+  });
+}
+
+void HostGraph::markNodesAsNotProcessing(Node *node) {
+  if (node == nullptr) {
+    return;
+  }
+  if (!node->handle->audioNode->isProcessable()) {
+    return;
+  }
+  if (node->handle->audioNode->processableState_ ==
+      GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE) {
+    node->handle->audioNode->setProcessableState(GraphObject::PROCESSABLE_STATE::NOT_PROCESSABLE);
+  }
+  if (node->inputs.empty()) {
+    return;
+  }
+
+  for (Node *input : node->inputs) {
+    markNodesAsNotProcessing(input);
+  }
+}
+
+auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
+  if (std::ranges::find(nodes, from) == nodes.end() ||
+      std::ranges::find(nodes, to) == nodes.end()) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+  if (from->ghost || to->ghost) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+
+  auto itOut = std::ranges::find(from->outputs, to);
+  if (itOut == from->outputs.end()) {
+    return Res::Err(ResultError::EDGE_NOT_FOUND);
+  }
+
+  auto itIn = std::ranges::find(to->inputs, from);
+  if (itIn != to->inputs.end()) {
+    to->inputs.erase(itIn);
+  }
+  from->outputs.erase(itOut);
+  edgeCount_--;
+
+  // could be problematic, since we are passing raw pointers to the lambda
+  return Res::Ok([from, to](AudioGraph &graph, auto &) {
+    if (from != nullptr &&
+        from->handle->audioNode->processableState_ ==
+            GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE) {
+      bool updateProcessingNodes = std::ranges::all_of(
+          from->outputs, [](Node *output) { return !output->handle->audioNode->isProcessable(); });
+      if (updateProcessingNodes) {
+        HostGraph::markNodesAsNotProcessing(from);
+      }
+    }
+    graph.pool().remove(graph[to->handle->index].input_head, from->handle->index);
+    graph.markDirty();
+  });
+}
+
+auto HostGraph::removeAllEdges(Node *from) -> Res {
+  if (std::ranges::find(nodes, from) == nodes.end() || from->ghost) {
+    return Res::Err(ResultError::NODE_NOT_FOUND);
+  }
+
+  auto pairs = std::vector<std::pair<std::uint32_t, std::uint32_t>>();
+  pairs.reserve(from->outputs.size());
+
+  for (Node *to : from->outputs) {
+    auto itIn = std::ranges::find(to->inputs, from);
+    if (itIn != to->inputs.end()) {
+      to->inputs.erase(itIn);
+    }
+    edgeCount_--;
+    pairs.emplace_back(from->handle->index, to->handle->index);
+  }
+  from->outputs.clear();
+
+  return Res::Ok([pairs = std::move(pairs), from](AudioGraph &graph, auto &disposer) mutable {
+    auto *fromNode = from->handle->audioNode->asAudioNode();
+    if (fromNode != nullptr &&
+        fromNode->processableState_ == GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE) {
+      HostGraph::markNodesAsNotProcessing(from);
+    }
+    for (const auto &[fromIdx, toIdx] : pairs) {
+      graph.pool().remove(graph[toIdx].input_head, fromIdx);
+    }
+    graph.markDirty();
+    disposer.dispose(std::move(pairs));
+  });
+}
+
+bool HostGraph::hasPath(Node *start, Node *end) {
+  if (start == end) {
+    return true;
+  }
+
+  last_term++;
+  size_t term = last_term;
+
+  std::vector<Node *> stack;
+  stack.push_back(start);
+  start->traversalState.term = term;
+
+  while (!stack.empty()) {
+    Node *curr = stack.back();
+    stack.pop_back();
+
+    if (curr == end) {
+      return true;
+    }
+
+    for (Node *out : curr->outputs) {
+      if (out->traversalState.visit(term)) {
+        stack.push_back(out);
+      }
+    }
+  }
+  return false;
+}
+
+size_t HostGraph::edgeCount() const {
+  return edgeCount_;
+}
+
+size_t HostGraph::nodeCount() const {
+  return nodes.size();
+}
+
+void HostGraph::collectDisposedNodes() {
+  for (auto it = nodes.begin(); it != nodes.end();) {
+    Node *n = *it;
+    if (n->ghost && n->handle.use_count() == 1) {
+      edgeCount_ -= n->outputs.size();
+      *it = nodes.back();
+      nodes.pop_back();
+      delete n;
+    } else {
+      ++it;
+    }
+  }
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
new file mode 100644
index 000000000..2524b283d
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
@@ -0,0 +1,134 @@
+#pragma once
+
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Disposer.hpp>
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
+#include <audioapi/utils/FatFunction.hpp>
+#include <audioapi/utils/Result.hpp>
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+class GraphCycleDebugTest;
+
+namespace audioapi::utils::graph {
+
+class Graph;
+class TestGraphUtils;
+
+/// @brief Main-thread graph mirror that keeps structure in sync with AudioGraph.
+///
+/// Maintains adjacency lists (inputs / outputs) for O(V+E) cycle detection
+/// via DFS. Every mutation produces an `AGEvent` lambda that, when executed on
+/// the audio thread, applies the same structural change to AudioGraph.
+///
+/// Ghost nodes: when a node is removed it is marked `ghost = true` but its
+/// edges are kept so that `hasPath` still sees paths through nodes that are
+/// alive in AudioGraph. Ghosts are collected once AudioGraph releases its
+/// shared_ptr (detected via `use_count() == 1`).
+///
+/// @note Use through the Graph wrapper for safety.
+class HostGraph {
+ public:
+  enum class ResultError {
+    NODE_NOT_FOUND,
+    CYCLE_DETECTED,
+    EDGE_NOT_FOUND,
+    EDGE_ALREADY_EXISTS,
+  };
+
+  /// Event that modifies AudioGraph to keep it consistent with HostGraph.
+  /// The second argument is the Disposer used to offload buffer deallocation.
+  using AGEvent = FatFunction<32, void(AudioGraph &, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &)>;
+
+  using Res = Result<AGEvent, ResultError>;
+
+  /// Per-node scratch used by graph traversals (e.g. hasPath).
+  struct TraversalState {
+    size_t term = 0;
+
+    /// @return true if node was not yet visited in the current traversal term
+    bool visit(size_t currentTerm);
+  };
+
+  /// A single node in the HostGraph.
+  struct Node {
+    std::vector<Node *> inputs;  // reversed edges
+    std::vector<Node *> outputs; // forward edges
+    TraversalState traversalState;
+    std::shared_ptr<NodeHandle> handle; // shared handle bridging to AudioGraph
+    bool ghost = false; // kept for cycle detection until AudioGraph confirms deletion
+
+#if RN_AUDIO_API_TEST
+    size_t test_node_identifier__ = 0;
+#endif
+
+    /// Destructor tears down all edges touching this node.
+    ~Node();
+  };
+
+  // ── Lifecycle ───────────────────────────────────────────────────────────
+
+  HostGraph();
+  ~HostGraph();
+
+  HostGraph(const HostGraph &) = delete;
+  HostGraph &operator=(const HostGraph &) = delete;
+
+  HostGraph(HostGraph &&other) noexcept;
+  HostGraph &operator=(HostGraph &&other) noexcept;
+
+  // ── Public API ──────────────────────────────────────────────────────────
+
+  /// @brief Adds a new node to the graph.
+  /// @param handle shared handle that bridges HostGraph ↔ AudioGraph
+  /// @return pair of (raw Node pointer, AGEvent to replay on AudioGraph)
+  std::pair<Node *, AGEvent> addNode(std::shared_ptr<NodeHandle> handle);
+
+  /// @brief Removes a node (marks it as ghost, keeps edges for cycle detection).
+  /// @return AGEvent that sets `orphaned = true` on the AudioGraph side.
+  Res removeNode(Node *node);
+
+  /// @brief Adds a directed edge from → to. Rejects cycles and duplicates.
+  /// @return AGEvent that adds the input on the AudioGraph side.
+  Res addEdge(Node *from, Node *to);
+
+  static void markNodesAsProcessing(Node *node);
+
+  /// @brief Removes a directed edge from → to.
+  /// @return AGEvent that removes the input on the AudioGraph side.
+  Res removeEdge(Node *from, Node *to);
+
+  static void markNodesAsNotProcessing(Node *node);
+
+  /// @brief Removes all outgoing edges from `from`.
+  /// @return single AGEvent that removes all inputs on the AudioGraph side, or NODE_NOT_FOUND.
+  Res removeAllEdges(Node *from);
+
+  /// @brief Current number of live (non-ghost) edges.
+  [[nodiscard]] size_t edgeCount() const;
+
+  /// @brief Current number of nodes (including ghosts).
+  [[nodiscard]] size_t nodeCount() const;
+
+ private:
+  std::vector<Node *> nodes;
+  size_t edgeCount_ = 0;
+  size_t last_term = 0; // monotonic counter for traversal freshness
+
+  /// @brief DFS reachability check (traverses ghosts too).
+  bool hasPath(Node *start, Node *end);
+
+  /// @brief Scans ghost nodes and deletes those whose handle has
+  /// `use_count() == 1`, meaning AudioGraph has released its reference.
+  void collectDisposedNodes();
+
+  friend class Graph;
+  friend class TestGraphUtils;
+  friend class HostGraphTest;
+  friend class GraphCycleDebugTest;
+};
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
deleted file mode 100644
index 2d1201748..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.hpp
+++ /dev/null
@@ -1,344 +0,0 @@
-#pragma once
-
-#include <audioapi/core/utils/Constants.h>
-#include <audioapi/core/utils/Disposer.hpp>
-#include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
-#include <audioapi/utils/FatFunction.hpp>
-#include <audioapi/utils/Result.hpp>
-
-#include <algorithm>
-#include <memory>
-#include <utility>
-#include <vector>
-
-class GraphCycleDebugTest;
-
-namespace audioapi::utils::graph {
-
-class HostGraph;
-class Graph;
-class TestGraphUtils;
-
-/// @brief Main-thread graph mirror that keeps structure in sync with AudioGraph.
-///
-/// Maintains adjacency lists (inputs / outputs) for O(V+E) cycle detection
-/// via DFS. Every mutation produces an `AGEvent` lambda that, when executed on
-/// the audio thread, applies the same structural change to AudioGraph.
-///
-/// Ghost nodes: when a node is removed it is marked `ghost = true` but its
-/// edges are kept so that `hasPath` still sees paths through nodes that are
-/// alive in AudioGraph. Ghosts are collected once AudioGraph releases its
-/// shared_ptr (detected via `use_count() == 1`).
-///
-/// @note Use through the Graph wrapper for safety.
-class HostGraph {
- public:
-  enum class ResultError {
-    NODE_NOT_FOUND,
-    CYCLE_DETECTED,
-    EDGE_NOT_FOUND,
-    EDGE_ALREADY_EXISTS,
-  };
-
-  /// Event that modifies AudioGraph to keep it consistent with HostGraph.
-  /// The second argument is the Disposer used to offload buffer deallocation.
-  using AGEvent = FatFunction<32, void(AudioGraph &, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &)>;
-
-  using Res = Result<AGEvent, ResultError>;
-
-  /// Per-node scratch used by graph traversals (e.g. hasPath).
-  struct TraversalState {
-    size_t term = 0;
-
-    /// @return true if node was not yet visited in the current traversal term
-    bool visit(size_t currentTerm);
-  };
-
-  /// A single node in the HostGraph.
-  struct Node {
-    std::vector<Node *> inputs;  // reversed edges
-    std::vector<Node *> outputs; // forward edges
-    TraversalState traversalState;
-    std::shared_ptr<NodeHandle> handle; // shared handle bridging to AudioGraph
-    bool ghost = false; // kept for cycle detection until AudioGraph confirms deletion
-
-#if RN_AUDIO_API_TEST
-    size_t test_node_identifier__ = 0;
-#endif
-
-    /// Destructor tears down all edges touching this node.
-    ~Node();
-  };
-
-  // ── Lifecycle ───────────────────────────────────────────────────────────
-
-  HostGraph() = default;
-  ~HostGraph();
-
-  HostGraph(const HostGraph &) = delete;
-  HostGraph &operator=(const HostGraph &) = delete;
-
-  HostGraph(HostGraph &&other) noexcept;
-  HostGraph &operator=(HostGraph &&other) noexcept;
-
-  // ── Public API ──────────────────────────────────────────────────────────
-
-  /// @brief Adds a new node to the graph.
-  /// @param handle shared handle that bridges HostGraph ↔ AudioGraph
-  /// @return pair of (raw Node pointer, AGEvent to replay on AudioGraph)
-  std::pair<Node *, AGEvent> addNode(std::shared_ptr<NodeHandle> handle);
-
-  /// @brief Removes a node (marks it as ghost, keeps edges for cycle detection).
-  /// @return AGEvent that sets `orphaned = true` on the AudioGraph side.
-  Res removeNode(Node *node);
-
-  /// @brief Adds a directed edge from → to. Rejects cycles and duplicates.
-  /// @return AGEvent that adds the input on the AudioGraph side.
-  Res addEdge(Node *from, Node *to);
-
-  /// @brief Removes a directed edge from → to.
-  /// @return AGEvent that removes the input on the AudioGraph side.
-  Res removeEdge(Node *from, Node *to);
-
-  /// @brief Removes all outgoing edges from `from`.
-  /// @return single AGEvent that removes all inputs on the AudioGraph side, or NODE_NOT_FOUND.
-  Res removeAllEdges(Node *from);
-
-  /// @brief Current number of live (non-ghost) edges.
-  [[nodiscard]] size_t edgeCount() const;
-
-  /// @brief Current number of nodes (including ghosts).
-  [[nodiscard]] size_t nodeCount() const;
-
- private:
-  std::vector<Node *> nodes;
-  size_t edgeCount_ = 0;
-  size_t last_term = 0; // monotonic counter for traversal freshness
-
-  /// @brief DFS reachability check (traverses ghosts too).
-  bool hasPath(Node *start, Node *end);
-
-  /// @brief Scans ghost nodes and deletes those whose handle has
-  /// `use_count() == 1`, meaning AudioGraph has released its reference.
-  void collectDisposedNodes();
-
-  friend class Graph;
-  friend class TestGraphUtils;
-  friend class HostGraphTest;
-  friend class GraphCycleDebugTest;
-};
-
-// =========================================================================
-// Implementation
-// =========================================================================
-
-inline bool HostGraph::TraversalState::visit(size_t currentTerm) {
-  if (term == currentTerm) {
-    return false;
-  }
-  term = currentTerm;
-  return true;
-}
-
-inline HostGraph::Node::~Node() {
-  for (Node *input : inputs) {
-    auto &outs = input->outputs;
-    outs.erase(std::remove(outs.begin(), outs.end(), this), outs.end());
-  }
-  for (Node *output : outputs) {
-    auto &inps = output->inputs;
-    inps.erase(std::remove(inps.begin(), inps.end(), this), inps.end());
-  }
-}
-
-// ── Lifecycle ─────────────────────────────────────────────────────────────
-
-inline HostGraph::~HostGraph() {
-  for (Node *n : nodes) {
-    delete n;
-  }
-  nodes.clear();
-}
-
-inline HostGraph::HostGraph(HostGraph &&other) noexcept
-    : nodes(std::move(other.nodes)), edgeCount_(other.edgeCount_), last_term(other.last_term) {
-  other.edgeCount_ = 0;
-  other.last_term = 0;
-}
-
-inline auto HostGraph::operator=(HostGraph &&other) noexcept -> HostGraph & {
-  if (this != &other) {
-    for (Node *n : nodes) {
-      delete n;
-    }
-    nodes = std::move(other.nodes);
-    edgeCount_ = other.edgeCount_;
-    last_term = other.last_term;
-    other.edgeCount_ = 0;
-    other.last_term = 0;
-  }
-  return *this;
-}
-
-inline auto HostGraph::addNode(std::shared_ptr<NodeHandle> handle) -> std::pair<Node *, AGEvent> {
-  Node *newNode = new Node();
-  newNode->handle = handle;
-  nodes.push_back(newNode);
-
-  auto event = [h = std::move(handle)](auto &graph, auto &) {
-    graph.addNode(h);
-  };
-
-  return {newNode, std::move(event)};
-}
-
-inline auto HostGraph::removeNode(Node *node) -> Res {
-  auto it = std::find(nodes.begin(), nodes.end(), node);
-  if (it == nodes.end()) {
-    return Res::Err(ResultError::NODE_NOT_FOUND);
-  }
-
-  node->ghost = true;
-
-  return Res::Ok(
-      [h = node->handle](AudioGraph &graph, auto &) { graph[h->index].orphaned = true; });
-}
-
-inline auto HostGraph::addEdge(Node *from, Node *to) -> Res {
-  if (std::find(nodes.begin(), nodes.end(), from) == nodes.end() ||
-      std::find(nodes.begin(), nodes.end(), to) == nodes.end()) {
-    return Res::Err(ResultError::NODE_NOT_FOUND);
-  }
-  if (from->ghost || to->ghost) {
-    return Res::Err(ResultError::NODE_NOT_FOUND);
-  }
-
-  for (Node *out : from->outputs) {
-    if (out == to) {
-      return Res::Err(ResultError::EDGE_ALREADY_EXISTS);
-    }
-  }
-
-  if (hasPath(to, from)) {
-    return Res::Err(ResultError::CYCLE_DETECTED);
-  }
-
-  from->outputs.push_back(to);
-  to->inputs.push_back(from);
-  edgeCount_++;
-
-  return Res::Ok([hFrom = from->handle, hTo = to->handle](AudioGraph &graph, auto &) {
-    graph.pool().push(graph[hTo->index].input_head, hFrom->index);
-    graph.markDirty();
-  });
-}
-
-inline auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
-  if (std::find(nodes.begin(), nodes.end(), from) == nodes.end() ||
-      std::find(nodes.begin(), nodes.end(), to) == nodes.end()) {
-    return Res::Err(ResultError::NODE_NOT_FOUND);
-  }
-  if (from->ghost || to->ghost) {
-    return Res::Err(ResultError::NODE_NOT_FOUND);
-  }
-
-  auto itOut = std::find(from->outputs.begin(), from->outputs.end(), to);
-  if (itOut == from->outputs.end()) {
-    return Res::Err(ResultError::EDGE_NOT_FOUND);
-  }
-
-  auto itIn = std::find(to->inputs.begin(), to->inputs.end(), from);
-  if (itIn != to->inputs.end()) {
-    to->inputs.erase(itIn);
-  }
-  from->outputs.erase(itOut);
-  edgeCount_--;
-
-  return Res::Ok([hFrom = from->handle, hTo = to->handle](AudioGraph &graph, auto &) {
-    graph.pool().remove(graph[hTo->index].input_head, hFrom->index);
-    graph.markDirty();
-  });
-}
-
-inline auto HostGraph::removeAllEdges(Node *from) -> Res {
-  if (std::find(nodes.begin(), nodes.end(), from) == nodes.end() || from->ghost) {
-    return Res::Err(ResultError::NODE_NOT_FOUND);
-  }
-
-  auto pairs = std::vector<std::pair<std::uint32_t, std::uint32_t>>();
-  pairs.reserve(from->outputs.size());
-
-  for (Node *to : from->outputs) {
-    auto itIn = std::find(to->inputs.begin(), to->inputs.end(), from);
-    if (itIn != to->inputs.end()) {
-      to->inputs.erase(itIn);
-    }
-    edgeCount_--;
-    pairs.emplace_back(from->handle->index, to->handle->index);
-  }
-  from->outputs.clear();
-
-  return Res::Ok([pairs = std::move(pairs)](AudioGraph &graph, auto &disposer) mutable {
-    for (const auto &[fromIdx, toIdx] : pairs) {
-      graph.pool().remove(graph[toIdx].input_head, fromIdx);
-    }
-    graph.markDirty();
-    disposer.dispose(std::move(pairs));
-  });
-}
-
-inline bool HostGraph::hasPath(Node *start, Node *end) {
-  if (start == end) {
-    return true;
-  }
-
-  last_term++;
-  size_t term = last_term;
-
-  std::vector<Node *> stack;
-  stack.push_back(start);
-  start->traversalState.term = term;
-
-  while (!stack.empty()) {
-    Node *curr = stack.back();
-    stack.pop_back();
-
-    if (curr == end) {
-      return true;
-    }
-
-    for (Node *out : curr->outputs) {
-      if (out->traversalState.visit(term)) {
-        stack.push_back(out);
-      }
-    }
-  }
-  return false;
-}
-
-inline size_t HostGraph::edgeCount() const {
-  return edgeCount_;
-}
-
-inline size_t HostGraph::nodeCount() const {
-  return nodes.size();
-}
-
-inline void HostGraph::collectDisposedNodes() {
-  for (auto it = nodes.begin(); it != nodes.end();) {
-    Node *n = *it;
-    if (n->ghost && n->handle.use_count() == 1) {
-      // ~Node() tears down edges from neighbor lists.
-      // We decrement for each unique edge (stored once in outputs).
-      edgeCount_ -= n->outputs.size();
-      *it = nodes.back();
-      nodes.pop_back();
-      delete n;
-    } else {
-      ++it;
-    }
-  }
-}
-
-} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp
new file mode 100644
index 000000000..0450052f2
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp
@@ -0,0 +1,55 @@
+#include <audioapi/core/utils/graph/HostNode.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi::utils::graph {
+
+HostNode::HostNode(std::shared_ptr<GraphType> graph, std::unique_ptr<GraphObject> graphObject)
+    : graph_(std::move(graph)), node_(graph_->addNode(std::move(graphObject))) {}
+
+HostNode::~HostNode() {
+  if (graph_ && node_) {
+    (void)graph_->removeNode(node_);
+    node_ = nullptr;
+  }
+}
+
+HostNode::HostNode(HostNode &&other) noexcept
+    : graph_(std::move(other.graph_)), node_(other.node_) {
+  other.node_ = nullptr;
+}
+
+HostNode &HostNode::operator=(HostNode &&other) noexcept {
+  if (this != &other) {
+    if (graph_ && node_) {
+      (void)graph_->removeNode(node_);
+    }
+    graph_ = std::move(other.graph_);
+    node_ = other.node_;
+    other.node_ = nullptr;
+  }
+  return *this;
+}
+
+HostNode::Res HostNode::connect(HostNode &other) {
+  return graph_->addEdge(node_, other.node_);
+}
+
+HostNode::Res HostNode::disconnect(HostNode &other) {
+  return graph_->removeEdge(node_, other.node_);
+}
+
+HostNode::Res HostNode::disconnect() {
+  return graph_->removeAllEdges(node_);
+}
+
+HostNode::HNode *HostNode::rawNode() const {
+  return node_;
+}
+
+const std::shared_ptr<HostNode::GraphType> &HostNode::graph() const {
+  return graph_;
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.h
similarity index 67%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.h
index 2790622a7..19442cc78 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.h
@@ -1,6 +1,8 @@
 #pragma once
 
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/GraphObject.h>
+#include <audioapi/utils/Result.hpp>
 
 #include <concepts>
 #include <memory>
@@ -17,10 +19,10 @@ namespace audioapi::utils::graph {
 ///
 /// Host objects that represent audio processing nodes should publicly inherit
 /// from HostNode and pass their payload (GraphObject-derived object) to the
-/// constructor. `connectNode` / `disconnectNode` provide edge management.
+/// constructor. `connect` / `disconnect` provide edge management.
 ///
 /// @note HostNode intentionally does NOT prevent cycles — callers must handle
-/// the error returned by `connectNode()`.
+/// the error returned by `connect()`.
 ///
 /// ## Example usage:
 /// ```cpp
@@ -32,7 +34,7 @@ namespace audioapi::utils::graph {
 /// };
 ///
 /// auto gain = std::make_unique<MyGainNode>(graph, std::move(gainImpl));
-/// gain->connectNode(*destination);
+/// gain->connect(*destination);
 /// gain.reset(); // destructor removes the node from the graph
 /// ```
 class HostNode {
@@ -49,8 +51,7 @@ class HostNode {
   ///                    AudioGraph via NodeHandle)
   explicit HostNode(
       std::shared_ptr<GraphType> graph,
-      std::unique_ptr<GraphObject> graphObject = nullptr)
-      : graph_(std::move(graph)), node_(graph_->addNode(std::move(graphObject))) {}
+      std::unique_ptr<GraphObject> graphObject = nullptr);
 
   template <typename TObject>
     requires std::derived_from<TObject, GraphObject>
@@ -60,64 +61,33 @@ class HostNode {
   /// @brief Destructor removes the node from the graph.
   /// This marks the node as a ghost in HostGraph, and schedules an event
   /// that sets `orphaned = true` on the AudioGraph side.
-  virtual ~HostNode() {
-    if (graph_ && node_) {
-      // Ignore the result — the node should always be found unless the
-      // graph was already torn down.
-      (void)graph_->removeNode(node_);
-      node_ = nullptr;
-    }
-  }
+  virtual ~HostNode();
 
   // Non-copyable (unique graph node identity)
   HostNode(const HostNode &) = delete;
   HostNode &operator=(const HostNode &) = delete;
 
   // Movable
-  HostNode(HostNode &&other) noexcept : graph_(std::move(other.graph_)), node_(other.node_) {
-    other.node_ = nullptr;
-  }
-
-  HostNode &operator=(HostNode &&other) noexcept {
-    if (this != &other) {
-      // Remove current node first
-      if (graph_ && node_) {
-        (void)graph_->removeNode(node_);
-      }
-      graph_ = std::move(other.graph_);
-      node_ = other.node_;
-      other.node_ = nullptr;
-    }
-    return *this;
-  }
+  HostNode(HostNode &&other) noexcept;
+  HostNode &operator=(HostNode &&other) noexcept;
 
   /// @brief Connects this node's output to another node's input (this → other).
   /// @return Ok on success, Err on cycle / duplicate / not-found
-  Res connect(HostNode &other) {
-    return graph_->addEdge(node_, other.node_);
-  }
+  Res connect(HostNode &other);
 
   /// @brief Disconnects this node's output from another node's input.
   /// @return Ok on success, Err on not-found
-  Res disconnect(HostNode &other) {
-    return graph_->removeEdge(node_, other.node_);
-  }
+  Res disconnect(HostNode &other);
 
   /// @brief Disconnects all this node's outputs.
   /// @return Ok on success, Err on not-found
-  Res disconnect() {
-    return graph_->removeAllEdges(node_);
-  }
+  Res disconnect();
 
   /// @brief Returns the raw HostGraph::Node pointer (for advanced usage / testing).
-  [[nodiscard]] HNode *rawNode() const {
-    return node_;
-  }
+  [[nodiscard]] HNode *rawNode() const;
 
   /// @brief Returns the Graph this node belongs to.
-  [[nodiscard]] const std::shared_ptr<GraphType> &graph() const {
-    return graph_;
-  }
+  [[nodiscard]] const std::shared_ptr<GraphType> &graph() const;
 
  protected:
   std::shared_ptr<GraphType> graph_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.cpp
new file mode 100644
index 000000000..62705a91f
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.cpp
@@ -0,0 +1,123 @@
+// InputPool out-of-line definitions (templates remain in InputPool.h).
+
+#include <audioapi/core/utils/graph/InputPool.h>
+
+namespace audioapi::utils::graph {
+
+// ── Lifecycle ─────────────────────────────────────────────────────────────
+
+InputPool::InputPool() = default;
+
+InputPool::~InputPool() {
+  delete[] slots_;
+}
+
+InputPool::InputPool(InputPool &&other) noexcept
+    : slots_(other.slots_), capacity_(other.capacity_), free_head_(other.free_head_) {
+  other.slots_ = nullptr;
+  other.capacity_ = 0;
+  other.free_head_ = kNull;
+}
+
+InputPool &InputPool::operator=(InputPool &&other) noexcept {
+  if (this != &other) {
+    delete[] slots_;
+    slots_ = other.slots_;
+    capacity_ = other.capacity_;
+    free_head_ = other.free_head_;
+    other.slots_ = nullptr;
+    other.capacity_ = 0;
+    other.free_head_ = kNull;
+  }
+  return *this;
+}
+
+// ── Slot allocation ───────────────────────────────────────────────────────
+
+std::uint32_t InputPool::alloc() {
+  if (free_head_ == kNull) {
+    grow(capacity_ == 0 ? 64 : capacity_ * 2);
+  }
+  std::uint32_t idx = free_head_;
+  free_head_ = slots_[idx].next_free;
+  return idx;
+}
+
+void InputPool::free(std::uint32_t idx) {
+  slots_[idx].next_free = free_head_;
+  free_head_ = idx;
+}
+
+// ── Linked-list operations ────────────────────────────────────────────────
+
+void InputPool::push(std::uint32_t &head, std::uint32_t inputVal) {
+  std::uint32_t idx = alloc();
+  slots_[idx].val = inputVal;
+  slots_[idx].next = head;
+  head = idx;
+}
+
+bool InputPool::remove(std::uint32_t &head, std::uint32_t inputVal) {
+  std::uint32_t *prev = &head;
+  std::uint32_t curr = head;
+  while (curr != kNull) {
+    if (slots_[curr].val == inputVal) {
+      *prev = slots_[curr].next;
+      free(curr);
+      return true;
+    }
+    prev = &slots_[curr].next;
+    curr = slots_[curr].next;
+  }
+  return false;
+}
+
+void InputPool::freeAll(std::uint32_t &head) {
+  while (head != kNull) {
+    std::uint32_t nxt = slots_[head].next;
+    free(head);
+    head = nxt;
+  }
+}
+
+bool InputPool::isEmpty(std::uint32_t head) {
+  return head == kNull;
+}
+
+// ── Iteration ─────────────────────────────────────────────────────────────
+
+InputPool::InputView<true> InputPool::view(std::uint32_t head) const {
+  return {.slots = slots_, .head = head};
+}
+
+InputPool::InputView<false> InputPool::mutableView(std::uint32_t head) {
+  return {.slots = slots_, .head = head};
+}
+
+// ── Pool management ───────────────────────────────────────────────────────
+
+std::uint32_t InputPool::capacity() const {
+  return capacity_;
+}
+
+InputPool::Slot *InputPool::adoptBuffer(Slot *newSlots, std::uint32_t newCapacity) {
+  if (slots_ != nullptr) {
+    std::memcpy(newSlots, slots_, capacity_ * sizeof(Slot));
+  }
+  for (std::uint32_t i = capacity_; i < newCapacity; i++) {
+    newSlots[i].next_free = free_head_;
+    free_head_ = i;
+  }
+  Slot *old = slots_;
+  slots_ = newSlots;
+  capacity_ = newCapacity;
+  return old;
+}
+
+void InputPool::grow(std::uint32_t newCapacity) {
+  auto *newSlots = new Slot[newCapacity];
+  Slot *old = adoptBuffer(newSlots, newCapacity);
+  delete[] old;
+}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.h
similarity index 63%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.h
index 93b80821b..aa9724a1c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/InputPool.h
@@ -77,7 +77,7 @@ class InputPool {
 
   // ── Lifecycle ───────────────────────────────────────────────────────────
 
-  InputPool() = default;
+  InputPool();
   ~InputPool();
 
   InputPool(const InputPool &) = delete;
@@ -147,12 +147,6 @@ class InputPool {
   std::uint32_t free_head_ = kNull;
 };
 
-// =========================================================================
-// Implementation
-// =========================================================================
-
-// ── Iterator ──────────────────────────────────────────────────────────────
-
 template <bool Const>
 auto InputPool::Iterator<Const>::operator*() const -> reference {
   return slots[current].val;
@@ -179,8 +173,6 @@ bool InputPool::Iterator<Const>::operator!=(const Iterator &other) const {
   return current != other.current;
 }
 
-// ── InputView ─────────────────────────────────────────────────────────────
-
 template <bool Const>
 auto InputPool::InputView<Const>::begin() const -> Iterator<Const> {
   return {.slots = slots, .current = head};
@@ -191,72 +183,6 @@ auto InputPool::InputView<Const>::end() const -> Iterator<Const> {
   return {.slots = slots, .current = kNull};
 }
 
-// ── Lifecycle ─────────────────────────────────────────────────────────────
-
-inline InputPool::~InputPool() {
-  delete[] slots_;
-}
-
-inline InputPool::InputPool(InputPool &&other) noexcept
-    : slots_(other.slots_), capacity_(other.capacity_), free_head_(other.free_head_) {
-  other.slots_ = nullptr;
-  other.capacity_ = 0;
-  other.free_head_ = kNull;
-}
-
-inline InputPool &InputPool::operator=(InputPool &&other) noexcept {
-  if (this != &other) {
-    delete[] slots_;
-    slots_ = other.slots_;
-    capacity_ = other.capacity_;
-    free_head_ = other.free_head_;
-    other.slots_ = nullptr;
-    other.capacity_ = 0;
-    other.free_head_ = kNull;
-  }
-  return *this;
-}
-
-// ── Slot allocation ───────────────────────────────────────────────────────
-
-inline std::uint32_t InputPool::alloc() {
-  if (free_head_ == kNull) {
-    grow(capacity_ == 0 ? 64 : capacity_ * 2);
-  }
-  std::uint32_t idx = free_head_;
-  free_head_ = slots_[idx].next_free;
-  return idx;
-}
-
-inline void InputPool::free(std::uint32_t idx) {
-  slots_[idx].next_free = free_head_;
-  free_head_ = idx;
-}
-
-// ── Linked-list operations ────────────────────────────────────────────────
-
-inline void InputPool::push(std::uint32_t &head, std::uint32_t inputVal) {
-  std::uint32_t idx = alloc();
-  slots_[idx].val = inputVal;
-  slots_[idx].next = head;
-  head = idx;
-}
-
-inline bool InputPool::remove(std::uint32_t &head, std::uint32_t inputVal) {
-  std::uint32_t *prev = &head;
-  std::uint32_t curr = head;
-  while (curr != kNull) {
-    if (slots_[curr].val == inputVal) {
-      *prev = slots_[curr].next;
-      free(curr);
-      return true;
-    }
-    prev = &slots_[curr].next;
-    curr = slots_[curr].next;
-  }
-  return false;
-}
-
 template <typename Pred>
   requires(std::predicate<Pred, std::uint32_t>)
 void InputPool::removeIf(std::uint32_t &head, Pred pred) {
@@ -274,52 +200,4 @@ void InputPool::removeIf(std::uint32_t &head, Pred pred) {
   }
 }
 
-inline void InputPool::freeAll(std::uint32_t &head) {
-  while (head != kNull) {
-    std::uint32_t nxt = slots_[head].next;
-    free(head);
-    head = nxt;
-  }
-}
-
-inline bool InputPool::isEmpty(std::uint32_t head) {
-  return head == kNull;
-}
-
-// ── Iteration ─────────────────────────────────────────────────────────────
-
-inline InputPool::InputView<true> InputPool::view(std::uint32_t head) const {
-  return {.slots = slots_, .head = head};
-}
-
-inline InputPool::InputView<false> InputPool::mutableView(std::uint32_t head) {
-  return {.slots = slots_, .head = head};
-}
-
-// ── Pool management ───────────────────────────────────────────────────────
-
-inline std::uint32_t InputPool::capacity() const {
-  return capacity_;
-}
-
-inline InputPool::Slot *InputPool::adoptBuffer(Slot *newSlots, std::uint32_t newCapacity) {
-  if (slots_ != nullptr) {
-    std::memcpy(newSlots, slots_, capacity_ * sizeof(Slot));
-  }
-  for (std::uint32_t i = capacity_; i < newCapacity; i++) {
-    newSlots[i].next_free = free_head_;
-    free_head_ = i;
-  }
-  Slot *old = slots_;
-  slots_ = newSlots;
-  capacity_ = newCapacity;
-  return old;
-}
-
-inline void InputPool::grow(std::uint32_t newCapacity) {
-  auto *newSlots = new Slot[newCapacity];
-  Slot *old = adoptBuffer(newSlots, newCapacity);
-  delete[] old;
-}
-
 } // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.cpp
new file mode 100644
index 000000000..075afe5e5
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.cpp
@@ -0,0 +1,10 @@
+#include <audioapi/core/utils/graph/NodeHandle.h>
+#include <memory>
+#include <utility>
+
+namespace audioapi::utils::graph {
+
+NodeHandle::NodeHandle(std::uint32_t index, std::unique_ptr<GraphObject> audioNode)
+    : audioNode(std::move(audioNode)), index(index) {}
+
+} // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.h
similarity index 89%
rename from packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
rename to packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.h
index d2146a420..3421b17fd 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/NodeHandle.h
@@ -1,10 +1,9 @@
 #pragma once
 
-#include <audioapi/core/utils/graph/GraphObject.hpp>
+#include <audioapi/core/utils/graph/GraphObject.h>
 
 #include <cstdint>
 #include <memory>
-#include <utility>
 
 namespace audioapi::utils::graph {
 
@@ -26,8 +25,7 @@ struct NodeHandle {
   std::unique_ptr<GraphObject> audioNode; // payload graph object (may be null in tests)
   std::uint32_t index;                    // current position in AudioGraph::nodes
 
-  NodeHandle(std::uint32_t index, std::unique_ptr<GraphObject> audioNode)
-      : audioNode(std::move(audioNode)), index(index) {}
+  NodeHandle(std::uint32_t index, std::unique_ptr<GraphObject> audioNode);
 };
 
 } // namespace audioapi::utils::graph
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
index 556ee58ec..31ee82fb8 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphFuzzTest.cpp
@@ -1,5 +1,5 @@
-#include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
 #include <gtest/gtest.h>
 #include "TestGraphUtils.h"
 
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
index 47a5165af..bf9ca3030 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/AudioGraphTest.cpp
@@ -1,5 +1,5 @@
-#include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
 #include <gtest/gtest.h>
 #include <memory>
 #include <utility>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
index dd7ef74d2..4f9c9c424 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/BridgeNodeTest.cpp
@@ -1,6 +1,6 @@
-#include <audioapi/core/utils/graph/BridgeNode.hpp>
-#include <audioapi/core/utils/graph/Graph.hpp>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <audioapi/core/utils/graph/BridgeNode.h>
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
 #include <gtest/gtest.h>
 
 #include <algorithm>
@@ -18,14 +18,14 @@ namespace audioapi::utils::graph {
 // A. isProcessable contract
 // =========================================================================
 
-TEST(BridgeNodeContract, MockNodeIsProcessable) {
+TEST(BridgeNodeContract, MockNodeIsNotProcessable) {
   MockNode node;
-  EXPECT_TRUE(node.isProcessable());
+  EXPECT_FALSE(node.isProcessable());
 }
 
-TEST(BridgeNodeContract, BridgeNodeIsProcessable) {
+TEST(BridgeNodeContract, BridgeNodeIsNotProcessable) {
   BridgeNode bridge(nullptr);
-  EXPECT_TRUE(bridge.isProcessable());
+  EXPECT_FALSE(bridge.isProcessable());
 }
 
 TEST(BridgeNodeContract, BridgeNodeIsAlwaysDestructible) {
@@ -186,9 +186,13 @@ class BridgeIterTest : public ::testing::Test {
 };
 
 TEST_F(BridgeIterTest, IterSkipsNonProcessableNodes) {
-  auto *processable1 = addNode(std::make_unique<MockNode>());
+  auto node = std::make_unique<MockNode>();
+  node->setProcessable();
+  auto *processable1 = addNode(std::move(node));
   auto *nonProcessable = addNode(std::make_unique<NonProcessableMockNode>());
-  auto *processable2 = addNode(std::make_unique<MockNode>());
+  auto node2 = std::make_unique<MockNode>();
+  node2->setProcessable();
+  auto *processable2 = addNode(std::move(node2));
 
   ASSERT_TRUE(addEdge(processable1, nonProcessable));
   ASSERT_TRUE(addEdge(nonProcessable, processable2));
@@ -228,7 +232,9 @@ TEST_F(BridgeIterTest, InputsViewMayReferenceBridgeIndices) {
   // iter() yields all processable nodes including bridge
   auto *source = addNode(std::make_unique<MockNode>());
   auto *bridge = addNode(std::make_unique<BridgeNode>(nullptr));
-  auto *owner = addNode(std::make_unique<MockNode>());
+  auto node = std::make_unique<MockNode>();
+  node->setProcessable();
+  auto *owner = addNode(std::move(node));
 
   ASSERT_TRUE(addEdge(source, bridge));
   ASSERT_TRUE(addEdge(bridge, owner));
@@ -344,7 +350,10 @@ class BridgeGraphWrapperTest : public ::testing::Test {
 
 TEST_F(BridgeGraphWrapperTest, ConnectSourceToBridge) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
-  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto node = std::make_unique<MockNode>();
+  // set manually so processable propagates through bridge and source
+  node->setProcessable();
+  auto *owner = graph->addNode(std::move(node));
   auto *param = createParam();
   auto *bridge = createParamBridge(param, owner);
 
@@ -363,7 +372,10 @@ TEST_F(BridgeGraphWrapperTest, ConnectSourceToBridge) {
 
 TEST_F(BridgeGraphWrapperTest, DisconnectSourceFromBridge) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
-  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto node = std::make_unique<MockNode>();
+  // set manually so processable propagates through bridge and source
+  node->setProcessable();
+  auto *owner = graph->addNode(std::move(node));
   auto *param = createParam();
   auto *bridge = createParamBridge(param, owner);
 
@@ -379,7 +391,7 @@ TEST_F(BridgeGraphWrapperTest, DisconnectSourceFromBridge) {
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  EXPECT_EQ(iterCount, 3u); // source + bridge + owner all still exist
+  EXPECT_EQ(iterCount, 2u); // only owner + bridge remains processable
 }
 
 TEST_F(BridgeGraphWrapperTest, DuplicateEdgeToBridgeRejected) {
@@ -415,7 +427,10 @@ TEST_F(BridgeGraphWrapperTest, CycleDetectedThroughBridge) {
 
 TEST_F(BridgeGraphWrapperTest, BridgeRemovalWhenParamDestroyed) {
   auto *source = graph->addNode(std::make_unique<MockNode>());
-  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto node = std::make_unique<MockNode>();
+  // set manually so processable propagates through bridge and source
+  node->setProcessable();
+  auto *owner = graph->addNode(std::move(node));
   auto *param = createParam();
   auto *bridge = createParamBridge(param, owner);
 
@@ -434,13 +449,16 @@ TEST_F(BridgeGraphWrapperTest, BridgeRemovalWhenParamDestroyed) {
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  EXPECT_EQ(iterCount, 2u); // source + owner
+  EXPECT_EQ(iterCount, 1u); // only owner remains processable
 }
 
 TEST_F(BridgeGraphWrapperTest, MultipleSourcesConnectToSameBridge) {
   auto *source1 = graph->addNode(std::make_unique<MockNode>());
   auto *source2 = graph->addNode(std::make_unique<MockNode>());
-  auto *owner = graph->addNode(std::make_unique<MockNode>());
+  auto node = std::make_unique<MockNode>();
+  // set manually so processable propagates through bridge and source
+  node->setProcessable();
+  auto *owner = graph->addNode(std::move(node));
   auto *param = createParam();
   auto *bridge = createParamBridge(param, owner);
 
@@ -464,7 +482,7 @@ TEST_F(BridgeGraphWrapperTest, MultipleSourcesConnectToSameBridge) {
   for (auto &&[graphObject, inputs] : graph->iter()) {
     iterCount++;
   }
-  EXPECT_EQ(iterCount, 4u);
+  EXPECT_EQ(iterCount, 3u); // source1 is unprocessable
 }
 
 TEST_F(BridgeGraphWrapperTest, ConcurrentWithMockGraphProcessor) {
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
index 08b3a537a..2df07f1e3 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphCycleDebugTest.cpp
@@ -1,4 +1,4 @@
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include <gtest/gtest.h>
 #include <algorithm>
 #include <iostream>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
index f1e0810fa..483a6171e 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphFuzzTest.cpp
@@ -1,4 +1,4 @@
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include <gtest/gtest.h>
 #include <chrono>
 #include <memory>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
index 80f3e18ee..4194699cb 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
@@ -1,4 +1,4 @@
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include <gtest/gtest.h>
 #include <atomic>
 #include <chrono>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
index b11a5002f..8fec9e0cf 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/HostGraphTest.cpp
@@ -1,7 +1,7 @@
 #include <audioapi/core/utils/Disposer.hpp>
-#include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/HostGraph.hpp>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <audioapi/core/utils/graph/HostGraph.h>
+#include <audioapi/core/utils/graph/NodeHandle.h>
 #include <gtest/gtest.h>
 #include <memory>
 #include <utility>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h b/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h
index aeb671b67..7dff81a27 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/MockGraphProcessor.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include "AudioThreadGuard.h"
 
 #include <atomic>
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
index 7dff487d5..ca3f42d53 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/TestGraphUtils.h
@@ -9,10 +9,10 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
-#include <audioapi/core/utils/graph/AudioGraph.hpp>
-#include <audioapi/core/utils/graph/BridgeNode.hpp>
-#include <audioapi/core/utils/graph/HostGraph.hpp>
-#include <audioapi/core/utils/graph/HostNode.hpp>
+#include <audioapi/core/utils/graph/AudioGraph.h>
+#include <audioapi/core/utils/graph/BridgeNode.h>
+#include <audioapi/core/utils/graph/HostGraph.h>
+#include <audioapi/core/utils/graph/HostNode.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
 #include <atomic>
 #include <functional>
@@ -57,6 +57,10 @@ struct MockNode : AudioNode {
     destructible_.store(value, std::memory_order_release);
   }
 
+  void setProcessable() {
+    setProcessableState(PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE);
+  }
+
  private:
   void processNode(int) override {}
 
@@ -107,7 +111,9 @@ struct ProcessableMockNode : MockNode {
       ProcessFn processFn = nullptr,
       int initialValue = 0,
       bool destructible = true)
-      : MockNode(destructible), value(initialValue), processFn_(std::move(processFn)) {}
+      : MockNode(destructible), value(initialValue), processFn_(std::move(processFn)) {
+    setProcessable();
+  }
 
   /// @brief Called by the audio thread with an input range from `Graph::iter()`.
   ///
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
index 4f346022f..1ebe86423 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
@@ -10,7 +10,7 @@ typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
 #include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/core/utils/graph/NodeHandle.hpp>
+#include <audioapi/core/utils/graph/NodeHandle.h>
 #include <audioapi/utils/Result.hpp>
 
 namespace audioapi {

From bbb909ff3a9186565c6ca24b6394597426e5fe5f Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Tue, 7 Apr 2026 19:26:43 +0200
Subject: [PATCH 34/38] feat: delay node

---
 .../HostObjects/AudioNodeHostObject.cpp       | 21 +++++
 .../effects/DelayNodeHostObject.cpp           | 21 ++++-
 .../HostObjects/effects/DelayNodeHostObject.h |  6 ++
 .../cpp/audioapi/core/effects/DelayNode.cpp   | 80 +++----------------
 .../cpp/audioapi/core/effects/DelayNode.h     | 16 ++--
 .../audioapi/core/effects/delay/DelayLine.h   | 66 +++++++++++++++
 .../core/effects/delay/DelayReader.cpp        | 34 ++++++++
 .../audioapi/core/effects/delay/DelayReader.h | 27 +++++++
 .../core/effects/delay/DelayRingBufferOp.h    | 51 ++++++++++++
 .../core/effects/delay/DelayWriter.cpp        | 39 +++++++++
 .../audioapi/core/effects/delay/DelayWriter.h | 28 +++++++
 .../delay/host_nodes/DelayReaderHostNode.cpp  | 17 ++++
 .../delay/host_nodes/DelayReaderHostNode.h    | 17 ++++
 .../delay/host_nodes/DelayWriterHostNode.cpp  | 17 ++++
 .../delay/host_nodes/DelayWriterHostNode.h    | 17 ++++
 .../cpp/audioapi/core/utils/graph/Graph.cpp   |  8 +-
 .../cpp/audioapi/core/utils/graph/Graph.h     | 16 +---
 .../audioapi/core/utils/graph/HostGraph.cpp   |  2 +-
 .../cpp/audioapi/core/utils/graph/HostGraph.h |  4 +-
 .../cpp/test/src/core/effects/DelayTest.cpp   | 61 +++++++++++---
 .../test/src/graph/GraphNodeGrowthTest.cpp    |  2 +-
 21 files changed, 440 insertions(+), 110 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayLine.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayRingBufferOp.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h

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
index 8aa8e75c8..24b5a7d38 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.cpp
@@ -1,8 +1,11 @@
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
+#include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <audioapi/core/AudioNode.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h>
 
 #include <memory>
 #include <utility>
@@ -61,6 +64,24 @@ JSI_PROPERTY_GETTER_IMPL(AudioNodeHostObject, channelInterpretation) {
 
 JSI_HOST_FUNCTION_IMPL(AudioNodeHostObject, connect) {
   auto obj = args[0].getObject(runtime);
+
+  // delay node is being connected to something, use delay reader
+  if (auto *fromNode = dynamic_cast<DelayNodeHostObject *>(this); fromNode != nullptr) {
+    auto delayReader = fromNode->delayReaderHostNode_;
+    auto toNode = obj.getHostObject<AudioNodeHostObject>(runtime);
+    delayReader->connect(*toNode);
+    return jsi::Value::undefined();
+  }
+
+  // something is being connected to a delay node, use delay writer
+  if (auto *toNode = dynamic_cast<DelayNodeHostObject *>(
+          obj.getHostObject<AudioNodeHostObject>(runtime).get());
+      toNode != nullptr) {
+    auto delayWriter = toNode->delayWriterHostNode_;
+    connect(*delayWriter);
+    return jsi::Value::undefined();
+  }
+
   if (obj.isHostObject<AudioNodeHostObject>(runtime)) {
     auto node = obj.getHostObject<AudioNodeHostObject>(runtime);
     connect(*node);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
index ee1fd5de5..09902f5e3 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
@@ -2,9 +2,13 @@
 #include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h>
 #include <audioapi/types/NodeOptions.h>
 
 #include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -15,9 +19,20 @@ DelayNodeHostObject::DelayNodeHostObject(
           context->getGraph(),
           std::make_unique<DelayNode>(context, options),
           options) {
-  auto delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
+  auto *delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
   delayTimeParam_ =
       std::make_shared<AudioParamHostObject>(graph_, node_, delayNode->getDelayTimeParam());
+
+  auto delayBuffer = std::make_shared<AudioBuffer>(
+      static_cast<size_t>(options.maxDelayTime * context->getSampleRate() + 1),
+      channelCount_,
+      context->getSampleRate());
+
+  delayWriterHostNode_ =
+      std::make_shared<DelayWriterHostNode>(graph_, std::move(delayNode->delayWriter_));
+  delayReaderHostNode_ =
+      std::make_shared<DelayReaderHostNode>(graph_, std::move(delayNode->delayReader_));
+
   addGetters(JSI_EXPORT_PROPERTY_GETTER(DelayNodeHostObject, delayTime));
 }
 
@@ -26,9 +41,9 @@ JSI_PROPERTY_GETTER_IMPL(DelayNodeHostObject, delayTime) {
 }
 
 size_t DelayNodeHostObject::getSizeInBytes() const {
-  auto delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
+  auto *delayNode = static_cast<DelayNode *>(node_->handle->audioNode->asAudioNode());
   auto base = sizeof(float) * delayNode->getDelayTimeParam()->getMaxValue();
-  return base * delayNode->getContextSampleRate();
+  return static_cast<size_t>(base * delayNode->getContextSampleRate());
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.h
index df72a99bf..2b44dc123 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.h
@@ -10,6 +10,9 @@ using namespace facebook;
 struct DelayOptions;
 class BaseAudioContext;
 class AudioParamHostObject;
+class DelayLine;
+class DelayWriterHostNode;
+class DelayReaderHostNode;
 
 class DelayNodeHostObject : public AudioNodeHostObject {
  public:
@@ -20,8 +23,11 @@ class DelayNodeHostObject : public AudioNodeHostObject {
   [[nodiscard]] size_t getSizeInBytes() const;
 
   JSI_PROPERTY_GETTER_DECL(delayTime);
+  std::shared_ptr<DelayWriterHostNode> delayWriterHostNode_;
+  std::shared_ptr<DelayReaderHostNode> delayReaderHostNode_;
 
  private:
   std::shared_ptr<AudioParamHostObject> delayTimeParam_;
+  std::shared_ptr<DelayLine> delayLine_;
 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
index 14cb88b40..e754b78af 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
@@ -1,5 +1,9 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/core/effects/delay/DelayReader.h>
+#include <audioapi/core/effects/delay/DelayRingBufferOp.h>
+#include <audioapi/core/effects/delay/DelayWriter.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
@@ -18,80 +22,14 @@ DelayNode::DelayNode(const std::shared_ptr<BaseAudioContext> &context, const Del
                   options.maxDelayTime * context->getSampleRate() +
                   1), // +1 to enable delayTime equal to maxDelayTime
               channelCount_,
-              context->getSampleRate())) {}
+              context->getSampleRate())) {
+  delayLine_ = std::make_shared<DelayLine>(delayBuffer_, delayTimeParam_);
+  delayReader_ = std::make_unique<DelayReader>(context, options, delayLine_);
+  delayWriter_ = std::make_unique<DelayWriter>(context, options, delayLine_);
+}
 
 std::shared_ptr<AudioParam> DelayNode::getDelayTimeParam() const {
   return delayTimeParam_;
 }
 
-void DelayNode::delayBufferOperation(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess,
-    size_t &operationStartingIndex,
-    DelayNode::BufferAction action) {
-  size_t processingBufferStartIndex = 0;
-
-  // handle buffer wrap around
-  if (operationStartingIndex + framesToProcess > delayBuffer_->getSize()) {
-    int framesToEnd =
-        static_cast<int>(operationStartingIndex + framesToProcess - delayBuffer_->getSize());
-
-    if (action == BufferAction::WRITE) {
-      delayBuffer_->sum(
-          *processingBuffer, processingBufferStartIndex, operationStartingIndex, framesToEnd);
-    } else { // READ
-      processingBuffer->sum(
-          *delayBuffer_, operationStartingIndex, processingBufferStartIndex, framesToEnd);
-    }
-
-    operationStartingIndex = 0;
-    processingBufferStartIndex += framesToEnd;
-    framesToProcess -= framesToEnd;
-  }
-
-  if (action == BufferAction::WRITE) {
-    delayBuffer_->sum(
-        *processingBuffer, processingBufferStartIndex, operationStartingIndex, framesToProcess);
-    processingBuffer->zero();
-  } else { // READ
-    processingBuffer->sum(
-        *delayBuffer_, operationStartingIndex, processingBufferStartIndex, framesToProcess);
-    delayBuffer_->zero(operationStartingIndex, framesToProcess);
-  }
-
-  operationStartingIndex += framesToProcess;
-}
-
-// delay buffer always has channelCount_ channels
-// processing is split into two parts
-// 1. writing to delay buffer (mixing if needed) from processing buffer
-// 2. reading from delay buffer to processing buffer (mixing if needed) with delay
-void DelayNode::processNode(int framesToProcess) {
-  // handling tail processing
-  if (signalledToStop_) {
-    if (remainingFrames_ <= 0) {
-      signalledToStop_ = false;
-      return;
-    }
-
-    delayBufferOperation(audioBuffer_, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
-    remainingFrames_ -= framesToProcess;
-    return;
-  }
-
-  // normal processing
-  std::shared_ptr<BaseAudioContext> context = context_.lock();
-  if (context == nullptr) {
-    audioBuffer_->zero();
-    return;
-  }
-
-  auto delayTime = delayTimeParam_->processKRateParam(framesToProcess, context->getCurrentTime());
-  size_t writeIndex =
-      static_cast<size_t>(static_cast<float>(readIndex_) + delayTime * context->getSampleRate()) %
-      delayBuffer_->getSize();
-  delayBufferOperation(audioBuffer_, framesToProcess, writeIndex, DelayNode::BufferAction::WRITE);
-  delayBufferOperation(audioBuffer_, framesToProcess, readIndex_, DelayNode::BufferAction::READ);
-}
-
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
index b0c39fe52..36680b24f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
@@ -2,6 +2,8 @@
 
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/delay/DelayReader.h>
+#include <audioapi/core/effects/delay/DelayWriter.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
 #include <memory>
@@ -9,6 +11,7 @@
 namespace audioapi {
 
 struct DelayOptions;
+class DelayLine;
 
 class DelayNode : public AudioNode {
  public:
@@ -16,16 +19,17 @@ class DelayNode : public AudioNode {
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const;
 
+  std::shared_ptr<DelayLine> delayLine_;
+  std::unique_ptr<DelayReader> delayReader_;
+  std::unique_ptr<DelayWriter> delayWriter_;
+
  protected:
-  void processNode(int framesToProcess) override;
+  void processNode(int framesToProcess) override {
+    // noop
+  };
 
  private:
   enum class BufferAction : uint8_t { READ, WRITE };
-  void delayBufferOperation(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess,
-      size_t &operationStartingIndex,
-      BufferAction action);
   const std::shared_ptr<AudioParam> delayTimeParam_;
   std::shared_ptr<AudioBuffer> delayBuffer_;
   size_t readIndex_ = 0;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayLine.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayLine.h
new file mode 100644
index 000000000..31e578272
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayLine.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/utils/AudioBuffer.hpp>
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+/// Shared delay ring + delay-time param.
+///
+/// Two logical read positions:
+/// - `readIndex_` — advanced by DelayReader after each READ (live read head).
+/// - `writeIndex_` — copy of `readIndex_` at the start of each audio quantum
+///   (`syncReadSnapshotForQuantum` keyed by context sample frame). DelayWriter uses this to
+///   compute write position so writer/reader order in the graph does not matter.
+class DelayLine {
+ public:
+  DelayLine(std::shared_ptr<AudioBuffer> buffer, const std::shared_ptr<AudioParam> &delayTimeParam)
+      : buffer_(std::move(buffer)), delayTimeParam_(delayTimeParam) {}
+
+  [[nodiscard]] std::shared_ptr<AudioBuffer> getBuffer() const {
+    return buffer_;
+  }
+
+  [[nodiscard]] std::shared_ptr<AudioParam> getDelayTimeParam() const {
+    return delayTimeParam_;
+  }
+
+  /// Call at the start of DelayReader/DelayWriter `processNode` (same `currentSampleFrame` for
+  /// the whole graph pass). First touch each quantum refreshes `readSnapshotForWrite_` from
+  /// `readIndex_`.
+  void syncReadSnapshotForQuantum(size_t currentSampleFrame) {
+    if (currentSampleFrame != quantumSampleFrame_) {
+      writeIndex_ = readIndex_;
+      quantumSampleFrame_ = currentSampleFrame;
+    }
+  }
+
+  /// Read head used by DelayWriter for `(snapshot + delaySamples) % N` (not `readIndex_` after
+  /// reader may have advanced).
+  [[nodiscard]] size_t readSnapshotForWrite() const {
+    return writeIndex_;
+  }
+
+  [[nodiscard]] size_t &readIndex() {
+    return readIndex_;
+  }
+
+  [[nodiscard]] size_t readIndex() const {
+    return readIndex_;
+  }
+
+ private:
+  std::shared_ptr<AudioBuffer> buffer_;
+  std::shared_ptr<AudioParam> delayTimeParam_;
+
+  size_t readIndex_{0};
+  size_t writeIndex_{0};
+  size_t quantumSampleFrame_{std::numeric_limits<size_t>::max()};
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.cpp
new file mode 100644
index 000000000..20636840c
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.cpp
@@ -0,0 +1,34 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/core/effects/delay/DelayReader.h>
+#include <audioapi/core/effects/delay/DelayRingBufferOp.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+DelayReader::DelayReader(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AudioNodeOptions &options,
+    std::shared_ptr<DelayLine> delayLine)
+    : AudioNode(context, options), delayLine_(std::move(delayLine)) {}
+
+void DelayReader::processNode(int framesToProcess) {
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    audioBuffer_->zero();
+    return;
+  }
+
+  delayLine_->syncReadSnapshotForQuantum(context->getCurrentSampleFrame());
+
+  auto delayBuffer = delayLine_->getBuffer();
+  size_t &readIdx = delayLine_->readIndex();
+
+  delay_ring::bufferOperation(
+      delayBuffer, audioBuffer_, framesToProcess, readIdx, delay_ring::BufferAction::READ);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.h
new file mode 100644
index 000000000..1fcc88c12
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayReader.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <memory>
+
+namespace audioapi {
+
+class BaseAudioContext;
+
+/// Reads from the delay line at `delayLine->readIndex()` into the node buffer
+class DelayReader : public AudioNode {
+ public:
+  explicit DelayReader(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioNodeOptions &options,
+      std::shared_ptr<DelayLine> delayLine);
+
+  void processNode(int framesToProcess) override;
+
+ private:
+  std::shared_ptr<DelayLine> delayLine_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayRingBufferOp.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayRingBufferOp.h
new file mode 100644
index 000000000..f504593ac
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayRingBufferOp.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <audioapi/utils/AudioBuffer.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+namespace audioapi::delay_ring {
+
+enum class BufferAction : std::uint8_t { READ, WRITE };
+
+/// Ring-buffer read/write: splits at the end of the ring, then advances the head with wrap.
+inline void bufferOperation(
+    const std::shared_ptr<AudioBuffer> &delayBuffer,
+    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+    int framesToProcess,
+    size_t &operationStartingIndex,
+    BufferAction action) {
+  size_t processingBufferStartIndex = 0;
+
+  const size_t bufferSize = delayBuffer->getSize();
+  if (operationStartingIndex + static_cast<size_t>(framesToProcess) > bufferSize) {
+    const int tail = static_cast<int>(bufferSize - operationStartingIndex);
+
+    if (action == BufferAction::WRITE) {
+      delayBuffer->sum(*processingBuffer, processingBufferStartIndex, operationStartingIndex, tail);
+    } else {
+      processingBuffer->sum(*delayBuffer, operationStartingIndex, processingBufferStartIndex, tail);
+    }
+
+    operationStartingIndex = 0;
+    processingBufferStartIndex += static_cast<size_t>(tail);
+    framesToProcess -= tail;
+  }
+
+  if (action == BufferAction::WRITE) {
+    delayBuffer->sum(
+        *processingBuffer, processingBufferStartIndex, operationStartingIndex, framesToProcess);
+    processingBuffer->zero();
+  } else {
+    processingBuffer->sum(
+        *delayBuffer, operationStartingIndex, processingBufferStartIndex, framesToProcess);
+    delayBuffer->zero(operationStartingIndex, static_cast<size_t>(framesToProcess));
+  }
+
+  operationStartingIndex =
+      (operationStartingIndex + static_cast<size_t>(framesToProcess)) % bufferSize;
+}
+
+} // namespace audioapi::delay_ring
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp
new file mode 100644
index 000000000..ed4bba8cc
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp
@@ -0,0 +1,39 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/core/effects/delay/DelayRingBufferOp.h>
+#include <audioapi/core/effects/delay/DelayWriter.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+DelayWriter::DelayWriter(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AudioNodeOptions &options,
+    std::shared_ptr<DelayLine> delayLine)
+    : AudioNode(context, options), delayLine_(std::move(delayLine)) {}
+
+void DelayWriter::processNode(int framesToProcess) {
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    audioBuffer_->zero();
+    return;
+  }
+
+  delayLine_->syncReadSnapshotForQuantum(context->getCurrentSampleFrame());
+
+  auto delayBuffer = delayLine_->getBuffer();
+  auto delayTime = delayLine_->getDelayTimeParam()->processKRateParam(
+      framesToProcess, context->getCurrentTime());
+  const size_t readForWrite = delayLine_->readSnapshotForWrite();
+  size_t writeIndex =
+      static_cast<size_t>(static_cast<float>(readForWrite) + delayTime * context->getSampleRate()) %
+      delayBuffer->getSize();
+
+  delay_ring::bufferOperation(
+      delayBuffer, audioBuffer_, framesToProcess, writeIndex, delay_ring::BufferAction::WRITE);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h
new file mode 100644
index 000000000..fa7616e3a
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/types/NodeOptions.h>
+
+#include <memory>
+
+namespace audioapi {
+
+class BaseAudioContext;
+
+/// Writes the node’s input into the delay ring at `writeIndex = (readIndex + delaySamples) % N`
+/// (same rule as DelayNode).
+class DelayWriter : public AudioNode {
+ public:
+  explicit DelayWriter(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioNodeOptions &options,
+      std::shared_ptr<DelayLine> delayLine);
+
+  void processNode(int framesToProcess) override;
+
+ private:
+  std::shared_ptr<DelayLine> delayLine_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.cpp
new file mode 100644
index 000000000..288b66dc0
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.cpp
@@ -0,0 +1,17 @@
+#include <audioapi/core/effects/delay/DelayReader.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h>
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/HostNode.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+class DelayReader;
+
+DelayReaderHostNode::DelayReaderHostNode(
+    const std::shared_ptr<utils::graph::Graph> &graph,
+    std::unique_ptr<DelayReader> delayReader)
+    : utils::graph::HostNode(graph, std::move(delayReader)) {}
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h
new file mode 100644
index 000000000..300f66607
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayReaderHostNode.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/HostNode.h>
+#include <memory>
+
+namespace audioapi {
+
+class DelayReader;
+
+class DelayReaderHostNode : public utils::graph::HostNode {
+ public:
+  explicit DelayReaderHostNode(
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      std::unique_ptr<DelayReader> delayReader);
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.cpp
new file mode 100644
index 000000000..119f2f9bd
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.cpp
@@ -0,0 +1,17 @@
+#include <audioapi/core/effects/delay/DelayWriter.h>
+#include <audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h>
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/HostNode.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+class DelayWriter;
+
+DelayWriterHostNode::DelayWriterHostNode(
+    const std::shared_ptr<utils::graph::Graph> &graph,
+    std::unique_ptr<DelayWriter> delayWriter)
+    : utils::graph::HostNode(graph, std::move(delayWriter)) {}
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h
new file mode 100644
index 000000000..820187649
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/host_nodes/DelayWriterHostNode.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/HostNode.h>
+#include <memory>
+
+namespace audioapi {
+
+class DelayWriter;
+
+class DelayWriterHostNode : public utils::graph::HostNode {
+ public:
+  explicit DelayWriterHostNode(
+      const std::shared_ptr<utils::graph::Graph> &graph,
+      std::unique_ptr<DelayWriter> delayWriter);
+};
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
index f3522e2dd..3c9df8345 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
@@ -119,7 +119,13 @@ void Graph::sendNodeGrowIfNeeded() {
   auto nodes = static_cast<std::uint32_t>(hostGraph.nodeCount());
   if (nodes > nodeCapacity_) {
     std::uint32_t newCap = std::max(static_cast<std::uint32_t>(nodes * 2), std::uint32_t{64});
-    eventSender_.send([newCap](AudioGraph &graph, auto &) { graph.reserveNodes(newCap); });
+    auto buf = AudioGraph::makeNodeBuffer(newCap);
+    eventSender_.send(
+        [buf = std::move(buf)](
+            AudioGraph &graph, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &disposer) mutable {
+          auto old = graph.adoptNodeBuffer(std::move(buf));
+          disposer.dispose(std::move(old));
+        });
     nodeCapacity_ = newCap;
   }
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
index 1af915236..7769e8524 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
@@ -12,7 +12,6 @@
 #include <algorithm>
 #include <cstdint>
 #include <memory>
-#include <new>
 #include <utility>
 
 namespace audioapi::utils::graph {
@@ -151,20 +150,7 @@ class Graph {
   /// thread and sends it as an AGEvent through the event channel. The old
   /// buffer is sent to the Disposer for deallocation on a separate thread —
   /// never on the audio thread.
-  void sendNodeGrowIfNeeded() {
-    auto nodes = static_cast<std::uint32_t>(hostGraph.nodeCount());
-    if (nodes > nodeCapacity_) {
-      std::uint32_t newCap = std::max(static_cast<std::uint32_t>(nodes * 2), std::uint32_t{64});
-      auto buf = AudioGraph::makeNodeBuffer(newCap);
-      eventSender_.send(
-          [buf = std::move(buf)](
-              AudioGraph &graph, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> &disposer) mutable {
-            auto old = graph.adoptNodeBuffer(std::move(buf));
-            disposer.dispose(std::move(old));
-          });
-      nodeCapacity_ = newCap;
-    }
-  }
+  void sendNodeGrowIfNeeded();
 
   // ── Bridge tracking (main thread only) ──────────────────────────────────
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
index 3f234d0e5..a9e11b4f5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
@@ -130,7 +130,7 @@ auto HostGraph::addEdge(Node *from, Node *to) -> Res {
   // could be problematic, since we are passing raw pointers to the lambda
   return Res::Ok([from, to](AudioGraph &graph, auto &) {
     if (!from->handle->audioNode->isProcessable() && to->handle->audioNode->isProcessable()) {
-      HostGraph::markNodesAsProcessing(from);
+      markNodesAsProcessing(from);
     }
     graph.pool().push(graph[to->handle->index].input_head, from->handle->index);
     graph.markDirty();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
index 2524b283d..1545af377 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
@@ -32,7 +32,7 @@ class TestGraphUtils;
 /// @note Use through the Graph wrapper for safety.
 class HostGraph {
  public:
-  enum class ResultError {
+  enum class ResultError : uint8_t {
     NODE_NOT_FOUND,
     CYCLE_DETECTED,
     EDGE_NOT_FOUND,
@@ -95,12 +95,14 @@ class HostGraph {
   /// @return AGEvent that adds the input on the AudioGraph side.
   Res addEdge(Node *from, Node *to);
 
+  /// @brief Marks a node as processing and recursively marks all inputs as processing.
   static void markNodesAsProcessing(Node *node);
 
   /// @brief Removes a directed edge from → to.
   /// @return AGEvent that removes the input on the AudioGraph side.
   Res removeEdge(Node *from, Node *to);
 
+  /// @brief Marks a node as not processing and recursively marks all inputs as not processing.
   static void markNodesAsNotProcessing(Node *node);
 
   /// @brief Removes all outgoing edges from `from`.
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
index 0c3d7f85e..389a860a6 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/DelayTest.cpp
@@ -1,6 +1,8 @@
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/core/effects/delay/DelayReader.h>
+#include <audioapi/core/effects/delay/DelayWriter.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
@@ -29,22 +31,59 @@ class DelayTest : public ::testing::Test {
   }
 };
 
+class TestableDelayWriter : public DelayWriter {
+ public:
+  explicit TestableDelayWriter(
+      std::shared_ptr<BaseAudioContext> context,
+      const DelayOptions &options,
+      std::shared_ptr<DelayLine> delayLine)
+      : DelayWriter(context, options, delayLine) {}
+
+  void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
+    audioBuffer_ = input;
+  }
+};
+
+class TestableDelayReader : public DelayReader {
+ public:
+  explicit TestableDelayReader(
+      std::shared_ptr<BaseAudioContext> context,
+      const DelayOptions &options,
+      std::shared_ptr<DelayLine> delayLine)
+      : DelayReader(context, options, delayLine) {}
+
+  auto getOutputBuffer() {
+    return audioBuffer_;
+  }
+};
+
 class TestableDelayNode : public DelayNode {
  public:
   explicit TestableDelayNode(std::shared_ptr<BaseAudioContext> context, const DelayOptions &options)
-      : DelayNode(context, options) {}
+      : DelayNode(context, options),
+        testableDelayReader_(context, options, delayLine_),
+        testableDelayWriter_(context, options, delayLine_) {}
 
   void setDelayTimeParam(float value) {
     getDelayTimeParam()->setValue(value);
   }
 
   void setInputBuffer(const std::shared_ptr<DSPAudioBuffer> &input) {
-    audioBuffer_ = input;
+    testableDelayWriter_.setInputBuffer(input);
+  }
+
+  auto getOutputBuffer() {
+    return testableDelayReader_.getOutputBuffer();
   }
 
   void processNode(int framesToProcess) override {
-    DelayNode::processNode(framesToProcess);
+    testableDelayWriter_.processNode(framesToProcess);
+    testableDelayReader_.processNode(framesToProcess);
   }
+
+ private:
+  TestableDelayWriter testableDelayWriter_;
+  TestableDelayReader testableDelayReader_;
 };
 
 TEST_F(DelayTest, DelayCanBeCreated) {
@@ -54,7 +93,7 @@ TEST_F(DelayTest, DelayCanBeCreated) {
 
 TEST_F(DelayTest, DelayWithZeroDelayOutputsInputSignal) {
   static constexpr float DELAY_TIME = 0.0f;
-  static constexpr int FRAMES_TO_PROCESS = 4;
+  static constexpr int FRAMES_TO_PROCESS = 128;
   auto options = DelayOptions();
   options.maxDelayTime = 1.0f;
   auto delayNode = TestableDelayNode(context, options);
@@ -74,8 +113,8 @@ TEST_F(DelayTest, DelayWithZeroDelayOutputsInputSignal) {
 }
 
 TEST_F(DelayTest, DelayAppliesTimeShiftCorrectly) {
-  float DELAY_TIME = (128.0 / context->getSampleRate()) * 0.5;
   static constexpr int FRAMES_TO_PROCESS = 128;
+  float DELAY_TIME = (FRAMES_TO_PROCESS / context->getSampleRate()) * 0.5;
   auto options = DelayOptions();
   options.maxDelayTime = 1.0f;
   auto delayNode = TestableDelayNode(context, options);
@@ -102,10 +141,10 @@ TEST_F(DelayTest, DelayAppliesTimeShiftCorrectly) {
 }
 
 TEST_F(DelayTest, DelayHandlesTailCorrectly) {
-  float DELAY_TIME = (128.0 / context->getSampleRate()) * 0.5;
   static constexpr int FRAMES_TO_PROCESS = 128;
+  float DELAY_TIME = (FRAMES_TO_PROCESS / context->getSampleRate()) * 0.5;
   auto options = DelayOptions();
-  options.maxDelayTime = 1.0f;
+  options.maxDelayTime = (FRAMES_TO_PROCESS / context->getSampleRate()) * 3;
   auto delayNode = TestableDelayNode(context, options);
   delayNode.setDelayTimeParam(DELAY_TIME);
 
@@ -116,17 +155,17 @@ TEST_F(DelayTest, DelayHandlesTailCorrectly) {
 
   delayNode.setInputBuffer(buffer);
   delayNode.processNode(FRAMES_TO_PROCESS);
-  // Second call uses the result of the first call as input (same as old behavior
-  // where the same buffer object was passed to both calls)
+  // Second call uses the result of the first call as input
+  delayNode.getOutputBuffer()->zero();
   delayNode.processNode(FRAMES_TO_PROCESS);
   auto resultBuffer = delayNode.getOutputBuffer();
   for (size_t i = 0; i < FRAMES_TO_PROCESS; ++i) {
-    if (i < FRAMES_TO_PROCESS / 2) { // First 64 samples should be 2nd part of buffer
+    if (i < FRAMES_TO_PROCESS / 2) { // First samples should be 2nd part of buffer
       EXPECT_FLOAT_EQ(
           (*resultBuffer->getChannel(0))[i], static_cast<float>(i + 1 + FRAMES_TO_PROCESS / 2.0));
     } else {
       EXPECT_FLOAT_EQ((*resultBuffer->getChannel(0))[i],
-                      0.0f); // Last 64 samples should be zero
+                      0.0f); // Last samples should be zero
     }
   }
 }
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp
index 4b9325ab8..013035e2b 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphNodeGrowthTest.cpp
@@ -1,4 +1,4 @@
-#include <audioapi/core/utils/graph/Graph.hpp>
+#include <audioapi/core/utils/graph/Graph.h>
 #include <gtest/gtest.h>
 #include <chrono>
 #include <memory>

From ccd40a76615cf210298635547c4089bd73bd3d95 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 17 Apr 2026 14:51:19 +0200
Subject: [PATCH 35/38] feat: enabling delay both nodes

---
 .../effects/DelayNodeHostObject.cpp           | 13 +++++-
 .../cpp/audioapi/core/utils/graph/Graph.cpp   |  4 ++
 .../cpp/audioapi/core/utils/graph/Graph.h     |  7 ++++
 .../audioapi/core/utils/graph/HostGraph.cpp   | 42 +++++++++++++++----
 .../cpp/audioapi/core/utils/graph/HostGraph.h | 21 +++++++++-
 5 files changed, 75 insertions(+), 12 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
index 09902f5e3..9cfef4281 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp
@@ -28,10 +28,19 @@ DelayNodeHostObject::DelayNodeHostObject(
       channelCount_,
       context->getSampleRate());
 
-  delayWriterHostNode_ =
-      std::make_shared<DelayWriterHostNode>(graph_, std::move(delayNode->delayWriter_));
+  // order has to be preserved because adding cycle would not change their order in the graph
   delayReaderHostNode_ =
       std::make_shared<DelayReaderHostNode>(graph_, std::move(delayNode->delayReader_));
+  delayWriterHostNode_ =
+      std::make_shared<DelayWriterHostNode>(graph_, std::move(delayNode->delayWriter_));
+
+  // Reader and writer communicate via the delay line (a ring buffer), not via
+  // an audio edge. Linking their processable state ensures that when the
+  // reader becomes processable (because something downstream pulls from it),
+  // the writer — and everything feeding the writer — is also marked
+  // processable. The same link carries the transition back to NOT_PROCESSABLE
+  // on disconnect.
+  audioapi::utils::graph::Graph::linkNodes(delayReaderHostNode_->rawNode(), delayWriterHostNode_->rawNode());
 
   addGetters(JSI_EXPORT_PROPERTY_GETTER(DelayNodeHostObject, delayTime));
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
index 3c9df8345..70ac58b9e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
@@ -77,6 +77,10 @@ Graph::Res Graph::addEdge(HNode *from, HNode *to) {
   });
 }
 
+void Graph::linkNodes(HNode *from, HNode *to) {
+  HostGraph::linkNodes(from, to);
+}
+
 Graph::Res Graph::removeEdge(HNode *from, HNode *to) {
   collectDisposedNodes();
   return hostGraph.removeEdge(from, to).map([&](AGEvent event) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
index 7769e8524..ea281148c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
@@ -107,6 +107,13 @@ class Graph {
   /// @brief Adds a directed edge from → to. Rejects cycles and duplicates.
   Res addEdge(HNode *from, HNode *to);
 
+  /// @brief Links two nodes so that `to` follows the processable state of
+  /// `from` (one-way). No AudioGraph side effect — purely a host-graph hint
+  /// for propagating the processable state between nodes that share
+  /// processing semantics but not an audio edge (e.g. DelayReader →
+  /// DelayWriter).
+  static void linkNodes(HNode *from, HNode *to);
+
   /// @brief Removes a directed edge from → to.
   Res removeEdge(HNode *from, HNode *to);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
index a9e11b4f5..8c80e7e6d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
@@ -37,6 +37,9 @@ HostGraph::Node::~Node() {
 HostGraph::HostGraph() = default;
 
 HostGraph::~HostGraph() {
+  for (Node *n : nodes) {
+    n->linkedNodes.clear();
+  }
   for (Node *n : nodes) {
     delete n;
   }
@@ -51,6 +54,9 @@ HostGraph::HostGraph(HostGraph &&other) noexcept
 
 auto HostGraph::operator=(HostGraph &&other) noexcept -> HostGraph & {
   if (this != &other) {
+    for (Node *n : nodes) {
+      n->linkedNodes.clear();
+    }
     for (Node *n : nodes) {
       delete n;
     }
@@ -91,17 +97,20 @@ void HostGraph::markNodesAsProcessing(Node *node) {
   if (node == nullptr) {
     return;
   }
-  if (!node->handle->audioNode->isProcessable()) {
-    node->handle->audioNode->setProcessableState(
-        GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE);
-  }
-  if (node->inputs.empty()) {
+  // Already CONDITIONAL or ALWAYS — do not recurse. Stops infinite recursion
+  // on cycles (e.g. delay feedback) and avoids redundant walks.
+  if (node->handle->audioNode->isProcessable()) {
     return;
   }
+  node->handle->audioNode->setProcessableState(
+      GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE);
 
   for (Node *input : node->inputs) {
     markNodesAsProcessing(input);
   }
+  for (Node *linked : node->linkedNodes) {
+    markNodesAsProcessing(linked);
+  }
 }
 
 auto HostGraph::addEdge(Node *from, Node *to) -> Res {
@@ -144,17 +153,18 @@ void HostGraph::markNodesAsNotProcessing(Node *node) {
   if (!node->handle->audioNode->isProcessable()) {
     return;
   }
-  if (node->handle->audioNode->processableState_ ==
+  if (node->handle->audioNode->processableState_ !=
       GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE) {
-    node->handle->audioNode->setProcessableState(GraphObject::PROCESSABLE_STATE::NOT_PROCESSABLE);
-  }
-  if (node->inputs.empty()) {
     return;
   }
+  node->handle->audioNode->setProcessableState(GraphObject::PROCESSABLE_STATE::NOT_PROCESSABLE);
 
   for (Node *input : node->inputs) {
     markNodesAsNotProcessing(input);
   }
+  for (Node *linked : node->linkedNodes) {
+    markNodesAsNotProcessing(linked);
+  }
 }
 
 auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
@@ -255,6 +265,16 @@ bool HostGraph::hasPath(Node *start, Node *end) {
   return false;
 }
 
+void HostGraph::linkNodes(Node *from, Node *to) {
+  if (from == nullptr || to == nullptr || from == to) {
+    return;
+  }
+  if (std::ranges::find(from->linkedNodes, to) != from->linkedNodes.end()) {
+    return;
+  }
+  from->linkedNodes.push_back(to);
+}
+
 size_t HostGraph::edgeCount() const {
   return edgeCount_;
 }
@@ -268,6 +288,10 @@ void HostGraph::collectDisposedNodes() {
     Node *n = *it;
     if (n->ghost && n->handle.use_count() == 1) {
       edgeCount_ -= n->outputs.size();
+      for (Node *m : nodes) {
+        auto &ln = m->linkedNodes;
+        ln.erase(std::remove(ln.begin(), ln.end(), n), ln.end());
+      }
       *it = nodes.back();
       nodes.pop_back();
       delete n;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
index 1545af377..53d8613b1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
@@ -57,6 +57,13 @@ class HostGraph {
   struct Node {
     std::vector<Node *> inputs;  // reversed edges
     std::vector<Node *> outputs; // forward edges
+    /// Nodes whose processable state should follow this node's state.
+    /// Used to tie together the state of logically-linked host nodes that do
+    /// not share a graph edge (e.g. DelayReader → DelayWriter communicate via
+    /// a ring buffer, so no audio edge exists, but they must be processed
+    /// together). One-way: when THIS node is marked (not)processing, every
+    /// entry in `linkedNodes` is marked too (recursively).
+    std::vector<Node *> linkedNodes;
     TraversalState traversalState;
     std::shared_ptr<NodeHandle> handle; // shared handle bridging to AudioGraph
     bool ghost = false; // kept for cycle detection until AudioGraph confirms deletion
@@ -95,7 +102,19 @@ class HostGraph {
   /// @return AGEvent that adds the input on the AudioGraph side.
   Res addEdge(Node *from, Node *to);
 
-  /// @brief Marks a node as processing and recursively marks all inputs as processing.
+  /// @brief Links the processable-state of `from` to propagate into `to`.
+  ///
+  /// When `from` is marked (not)processing, `to` will be too. The link is
+  /// one-way and does NOT create a graph edge (no AudioGraph side effect).
+  /// Intended for host nodes that share processing semantics but do not
+  /// share an audio edge (e.g. DelayReader → DelayWriter).
+  ///
+  /// If the same pair is already linked, this is a no-op.
+  static void linkNodes(Node *from, Node *to);
+
+  /// @brief Marks this node CONDITIONAL_PROCESSABLE, then recurses into inputs
+  /// and linkedNodes. Skips nodes that are already processable (terminates
+  /// cycles and redundant paths).
   static void markNodesAsProcessing(Node *node);
 
   /// @brief Removes a directed edge from → to.

From 6a71c9c549da4b79a9559ceb53494dae144b90ac Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 17 Apr 2026 17:10:38 +0200
Subject: [PATCH 36/38] feat: channel count negotiations

---
 .../src/examples/AudioFile/AudioPlayer.ts     |  12 +-
 apps/fabric-example/ios/Podfile.lock          |   2 +-
 .../common/cpp/audioapi/core/AudioNode.h      |   7 +
 .../audioapi/core/utils/graph/HostGraph.cpp   | 162 ++++++++++++++++--
 .../common/cpp/test/src/graph/GraphTest.cpp   | 159 +++++++++++++++++
 5 files changed, 327 insertions(+), 15 deletions(-)

diff --git a/apps/common-app/src/examples/AudioFile/AudioPlayer.ts b/apps/common-app/src/examples/AudioFile/AudioPlayer.ts
index 0c357d3c9..f533cb974 100644
--- a/apps/common-app/src/examples/AudioFile/AudioPlayer.ts
+++ b/apps/common-app/src/examples/AudioFile/AudioPlayer.ts
@@ -49,10 +49,16 @@ class AudioPlayer {
     this.sourceNode = this.audioContext.createBufferSource({pitchCorrection: true});
     this.sourceNode.buffer = this.audioBuffer;
     this.sourceNode.playbackRate.value = this.playbackRate;
-    this.volumeNode = this.audioContext.createGain();
-    this.volumeNode.gain.value = this.volume;
+    const volume1 = this.audioContext.createGain();
+    const volume2 = this.audioContext.createGain();
+    volume1.gain.value = 0.5;
+    volume2.gain.value = 0.5;
+    // this.volumeNode = this.audioContext.createGain();
+    // this.volumeNode.gain.value = this.volume;
+
+    this.sourceNode.connect(volume1).connect(this.audioContext.destination);
+    this.sourceNode.connect(volume2).connect(this.audioContext.destination);
 
-    this.sourceNode.connect(this.volumeNode).connect(this.audioContext.destination);
     this.sourceNode.onPositionChangedInterval = 1000;
     this.sourceNode.onPositionChanged = (event) => {
       PlaybackNotificationManager.show({
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 0ff51c1dc..cdd4bf9ed 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2553,7 +2553,7 @@ SPEC CHECKSUMS:
   React-microtasksnativemodule: d1956f0eec54c619b63a379520fb4c618a55ccb9
   react-native-background-timer: 4638ae3bee00320753647900b21260b10587b6f7
   react-native-safe-area-context: ae7587b95fb580d1800c5b0b2a7bd48c2868e67a
-  react-native-skia: 5f68d3c3749bfb4f726e408410b8be5999392cd9
+  react-native-skia: 9e5b3a8a4ced921df89cb625dd9eb4fb10be1acf
   React-NativeModulesApple: 5ba0903927f6b8d335a091700e9fda143980f819
   React-networking: 3a4b7f9ed2b2d1c0441beacb79674323a24bcca6
   React-oscompat: ff26abf0ae3e3fdbe47b44224571e3fc7226a573
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index f0f3bd194..c02e6fa22 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -29,6 +29,13 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
 
   [[nodiscard]] size_t getChannelCount() const;
 
+  /// @brief Returns this node's `channelCountMode` attribute.
+  /// @note The value is immutable after construction, so this is safe to call
+  /// from any thread.
+  [[nodiscard]] ChannelCountMode getChannelCountMode() const {
+    return channelCountMode_;
+  }
+
   [[nodiscard]] float getContextSampleRate() const {
     if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
       return context->getSampleRate();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
index 8c80e7e6d..daa3c751d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
@@ -1,16 +1,120 @@
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/core/types/ChannelCountMode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/graph/GraphObject.h>
 #include <audioapi/core/utils/graph/HostGraph.h>
+#include <audioapi/utils/AudioBuffer.hpp>
 
 #include <algorithm>
 #include <cstddef>
+#include <memory>
 #include <utility>
 #include <vector>
 
 namespace audioapi::utils::graph {
 
+namespace {
+
+/// @brief Returns the AudioNode associated with `node`, or nullptr if the
+/// node has no audio payload (e.g. the lightweight `graph->addNode()` used
+/// in tests that exercise topology only).
+inline audioapi::AudioNode *audioNodeOf(const HostGraph::Node *node) {
+  if (node == nullptr || node->handle == nullptr || node->handle->audioNode == nullptr) {
+    return nullptr;
+  }
+  return node->handle->audioNode->asAudioNode();
+}
+
+/// @brief Computes the channel count that `dest`'s output buffer must carry
+/// after the current set of inputs (`dest->inputs`). Follows the Web Audio
+/// rules for `channelCountMode`:
+///   - EXPLICIT     -> `channelCount` attribute (inputs ignored)
+///   - MAX          -> max over inputs' channel counts
+///   - CLAMPED_MAX  -> min(channelCount attribute, max over inputs')
+///
+/// When there are no inputs the node keeps its own `channelCount` attribute
+/// (matches the shape the buffer already had at construction time).
+///
+/// Reads only host-thread-owned state: the const `channelCountMode_` and
+/// the `channelCount` attributes of the upstream nodes.
+size_t negotiateChannelCount(const HostGraph::Node *dest) {
+  auto *destAudio = audioNodeOf(dest);
+  if (destAudio == nullptr) {
+    return 0;
+  }
+
+  const auto attr = static_cast<size_t>(destAudio->getChannelCount());
+  const auto mode = destAudio->getChannelCountMode();
+
+  if (mode == audioapi::ChannelCountMode::EXPLICIT || dest->inputs.empty()) {
+    return attr;
+  }
+
+  size_t maxInputChannels = 0;
+  for (const HostGraph::Node *input : dest->inputs) {
+    auto *inAudio = audioNodeOf(input);
+    if (inAudio == nullptr) {
+      continue;
+    }
+    const auto c = static_cast<size_t>(inAudio->getChannelCount());
+    if (c > maxInputChannels) {
+      maxInputChannels = c;
+    }
+  }
+
+  if (maxInputChannels == 0) {
+    return attr;
+  }
+
+  switch (mode) {
+    case audioapi::ChannelCountMode::MAX:
+      return maxInputChannels;
+    case audioapi::ChannelCountMode::CLAMPED_MAX:
+      return std::min(attr, maxInputChannels);
+    case audioapi::ChannelCountMode::EXPLICIT:
+      return attr;
+  }
+  return attr;
+}
+
+/// @brief If `dest` is a real AudioNode and the newly negotiated channel
+/// count differs from what its output buffer already has, allocates a
+/// replacement `DSPAudioBuffer` on the host thread and returns it.
+/// Returns `nullptr` when no swap is needed (no audio payload, negotiation
+/// converged, or context gone).
+std::shared_ptr<audioapi::DSPAudioBuffer>
+buildNegotiatedBufferIfNeeded(const HostGraph::Node *dest) {
+  auto *destAudio = audioNodeOf(dest);
+  if (destAudio == nullptr) {
+    return nullptr;
+  }
+
+  const size_t desired = negotiateChannelCount(dest);
+  if (desired == 0) {
+    return nullptr;
+  }
+
+  // The current buffer shape is the only authoritative "current state" for
+  // channel count (the attribute can differ from the effective buffer in
+  // MAX / CLAMPED_MAX modes). Reading `getNumberOfChannels()` here is a
+  // plain load of a size_t owned by the shared_ptr we already hold, so it
+  // is safe on the host thread as long as the buffer pointer itself is
+  // only ever swapped under an AGEvent (which is the case).
+  const auto current = destAudio->getOutputBuffer();
+  if (current != nullptr && current->getNumberOfChannels() == desired) {
+    return nullptr;
+  }
+
+  return std::make_shared<audioapi::DSPAudioBuffer>(
+      audioapi::RENDER_QUANTUM_SIZE,
+      static_cast<int>(desired),
+      destAudio->getContextSampleRate());
+}
+
+} // namespace
+
 // =========================================================================
 // Implementation
 // =========================================================================
@@ -136,28 +240,46 @@ auto HostGraph::addEdge(Node *from, Node *to) -> Res {
   to->inputs.push_back(from);
   edgeCount_++;
 
+  // Channel-count negotiation: computed + allocated on the host thread,
+  // applied on the audio thread by the AGEvent below.
+  auto negotiatedBuffer = buildNegotiatedBufferIfNeeded(to);
+
   // could be problematic, since we are passing raw pointers to the lambda
-  return Res::Ok([from, to](AudioGraph &graph, auto &) {
-    if (!from->handle->audioNode->isProcessable() && to->handle->audioNode->isProcessable()) {
+  return Res::Ok([from, to, negotiatedBuffer = std::move(negotiatedBuffer)](
+                     AudioGraph &graph, auto &disposer) mutable {
+    auto *fromNode = from->handle ? from->handle->audioNode.get() : nullptr;
+    auto *toNode   = to->handle   ? to->handle->audioNode.get()   : nullptr;
+    if (fromNode && toNode &&
+        !fromNode->isProcessable() && toNode->isProcessable()) {
       markNodesAsProcessing(from);
     }
+    if (auto *toAudio = (toNode ? toNode->asAudioNode() : nullptr);
+        toAudio != nullptr && negotiatedBuffer != nullptr) {
+      auto oldBuffer = toAudio->getOutputBuffer();
+      toAudio->setOutputBuffer(std::move(negotiatedBuffer));
+      if (oldBuffer != nullptr) {
+        disposer.dispose(std::move(oldBuffer));
+      }
+    }
     graph.pool().push(graph[to->handle->index].input_head, from->handle->index);
     graph.markDirty();
   });
 }
 
 void HostGraph::markNodesAsNotProcessing(Node *node) {
-  if (node == nullptr) {
+  if (node == nullptr || node->handle == nullptr ||
+      node->handle->audioNode == nullptr) {
     return;
   }
-  if (!node->handle->audioNode->isProcessable()) {
+  auto *audioNode = node->handle->audioNode.get();
+  if (!audioNode->isProcessable()) {
     return;
   }
-  if (node->handle->audioNode->processableState_ !=
+  if (audioNode->processableState_ !=
       GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE) {
     return;
   }
-  node->handle->audioNode->setProcessableState(GraphObject::PROCESSABLE_STATE::NOT_PROCESSABLE);
+  audioNode->setProcessableState(GraphObject::PROCESSABLE_STATE::NOT_PROCESSABLE);
 
   for (Node *input : node->inputs) {
     markNodesAsNotProcessing(input);
@@ -188,17 +310,35 @@ auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
   from->outputs.erase(itOut);
   edgeCount_--;
 
+  // Channel-count negotiation: computed + allocated on the host thread,
+  // applied on the audio thread by the AGEvent below.
+  auto negotiatedBuffer = buildNegotiatedBufferIfNeeded(to);
+
   // could be problematic, since we are passing raw pointers to the lambda
-  return Res::Ok([from, to](AudioGraph &graph, auto &) {
-    if (from != nullptr &&
-        from->handle->audioNode->processableState_ ==
+  return Res::Ok([from, to, negotiatedBuffer = std::move(negotiatedBuffer)](
+                     AudioGraph &graph, auto &disposer) mutable {
+    auto *fromAudio = (from && from->handle) ? from->handle->audioNode.get() : nullptr;
+
+    if (fromAudio != nullptr &&
+        fromAudio->processableState_ ==
             GraphObject::PROCESSABLE_STATE::CONDITIONAL_PROCESSABLE) {
-      bool updateProcessingNodes = std::ranges::all_of(
-          from->outputs, [](Node *output) { return !output->handle->audioNode->isProcessable(); });
+      bool updateProcessingNodes = std::ranges::all_of(from->outputs, [](Node *output) {
+        auto *outAudio = (output && output->handle) ? output->handle->audioNode.get() : nullptr;
+        return outAudio == nullptr || !outAudio->isProcessable();
+      });
       if (updateProcessingNodes) {
         HostGraph::markNodesAsNotProcessing(from);
       }
     }
+    auto *toNode = to->handle ? to->handle->audioNode.get() : nullptr;
+    if (auto *toAudio = (toNode ? toNode->asAudioNode() : nullptr);
+        toAudio != nullptr && negotiatedBuffer != nullptr) {
+      auto oldBuffer = toAudio->getOutputBuffer();
+      toAudio->setOutputBuffer(std::move(negotiatedBuffer));
+      if (oldBuffer != nullptr) {
+        disposer.dispose(std::move(oldBuffer));
+      }
+    }
     graph.pool().remove(graph[to->handle->index].input_head, from->handle->index);
     graph.markDirty();
   });
diff --git a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
index 4194699cb..0142d552d 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/graph/GraphTest.cpp
@@ -1,10 +1,15 @@
+#include <audioapi/core/AudioNode.h>
+#include <audioapi/core/types/ChannelCountMode.h>
 #include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/types/NodeOptions.h>
+#include <audioapi/utils/AudioBuffer.hpp>
 #include <gtest/gtest.h>
 #include <atomic>
 #include <chrono>
 #include <cstdlib>
 #include <memory>
 #include <thread>
+#include <utility>
 #include <vector>
 #include "TestGraphUtils.h"
 
@@ -29,6 +34,47 @@ class GraphTest : public ::testing::Test {
   }
 };
 
+namespace {
+
+/// Minimal AudioNode used as both a "source" (configurable channel count on
+/// its output buffer) and a "destination" (configurable channelCount /
+/// channelCountMode whose effective buffer we assert on).
+class ChannelCountTestNode : public audioapi::AudioNode {
+ public:
+  ChannelCountTestNode(
+      const std::shared_ptr<audioapi::BaseAudioContext> &context,
+      const audioapi::AudioNodeOptions &options)
+      : AudioNode(context, options) {}
+
+  void processNode(int /*framesToProcess*/) override {}
+};
+
+struct ChannelOpts {
+  int channelCount;
+  audioapi::ChannelCountMode mode;
+};
+
+/// @returns the computed number of channels on the output buffer of the
+/// AudioNode that backs `node`.
+inline size_t channelsOf(const HostGraph::Node *node) {
+  auto *audioNode = node->handle->audioNode->asAudioNode();
+  return audioNode->getOutputBuffer()->getNumberOfChannels();
+}
+
+/// Adds a ChannelCountTestNode with the given options to the managed
+/// `graph`. Returns the HostGraph::Node pointer; the associated AudioGraph
+/// slot is populated once `graph->processEvents()` is called.
+inline HostGraph::Node *addChannelCountNode(Graph &graph, const ChannelOpts &opts) {
+  audioapi::AudioNodeOptions audioNodeOpts;
+  audioNodeOpts.channelCount = opts.channelCount;
+  audioNodeOpts.channelCountMode = opts.mode;
+
+  auto audioNode = std::make_unique<ChannelCountTestNode>(getGraphTestContext(), audioNodeOpts);
+  return graph.addNode(std::move(audioNode));
+}
+
+} // namespace
+
 TEST_F(GraphTest, EventsAreScheduledButNotExecutedUntilProcess) {
   auto *node = graph->addNode();
   ASSERT_NE(node, nullptr);
@@ -153,4 +199,117 @@ TEST_F(GraphTest, ThreadRaceConcurrency) {
   }
 }
 
+// ─── Channel-count negotiation on connect/disconnect ─────────────────────
+//
+// These tests assert the Web Audio contract: the computed number of
+// channels on a node's output buffer must follow `channelCountMode`
+//   - MAX          -> max(channelCount of each connected input)
+//                     (the node's channelCount attribute is ignored)
+//   - CLAMPED_MAX  -> min(channelCount attribute,
+//                         max(channelCount of each connected input))
+//   - EXPLICIT     -> always the channelCount attribute
+//
+// The computation must happen on the HostGraph side at addEdge/removeEdge
+// time, but the actual buffer swap is published through the AGEvent and
+// applied on the AudioGraph side — therefore each test calls
+// `graph->processEvents()` before inspecting `channelsOf(...)`.
+
+TEST_F(GraphTest, ChannelCountNegotiation_MaxMode_SingleInput) {
+  auto *source = addChannelCountNode(*graph, {.channelCount=4, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::MAX});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(source, dest).is_ok());
+  graph->processEvents();
+
+  EXPECT_EQ(channelsOf(dest), 4u)
+      << "MAX mode: after connecting a 4-channel source the downstream buffer "
+         "must be resized to 4 channels (channelCount attribute is ignored)";
+}
+
+TEST_F(GraphTest, ChannelCountNegotiation_MaxMode_MultipleInputsTakeMax) {
+  auto *mono = addChannelCountNode(*graph, {.channelCount=1, .mode=ChannelCountMode::EXPLICIT});
+  auto *six = addChannelCountNode(*graph, {.channelCount=6, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::MAX});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(mono, dest).is_ok());
+  ASSERT_TRUE(graph->addEdge(six, dest).is_ok());
+  graph->processEvents();
+
+  EXPECT_EQ(channelsOf(dest), 6u)
+      << "MAX mode: the downstream buffer must follow the largest connected input";
+}
+
+TEST_F(GraphTest, ChannelCountNegotiation_ClampedMaxMode_ClampsAboveAttribute) {
+  auto *source = addChannelCountNode(*graph, {.channelCount=6, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::CLAMPED_MAX});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(source, dest).is_ok());
+  graph->processEvents();
+
+  EXPECT_EQ(channelsOf(dest), 2u)
+      << "CLAMPED_MAX should clamp a 6-channel input down to channelCount=2";
+}
+
+TEST_F(GraphTest, ChannelCountNegotiation_ClampedMaxMode_FollowsInputWhenBelowAttribute) {
+  auto *source = addChannelCountNode(*graph, {.channelCount=1, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=4, .mode=ChannelCountMode::CLAMPED_MAX});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(source, dest).is_ok());
+  graph->processEvents();
+
+  EXPECT_EQ(channelsOf(dest), 1u)
+      << "CLAMPED_MAX: mono input with channelCount=4 must still produce a mono buffer";
+}
+
+TEST_F(GraphTest, ChannelCountNegotiation_ExplicitMode_IgnoresInput) {
+  auto *source = addChannelCountNode(*graph, {.channelCount=6, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=4, .mode=ChannelCountMode::EXPLICIT});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(source, dest).is_ok());
+  graph->processEvents();
+
+  EXPECT_EQ(channelsOf(dest), 4u)
+      << "EXPLICIT must always produce exactly channelCount channels";
+}
+
+TEST_F(GraphTest, ChannelCountNegotiation_MaxMode_RecomputesOnSecondConnection) {
+  auto *stereoSource = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::EXPLICIT});
+  auto *quadSource = addChannelCountNode(*graph, {.channelCount=4, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::MAX});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(stereoSource, dest).is_ok());
+  graph->processEvents();
+  EXPECT_EQ(channelsOf(dest), 2u)
+      << "MAX: with only a stereo source connected, buffer should be 2 channels";
+
+  ASSERT_TRUE(graph->addEdge(quadSource, dest).is_ok());
+  graph->processEvents();
+  EXPECT_EQ(channelsOf(dest), 4u)
+      << "MAX: connecting a 4-channel source must grow the buffer to 4 channels";
+}
+
+TEST_F(GraphTest, ChannelCountNegotiation_MaxMode_RecomputesOnDisconnection) {
+  auto *stereoSource = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::EXPLICIT});
+  auto *quadSource = addChannelCountNode(*graph, {.channelCount=4, .mode=ChannelCountMode::EXPLICIT});
+  auto *dest = addChannelCountNode(*graph, {.channelCount=2, .mode=ChannelCountMode::MAX});
+  graph->processEvents();
+
+  ASSERT_TRUE(graph->addEdge(stereoSource, dest).is_ok());
+  ASSERT_TRUE(graph->addEdge(quadSource, dest).is_ok());
+  graph->processEvents();
+  ASSERT_EQ(channelsOf(dest), 4u);
+
+  ASSERT_TRUE(graph->removeEdge(quadSource, dest).is_ok());
+  graph->processEvents();
+
+  EXPECT_EQ(channelsOf(dest), 2u)
+      << "MAX: removing the 4-channel source should shrink the buffer back to 2 channels";
+}
+
 } // namespace audioapi::utils::graph

From 0e3967ed6aee46f0d2423db6079318c1362cd969 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Tue, 21 Apr 2026 15:56:42 +0200
Subject: [PATCH 37/38] feat: removed race conditions

---
 .../HostObjects/AudioNodeHostObject.h         |  4 ++
 .../BaseAudioContextHostObject.cpp            | 43 ++++++++++++++-----
 .../AudioBufferSourceNodeHostObject.cpp       |  6 ++-
 .../sources/AudioFileSourceNodeHostObject.cpp | 34 ++++++++++-----
 .../AudioScheduledSourceNodeHostObject.cpp    |  6 ++-
 .../sources/OscillatorNodeHostObject.cpp      |  2 +-
 .../common/cpp/audioapi/core/AudioNode.h      | 13 ++++++
 .../common/cpp/audioapi/core/AudioParam.cpp   | 13 +-----
 .../cpp/audioapi/core/BaseAudioContext.cpp    |  1 +
 .../cpp/audioapi/core/BaseAudioContext.h      | 29 +++++++++++++
 .../audioapi/core/effects/StereoPannerNode.h  |  3 ++
 .../core/sources/AudioFileSourceNode.cpp      | 38 +++++++---------
 .../core/sources/AudioFileSourceNode.h        |  4 +-
 .../core/sources/AudioScheduledSourceNode.cpp |  4 +-
 .../cpp/audioapi/core/utils/graph/Graph.cpp   | 33 +++++++++++---
 .../cpp/audioapi/core/utils/graph/Graph.h     | 33 +++++++++++---
 .../audioapi/core/utils/graph/HostGraph.cpp   | 20 ++++++---
 .../cpp/audioapi/core/utils/graph/HostGraph.h |  5 +++
 .../audioapi/core/utils/graph/HostNode.cpp    |  5 ++-
 .../audioapi/jsi/RuntimeLifecycleMonitor.cpp  | 20 ++++++---
 .../ios/audioapi/ios/core/IOSAudioRecorder.mm | 40 +++++++++--------
 21 files changed, 249 insertions(+), 107 deletions(-)

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
index e09021a5e..998e7a894 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioNodeHostObject.h
@@ -35,6 +35,10 @@ class AudioNodeHostObject : public JsiHostObject, public utils::graph::HostNode
   JSI_HOST_FUNCTION_DECL(connect);
   JSI_HOST_FUNCTION_DECL(disconnect);
 
+  virtual size_t getMemoryPressure() {
+    return 350'000;
+  }
+
  protected:
   const int numberOfInputs_;
   const int numberOfOutputs_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index 35e617695..4bd372135 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -160,7 +160,9 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
   const auto oscillatorOptions = audioapi::option_parser::parseOscillatorOptions(runtime, options);
   auto oscillatorHostObject =
       std::make_shared<OscillatorNodeHostObject>(context_, oscillatorOptions);
-  return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
+  object.setExternalMemoryPressure(runtime, oscillatorHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
@@ -185,14 +187,18 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
       audioapi::option_parser::parseConstantSourceOptions(runtime, options);
   auto constantSourceHostObject =
       std::make_shared<ConstantSourceNodeHostObject>(context_, constantSourceOptions);
-  return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
+  object.setExternalMemoryPressure(runtime, constantSourceHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
   const auto options = args[0].asObject(runtime);
   const auto gainOptions = audioapi::option_parser::parseGainOptions(runtime, options);
   auto gainHostObject = std::make_shared<GainNodeHostObject>(context_, gainOptions);
-  return jsi::Object::createFromHostObject(runtime, gainHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, gainHostObject);
+  object.setExternalMemoryPressure(runtime, gainHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
@@ -200,7 +206,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
   const auto delayOptions = audioapi::option_parser::parseDelayOptions(runtime, options);
   auto delayNodeHostObject = std::make_shared<DelayNodeHostObject>(context_, delayOptions);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, delayNodeHostObject);
-  jsiObject.setExternalMemoryPressure(runtime, delayNodeHostObject->getSizeInBytes());
+  jsiObject.setExternalMemoryPressure(runtime, delayNodeHostObject->getMemoryPressure());
   return jsiObject;
 }
 
@@ -210,7 +216,9 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
       audioapi::option_parser::parseStereoPannerOptions(runtime, options);
   auto stereoPannerHostObject =
       std::make_shared<StereoPannerNodeHostObject>(context_, stereoPannerOptions);
-  return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
+  object.setExternalMemoryPressure(runtime, stereoPannerHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
@@ -219,14 +227,18 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
       audioapi::option_parser::parseBiquadFilterOptions(runtime, options);
   auto biquadFilterHostObject =
       std::make_shared<BiquadFilterNodeHostObject>(context_, biquadFilterOptions);
-  return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
+  object.setExternalMemoryPressure(runtime, biquadFilterHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createIIRFilter) {
   const auto options = args[0].asObject(runtime);
   const auto iirFilterOptions = audioapi::option_parser::parseIIRFilterOptions(runtime, options);
   auto iirFilterHostObject = std::make_shared<IIRFilterNodeHostObject>(context_, iirFilterOptions);
-  return jsi::Object::createFromHostObject(runtime, iirFilterHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, iirFilterHostObject);
+  object.setExternalMemoryPressure(runtime, iirFilterHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
@@ -247,7 +259,9 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createFileSource) {
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
     const auto fileSourceHostObject =
         std::make_shared<AudioFileSourceNodeHostObject>(context_, opts);
-    return jsi::Object::createFromHostObject(runtime, fileSourceHostObject);
+    auto object = jsi::Object::createFromHostObject(runtime, fileSourceHostObject);
+    object.setExternalMemoryPressure(runtime, fileSourceHostObject->getMemoryPressure());
+    return object;
   };
 
   const auto options = args[0].asObject(runtime);
@@ -263,7 +277,9 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
       audioapi::option_parser::parseBaseAudioBufferSourceOptions(runtime, options);
   auto bufferStreamSourceHostObject = std::make_shared<AudioBufferQueueSourceNodeHostObject>(
       context_, baseAudioBufferSourceOptions);
-  return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
+  object.setExternalMemoryPressure(runtime, bufferStreamSourceHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
@@ -294,7 +310,9 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
   const auto options = args[0].asObject(runtime);
   const auto analyserOptions = audioapi::option_parser::parseAnalyserOptions(runtime, options);
   auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(context_, analyserOptions);
-  return jsi::Object::createFromHostObject(runtime, analyserHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, analyserHostObject);
+  object.setExternalMemoryPressure(runtime, analyserHostObject->getMemoryPressure());
+  return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
@@ -308,6 +326,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
                                 .asHostObject<AudioBufferHostObject>(runtime);
     jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
   }
+  jsiObject.setExternalMemoryPressure(runtime, convolverHostObject->getMemoryPressure());
   return jsiObject;
 }
 
@@ -316,6 +335,8 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWaveShaper) {
   const auto waveShaperOptions = audioapi::option_parser::parseWaveShaperOptions(runtime, options);
   auto waveShaperHostObject =
       std::make_shared<WaveShaperNodeHostObject>(context_, waveShaperOptions);
-  return jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
+  auto object = jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
+  object.setExternalMemoryPressure(runtime, waveShaperHostObject->getMemoryPressure());
+  return object;
 }
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp
index 7cb57aaa1..0c58b5ab1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp
@@ -173,7 +173,11 @@ void AudioBufferSourceNodeHostObject::setOnLoopEndedCallbackId(uint64_t callback
   };
 
   audioBufferSourceNode->unregisterOnLoopEndedCallback(onLoopEndedCallbackId_);
-  audioBufferSourceNode->scheduleAudioEvent(std::move(event));
+  if (callbackId == 0) {
+    audioBufferSourceNode->scheduleGCEvent(std::move(event));
+  } else {
+    audioBufferSourceNode->scheduleAudioEvent(std::move(event));
+  }
   onLoopEndedCallbackId_ = callbackId;
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
index e8e19745f..c87b62492 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
@@ -1,21 +1,26 @@
 #include <audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h>
 
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioFileSourceNode.h>
 #include <audioapi/types/NodeOptions.h>
 #include <memory>
 #include <utility>
-#include "audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h"
 
 namespace audioapi {
 
 AudioFileSourceNodeHostObject::AudioFileSourceNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const AudioFileSourceOptions &options)
-    : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options),
+    : AudioScheduledSourceNodeHostObject(
+          context->getGraph(),
+          std::make_unique<AudioFileSourceNode>(context, options),
+          options),
       loop_(options.loop),
-      volume_(options.volume),
-      duration_(std::static_pointer_cast<AudioFileSourceNode>(node_)->getDuration()) {
+      duration_(
+          static_cast<AudioFileSourceNode *>(node_->handle->audioNode->asAudioNode())
+              ->getDuration()),
+      volume_(options.volume) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, volume),
       JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, loop),
@@ -43,7 +48,8 @@ JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
-  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *node = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
   volume_ = static_cast<float>(value.getNumber());
   auto event = [node, volume = this->volume_](BaseAudioContext &ctx) {
     node->setVolume(volume);
@@ -56,7 +62,8 @@ JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, loop) {
 }
 
 JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, loop) {
-  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *node = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
   loop_ = value.getBool();
   auto event = [node, loop = this->loop_](BaseAudioContext &ctx) {
     node->setLoop(loop);
@@ -65,7 +72,8 @@ JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, loop) {
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, currentTime) {
-  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *node = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
   return {node->getCurrentTime()};
 }
 
@@ -74,7 +82,8 @@ JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, duration) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioFileSourceNodeHostObject, pause) {
-  auto audioFileSourceNode = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *audioFileSourceNode = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
   auto event = [audioFileSourceNode](BaseAudioContext &ctx) {
     audioFileSourceNode->pause();
   };
@@ -83,7 +92,8 @@ JSI_HOST_FUNCTION_IMPL(AudioFileSourceNodeHostObject, pause) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioFileSourceNodeHostObject, seekToTime) {
-  auto audioFileSourceNode = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *audioFileSourceNode = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
   if (count < 1 || !args[0].isNumber()) {
     return jsi::Value::undefined();
   }
@@ -103,7 +113,8 @@ JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, onPositionChanged) {
 }
 
 void AudioFileSourceNodeHostObject::setOnPositionChangedCallbackId(uint64_t callbackId) {
-  auto sourceNode = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *sourceNode = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
 
   auto event = [sourceNode, callbackId](BaseAudioContext &) {
     sourceNode->setOnPositionChangedCallbackId(callbackId);
@@ -115,7 +126,8 @@ void AudioFileSourceNodeHostObject::setOnPositionChangedCallbackId(uint64_t call
 }
 
 void AudioFileSourceNodeHostObject::setOnEndedCallbackId(uint64_t callbackId) {
-  auto sourceNode = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  auto handle = node_->handle;
+  auto *sourceNode = static_cast<AudioFileSourceNode *>(handle->audioNode->asAudioNode());
 
   auto event = [sourceNode, callbackId](BaseAudioContext &) {
     sourceNode->setOnEndedCallbackId(callbackId);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp
index 05bbc338d..fb848a0a6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.cpp
@@ -67,7 +67,11 @@ void AudioScheduledSourceNodeHostObject::setOnEndedCallbackId(uint64_t callbackI
   };
 
   sourceNode->unregisterOnEndedCallback(onEndedCallbackId_);
-  sourceNode->scheduleAudioEvent(std::move(event));
+  if (callbackId == 0) {
+    sourceNode->scheduleGCEvent(std::move(event));
+  } else {
+    sourceNode->scheduleAudioEvent(std::move(event));
+  }
   onEndedCallbackId_ = callbackId;
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
index 00bae4a65..d3adc038b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp
@@ -19,7 +19,7 @@ OscillatorNodeHostObject::OscillatorNodeHostObject(
           std::make_unique<OscillatorNode>(context, options),
           options),
       type_(options.type) {
-  auto oscillatorNode = static_cast<OscillatorNode *>(node_->handle->audioNode->asAudioNode());
+  auto *oscillatorNode = static_cast<OscillatorNode *>(node_->handle->audioNode->asAudioNode());
   frequencyParam_ =
       std::make_shared<AudioParamHostObject>(graph_, node_, oscillatorNode->getFrequencyParam());
   detuneParam_ =
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index c02e6fa22..93ec4d95c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -89,6 +89,19 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
     return false;
   }
 
+  /// @brief Schedule an audio event from the JS runtime's finalizer (GC)
+  /// thread. Use this from `~HostObject` code paths — `scheduleAudioEvent`
+  /// would race because its SPSC channel's single producer is the JS
+  /// thread.
+  template <typename F>
+  bool scheduleGCEvent(F &&event) noexcept {
+    if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
+      return context->scheduleGCEvent(std::forward<F>(event));
+    }
+
+    return false;
+  }
+
   bool canBeDestructed() const override;
 
   [[nodiscard]] AudioNode *asAudioNode() override {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
index bb68b0289..b0512ddaa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp
@@ -19,22 +19,11 @@ AudioParam::AudioParam(
       defaultValue_(defaultValue),
       minValue_(minValue),
       maxValue_(maxValue),
-      startTime_(0),
-      endTime_(0),
-      startValue_(defaultValue),
-      endValue_(defaultValue),
       inputBuffer_(
           std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())),
       outputBuffer_(
           std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, 1, context->getSampleRate())),
-      eventRenderQueue_(defaultValue) {
-  // Default calculation function just returns the static value
-  calculateValue_ = [this](double, double, float, float, double) {
-    return value_.load(std::memory_order_relaxed);
-  };
-  inputBuffers_.reserve(4);
-  inputNodes_.reserve(4);
-}
+      eventRenderQueue_(defaultValue) {}
 
 float AudioParam::getValueAtTime(double time) {
   auto value = eventRenderQueue_.computeValueAtTime(time);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 459de16fa..8aa41b010 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -19,6 +19,7 @@ BaseAudioContext::BaseAudioContext(
       audioEventHandlerRegistry_(audioEventHandlerRegistry),
       runtimeRegistry_(runtimeRegistry),
       audioEventScheduler_(AUDIO_SCHEDULER_CAPACITY),
+      gcAudioEventScheduler_(GC_AUDIO_SCHEDULER_CAPACITY),
       disposer_(
           std::make_unique<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>>(AUDIO_SCHEDULER_CAPACITY)),
       graph_(std::make_shared<utils::graph::Graph>(AUDIO_SCHEDULER_CAPACITY, disposer_.get())) {}
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index 21ef94a79..3e8dab563 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -58,7 +58,13 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   virtual void initialize(const AudioDestinationNode *destination);
 
   void processAudioEvents() {
+    // Drain JS-thread scheduler first, then the GC-thread scheduler.
+    // This preserves causality for the common case where a JS-thread
+    // produced event logically happens-before a GC-thread cleanup event
+    // on the same node (e.g. `onEnded = id` followed by HostObject
+    // finalization that clears the callback id).
     audioEventScheduler_.processAllEvents(*this);
+    gcAudioEventScheduler_.processAllEvents(*this);
   }
 
   template <typename F>
@@ -72,6 +78,24 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
     return audioEventScheduler_.scheduleEvent(std::forward<F>(event));
   }
 
+  /// @brief Schedule an audio event produced on the JS runtime's finalizer
+  /// (GC) thread. Uses a dedicated SPSC channel so the main
+  /// `audioEventScheduler_` stays single-producer (JS thread).
+  ///
+  /// Call this from JSI HostObject destructors (which on Hermes fire on the
+  /// concurrent GC thread) instead of `scheduleAudioEvent`, otherwise the
+  /// GC thread and the JS thread will race on the same SPSC channel.
+  ///
+  /// @note Unlike `scheduleAudioEvent`, this does NOT fall through to a
+  /// synchronous `event(*this)` when the context is not RUNNING. The
+  /// finalizer thread must never touch context state directly, and the
+  /// event handler itself must be safe to skip if the audio thread never
+  /// drains it (e.g. context already closed).
+  template <typename F>
+  bool scheduleGCEvent(F &&event) noexcept { // NOLINT(cppcoreguidelines-missing-std-forward)
+    return gcAudioEventScheduler_.scheduleEvent(std::forward<F>(event));
+  }
+
   void processGraph(DSPAudioBuffer *buffer, int numFrames);
 
  protected:
@@ -90,7 +114,12 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<PeriodicWave> cachedTriangleWave_ = nullptr;
 
   static constexpr size_t AUDIO_SCHEDULER_CAPACITY = 1024;
+  static constexpr size_t GC_AUDIO_SCHEDULER_CAPACITY = 256;
   CrossThreadEventScheduler<BaseAudioContext> audioEventScheduler_;
+  /// Dedicated single-producer SPSC scheduler for events produced on the
+  /// JS runtime's finalizer (GC) thread. Keeps `audioEventScheduler_`
+  /// single-producer (JS thread) and avoids the MPSC-on-SPSC data race.
+  CrossThreadEventScheduler<BaseAudioContext> gcAudioEventScheduler_;
 
   std::unique_ptr<utils::DisposerImpl<DISPOSER_PAYLOAD_SIZE>> disposer_;
   std::shared_ptr<utils::graph::Graph> graph_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
index 3da3d7555..5f699cfe8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/StereoPannerNode.h
@@ -22,6 +22,9 @@ class StereoPannerNode : public AudioNode {
 
  protected:
   void processNode(int framesToProcess) override;
+  [[nodiscard]] const DSPAudioBuffer *getOutput() const override {
+    return outputBuffer_.get();
+  }
 
  private:
   const std::shared_ptr<AudioParam> panParam_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index fd6882060..c05d2db78 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -52,8 +52,6 @@ AudioFileSourceNode::AudioFileSourceNode(
       spsc::OverflowStrategy::OVERWRITE_ON_FULL,
       spsc::WaitStrategy::ATOMIC_WAIT>>(
       SEEK_OFFLOADER_WORKER_COUNT, [this](OffloadedSeekRequest req) { runOffloadedSeekTask(req); });
-
-  isInitialized_.store(true, std::memory_order_release);
 }
 
 void AudioFileSourceNode::setOnPositionChangedCallbackId(uint64_t callbackId) {
@@ -215,34 +213,32 @@ size_t AudioFileSourceNode::handleEof(
   return framesRead + extra;
 }
 
-std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    int framesToProcess) {
+void AudioFileSourceNode::processNode(int framesToProcess) {
   if (decoderState_ == nullptr || decoder_ == nullptr || !decoder_->isOpen()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   std::shared_ptr<BaseAudioContext> context = context_.lock();
   if (context == nullptr) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   if (pendingOffloadedSeeks_.load(std::memory_order_acquire) > 0) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   if (filePaused_) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   size_t startOffset = 0;
   size_t offsetLength = 0;
   updatePlaybackInfo(
-      processingBuffer,
+      audioBuffer_,
       framesToProcess,
       startOffset,
       offsetLength,
@@ -250,8 +246,8 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
       context->getCurrentSampleFrame());
 
   if (!isPlaying() && !isStopScheduled()) {
-    processingBuffer->zero();
-    return processingBuffer;
+    audioBuffer_->zero();
+    return;
   }
 
   auto &state = *decoderState_;
@@ -260,7 +256,7 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
   sendOnPositionChangedEvent(static_cast<int>(framesRead));
 
   if (volume_ != 0.0f && framesRead > 0) {
-    writeInterleavedToBufferAtOffset(processingBuffer, state, startOffset, framesRead);
+    writeInterleavedToBufferAtOffset(audioBuffer_, state, startOffset, framesRead);
   }
 
   if (framesRead < offsetLength) {
@@ -270,21 +266,19 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
       sendOnPositionChangedEvent(static_cast<int>(offsetLength - framesRead));
       filePaused_ = true;
       playbackState_ = PlaybackState::STOP_SCHEDULED;
-      processingBuffer->zero(startOffset + framesRead, offsetLength - framesRead);
+      audioBuffer_->zero(startOffset + framesRead, offsetLength - framesRead);
     } else {
-      const size_t totalFilled = handleEof(processingBuffer, offsetLength, framesRead, startOffset);
+      const size_t totalFilled = handleEof(audioBuffer_, offsetLength, framesRead, startOffset);
       onPositionChangedFlush_.store(true, std::memory_order_release);
       currentTime_.store(0, std::memory_order_release);
       sendOnPositionChangedEvent(static_cast<int>(totalFilled));
-      processingBuffer->zero(startOffset + totalFilled, offsetLength - totalFilled);
+      audioBuffer_->zero(startOffset + totalFilled, offsetLength - totalFilled);
     }
   }
 
   if (isStopScheduled()) {
     handleStopScheduled();
   }
-
-  return processingBuffer;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index 0730e4d1b..0eec1340b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -70,9 +70,7 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
   void seekToTime(double seconds);
 
  protected:
-  std::shared_ptr<DSPAudioBuffer> processNode(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      int framesToProcess) override;
+  void processNode(int framesToProcess) override;
 
  private:
   void initDecoders(
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
index fd3fb3146..6c036443e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp
@@ -82,7 +82,9 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   auto firstFrame = currentSampleFrame;
   size_t lastFrame = firstFrame + framesToProcess - 1;
 
-  size_t startFrame = std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
+  size_t startFrame = startTime_ == -1.0
+      ? firstFrame
+      : std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
   size_t stopFrame = stopTime_ == -1.0 ? std::numeric_limits<size_t>::max()
                                        : dsp::timeToSampleFrame(stopTime_, sampleRate);
   if (isFinished()) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
index 70ac58b9e..b409a5897 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.cpp
@@ -17,6 +17,11 @@ Graph::Graph(size_t eventQueueCapacity, Disposer<audioapi::DISPOSER_PAYLOAD_SIZE
       channel<AGEvent, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::BUSY_LOOP>(eventQueueCapacity);
   eventSender_ = std::move(es);
   eventReceiver_ = std::move(er);
+
+  auto [gs, gr] =
+      channel<AGEvent, OverflowStrategy::WAIT_ON_FULL, WaitStrategy::BUSY_LOOP>(eventQueueCapacity);
+  gcEventSender_ = std::move(gs);
+  gcEventReceiver_ = std::move(gr);
 }
 
 Graph::Graph(
@@ -37,11 +42,23 @@ Graph::Graph(
 
 void Graph::processEvents() {
   AGEvent event;
+  // Drain Channel A (JS thread producer: addNode / addEdge / grow / …)
+  // fully first — this guarantees that any `addNode(X)` pending here is
+  // applied to AudioGraph before we process a matching `orphan(X)` that
+  // may already be sitting in Channel B.
   while (eventReceiver_.try_receive(event) == audioapi::channels::spsc::ResponseStatus::SUCCESS) {
     if (event) {
       event(audioGraph, *disposer_);
     }
   }
+  // Drain Channel B (finalizer / GC thread producer: removeNode orphan
+  // events). These are idempotent w.r.t. each other and never require
+  // capacity growth (they only flip a boolean on an existing node).
+  while (gcEventReceiver_.try_receive(event) == audioapi::channels::spsc::ResponseStatus::SUCCESS) {
+    if (event) {
+      event(audioGraph, *disposer_);
+    }
+  }
 }
 
 void Graph::process() {
@@ -49,7 +66,7 @@ void Graph::process() {
 }
 
 Graph::HNode *Graph::addNode(std::unique_ptr<GraphObject> audioNode) {
-  collectDisposedNodes();
+  // collectDisposedNodes();
 
   auto handle = std::make_shared<NodeHandle>(0, std::move(audioNode));
   auto [hostNode, event] = hostGraph.addNode(handle);
@@ -61,15 +78,19 @@ Graph::HNode *Graph::addNode(std::unique_ptr<GraphObject> audioNode) {
 }
 
 Graph::Res Graph::removeNode(HNode *node) {
-  collectDisposedNodes();
+  // collectDisposedNodes();
+  // Routed through Channel B: HostNode destructors (and therefore this
+  // call) may fire on the JS runtime's finalizer thread (e.g. Hermes GC).
+  // Sending through the dedicated SPSC channel keeps the single-producer
+  // invariant for both channels.
   return hostGraph.removeNode(node).map([&](AGEvent event) {
-    eventSender_.send(std::move(event));
+    gcEventSender_.send(std::move(event));
     return NoneType{};
   });
 }
 
 Graph::Res Graph::addEdge(HNode *from, HNode *to) {
-  collectDisposedNodes();
+  // collectDisposedNodes();
   return hostGraph.addEdge(from, to).map([&](AGEvent event) {
     sendPoolGrowIfNeeded();
     eventSender_.send(std::move(event));
@@ -82,7 +103,7 @@ void Graph::linkNodes(HNode *from, HNode *to) {
 }
 
 Graph::Res Graph::removeEdge(HNode *from, HNode *to) {
-  collectDisposedNodes();
+  // collectDisposedNodes();
   return hostGraph.removeEdge(from, to).map([&](AGEvent event) {
     eventSender_.send(std::move(event));
     return NoneType{};
@@ -90,7 +111,7 @@ Graph::Res Graph::removeEdge(HNode *from, HNode *to) {
 }
 
 Graph::Res Graph::removeAllEdges(HNode *from) {
-  collectDisposedNodes();
+  // collectDisposedNodes();
   return hostGraph.removeAllEdges(from).map([&](AGEvent event) {
     eventSender_.send(std::move(event));
     return NoneType{};
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
index ea281148c..0524ae37e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/Graph.h
@@ -17,17 +17,29 @@
 namespace audioapi::utils::graph {
 
 /// @brief Thread-safe graph coordinator that bridges HostGraph (main thread)
-/// and AudioGraph (audio thread) via a single SPSC event channel.
+/// and AudioGraph (audio thread) via two SPSC event channels.
+///
+/// Two producer threads are supported:
+///   - The JS thread produces structural mutations (`addNode`, `addEdge`,
+///     `removeEdge`, `removeAllEdges`) and pre-grow events on **Channel A**.
+///   - The JS runtime's finalizer / GC thread produces `removeNode`
+///     (orphan) events on **Channel B**. This is the path taken when a
+///     HostObject's destructor runs on the Hermes GC finalizer thread.
+///
+/// The audio thread drains Channel A fully before Channel B in every
+/// `processEvents()` call. That preserves the invariant
+/// `addNode(X) happens-before orphan(X)` on the audio side even though
+/// the two channels carry no cross-ordering by themselves.
 ///
 /// Memory pre-growth: the main thread tracks edge and node counts. When
 /// growth is needed it sends an inline grow AGEvent immediately followed
-/// by the graph-mutation AGEvent through the **same** channel, guaranteeing
-/// FIFO ordering: the audio thread always applies growth before the
-/// operation that needs it.
+/// by the graph-mutation AGEvent through Channel A, guaranteeing FIFO
+/// ordering: the audio thread always applies growth before the operation
+/// that needs it.
 ///
 /// ## Audio-thread call order
 /// ```
-/// graph.processEvents();       // apply pending graph mutations (if any) — in FIFO order
+/// graph.processEvents();       // drain Channel A, then Channel B (FIFO within each)
 /// graph.process();             // toposort + compaction
 /// for (auto&& [node, inputs] : graph.iter()) { ... }
 /// ```
@@ -130,11 +142,20 @@ class Graph {
   alignas(hardware_destructive_interference_size) AudioGraph audioGraph;
   alignas(hardware_destructive_interference_size) HostGraph hostGraph;
 
-  // ── Channel (immutable after construction — no false sharing) ───────────
+  // ── Channels (immutable after construction — no false sharing) ─────────
+  //
+  // Channel A: JS thread producer — addNode / addEdge / removeEdge /
+  //            removeAllEdges / grow events.
+  // Channel B: finalizer (GC) thread producer — removeNode (orphan) events.
+  //
+  // Each channel has a single producer, so SPSC invariants hold.
 
   EventSender eventSender_;
   EventReceiver eventReceiver_;
 
+  EventSender gcEventSender_;
+  EventReceiver gcEventReceiver_;
+
   // ── Disposer — destroys old pool buffers off the audio thread ───────────
 
   Disposer<audioapi::DISPOSER_PAYLOAD_SIZE> *disposer_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
index 83ddf7746..67f8aa5df 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.cpp
@@ -6,8 +6,8 @@
 #include <audioapi/core/utils/graph/GraphObject.h>
 #include <audioapi/core/utils/graph/HostGraph.h>
 #include <audioapi/utils/AudioBuffer.hpp>
-
 #include <algorithm>
+
 #include <cstddef>
 #include <memory>
 #include <utility>
@@ -59,9 +59,7 @@ size_t negotiateChannelCount(const HostGraph::Node *dest) {
       continue;
     }
     const auto c = static_cast<size_t>(inAudio->getChannelCount());
-    if (c > maxInputChannels) {
-      maxInputChannels = c;
-    }
+    maxInputChannels = std::max(c, maxInputChannels);
   }
 
   if (maxInputChannels == 0) {
@@ -139,6 +137,7 @@ HostGraph::Node::~Node() {
 HostGraph::HostGraph() = default;
 
 HostGraph::~HostGraph() {
+  std::scoped_lock lock(nodesMutex_);
   for (Node *n : nodes) {
     n->linkedNodes.clear();
   }
@@ -156,6 +155,7 @@ HostGraph::HostGraph(HostGraph &&other) noexcept
 
 auto HostGraph::operator=(HostGraph &&other) noexcept -> HostGraph & {
   if (this != &other) {
+    std::scoped_lock lock(nodesMutex_, other.nodesMutex_);
     for (Node *n : nodes) {
       n->linkedNodes.clear();
     }
@@ -172,18 +172,20 @@ auto HostGraph::operator=(HostGraph &&other) noexcept -> HostGraph & {
 }
 
 auto HostGraph::addNode(std::shared_ptr<NodeHandle> handle) -> std::pair<Node *, AGEvent> {
+  std::scoped_lock lock(nodesMutex_);
   Node *newNode = new Node();
   newNode->handle = handle;
   nodes.push_back(newNode);
 
   auto event = [h = std::move(handle)](auto &graph, auto &) {
-    graph.addNode(h);
+    graph.addNode(std::move(h));
   };
 
   return {newNode, std::move(event)};
 }
 
 auto HostGraph::removeNode(Node *node) -> Res {
+  std::scoped_lock lock(nodesMutex_);
   auto it = std::ranges::find(nodes, node);
   if (it == nodes.end()) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
@@ -216,6 +218,7 @@ void HostGraph::markNodesAsProcessing(Node *node) {
 }
 
 auto HostGraph::addEdge(Node *from, Node *to) -> Res {
+  std::scoped_lock lock(nodesMutex_);
   if (std::ranges::find(nodes, from) == nodes.end() ||
       std::ranges::find(nodes, to) == nodes.end()) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
@@ -285,6 +288,7 @@ void HostGraph::markNodesAsNotProcessing(Node *node) {
 }
 
 auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
+  std::scoped_lock lock(nodesMutex_);
   if (std::ranges::find(nodes, from) == nodes.end() ||
       std::ranges::find(nodes, to) == nodes.end()) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
@@ -328,7 +332,7 @@ auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
     if (auto *toAudio = (toNode ? toNode->asAudioNode() : nullptr);
         toAudio != nullptr && negotiatedBuffer != nullptr) {
       auto oldBuffer = toAudio->getOutputBuffer();
-      toAudio->setOutputBuffer(std::move(negotiatedBuffer));
+      toAudio->setOutputBuffer(negotiatedBuffer);
       if (oldBuffer != nullptr) {
         disposer.dispose(std::move(oldBuffer));
       }
@@ -339,6 +343,7 @@ auto HostGraph::removeEdge(Node *from, Node *to) -> Res {
 }
 
 auto HostGraph::removeAllEdges(Node *from) -> Res {
+  std::scoped_lock lock(nodesMutex_);
   if (std::ranges::find(nodes, from) == nodes.end() || from->ghost) {
     return Res::Err(ResultError::NODE_NOT_FOUND);
   }
@@ -410,14 +415,17 @@ void HostGraph::linkNodes(Node *from, Node *to) {
 }
 
 size_t HostGraph::edgeCount() const {
+  std::scoped_lock lock(nodesMutex_);
   return edgeCount_;
 }
 
 size_t HostGraph::nodeCount() const {
+  std::scoped_lock lock(nodesMutex_);
   return nodes.size();
 }
 
 void HostGraph::collectDisposedNodes() {
+  std::scoped_lock lock(nodesMutex_);
   for (auto it = nodes.begin(); it != nodes.end();) {
     Node *n = *it;
     if (n->ghost && n->handle.use_count() == 1) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
index 53d8613b1..54f8ec4af 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostGraph.h
@@ -8,6 +8,7 @@
 #include <audioapi/utils/Result.hpp>
 
 #include <memory>
+#include <mutex>
 #include <utility>
 #include <vector>
 
@@ -136,6 +137,10 @@ class HostGraph {
 
  private:
   std::vector<Node *> nodes;
+  /// Guards access to `nodes` and the per-node adjacency mutated by the
+  /// public API (inputs/outputs/ghost). Public API methods do not call one
+  /// another while holding the lock, so a plain mutex is sufficient.
+  mutable std::mutex nodesMutex_;
   size_t edgeCount_ = 0;
   size_t last_term = 0; // monotonic counter for traversal freshness
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp
index 0450052f2..59d5bb8aa 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/graph/HostNode.cpp
@@ -9,7 +9,8 @@ HostNode::HostNode(std::shared_ptr<GraphType> graph, std::unique_ptr<GraphObject
     : graph_(std::move(graph)), node_(graph_->addNode(std::move(graphObject))) {}
 
 HostNode::~HostNode() {
-  if (graph_ && node_) {
+  if (graph_ && (node_ != nullptr)) {
+    graph_->collectDisposedNodes();
     (void)graph_->removeNode(node_);
     node_ = nullptr;
   }
@@ -22,7 +23,7 @@ HostNode::HostNode(HostNode &&other) noexcept
 
 HostNode &HostNode::operator=(HostNode &&other) noexcept {
   if (this != &other) {
-    if (graph_ && node_) {
+    if (graph_ && (node_ != nullptr)) {
       (void)graph_->removeNode(node_);
     }
     graph_ = std::move(other.graph_);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/jsi/RuntimeLifecycleMonitor.cpp b/packages/react-native-audio-api/common/cpp/audioapi/jsi/RuntimeLifecycleMonitor.cpp
index 53d259bfb..ee1b326b2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/jsi/RuntimeLifecycleMonitor.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/jsi/RuntimeLifecycleMonitor.cpp
@@ -1,5 +1,6 @@
 #include <audioapi/jsi/RuntimeLifecycleMonitor.h>
 #include <memory>
+#include <mutex>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -7,22 +8,30 @@
 namespace audioapi {
 
 static std::unordered_map<jsi::Runtime *, std::unordered_set<RuntimeLifecycleListener *>> listeners;
+static std::mutex listenersMutex;
 
 struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
   jsi::Runtime *rt_;
   explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : rt_(rt) {}
   ~RuntimeLifecycleMonitorObject() override {
-    auto listenersSet = listeners.find(rt_);
-    if (listenersSet != listeners.end()) {
-      for (auto listener : listenersSet->second) {
-        listener->onRuntimeDestroyed(rt_);
+    std::unordered_set<RuntimeLifecycleListener *> toNotify;
+    {
+      std::scoped_lock lock(listenersMutex);
+      auto listenersSet = listeners.find(rt_);
+      if (listenersSet != listeners.end()) {
+        toNotify = std::move(listenersSet->second);
+        listeners.erase(listenersSet);
       }
-      listeners.erase(listenersSet);
+    }
+    // Notify outside the lock — listener callbacks may re-enter add/remove.
+    for (auto *listener : toNotify) {
+      listener->onRuntimeDestroyed(rt_);
     }
   }
 };
 
 void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
+  std::scoped_lock lock(listenersMutex);
   auto listenersSet = listeners.find(&rt);
   if (listenersSet == listeners.end()) {
     // We install a global host object in the provided runtime, this way we can
@@ -43,6 +52,7 @@ void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt, RuntimeLifecycleList
 }
 
 void RuntimeLifecycleMonitor::removeListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
+  std::scoped_lock lock(listenersMutex);
   auto listenersSet = listeners.find(&rt);
   if (listenersSet == listeners.end()) {
     // nothing to do here
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
index df72f376e..1007b489a 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
@@ -149,7 +149,7 @@ static void cleanupStartedRecorder(
     isConnected_.store(false, std::memory_order_release);
     dataCallback_ = nullptr;
     fileWriter_ = nullptr;
-    adapterNode_ = nullptr;
+    adapterNodeHandle_ = nullptr;
   }
 
   [nativeRecorder_ cleanup];
@@ -270,11 +270,12 @@ static void cleanupStartedRecorder(
     callbackOutputConfigured_.store(true, std::memory_order_release);
   }
 
-  if (wantsConnection() && adapterNode_ != nullptr) {
-    adapterNode_->init(
-        maxInputBufferLength,
-        recorderFormatChannelCount(inputFormat),
-        recorderFormatSampleRate(inputFormat));
+  if (wantsConnection() && adapterNodeHandle_ != nullptr) {
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(
+            maxInputBufferLength,
+            recorderFormatChannelCount(inputFormat),
+            recorderFormatSampleRate(inputFormat));
     connectedConfigured_.store(true, std::memory_order_release);
   }
 
@@ -291,7 +292,7 @@ static void cleanupStartedRecorder(
 {
   std::shared_ptr<AudioFileWriter> fileWriter;
   std::shared_ptr<AudioRecorderCallback> dataCallback;
-  std::shared_ptr<RecorderAdapterNode> adapterNode;
+  std::shared_ptr<utils::graph::NodeHandle> adapterNodeHandle;
   std::vector<std::string> outputPaths;
   std::string filePath;
 
@@ -328,7 +329,7 @@ static void cleanupStartedRecorder(
 
     if (hadConnection) {
       connectedConfigured_.store(false, std::memory_order_release);
-      adapterNode = std::move(adapterNode_);
+      adapterNodeHandle = std::move(adapterNodeHandle_);
     }
 
     for (const auto &raw : recordingSegmentPaths_) {
@@ -360,8 +361,8 @@ static void cleanupStartedRecorder(
     dataCallback->cleanup();
   }
 
-  if (adapterNode != nullptr) {
-    adapterNode->adapterCleanup();
+  if (adapterNodeHandle != nullptr) {
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle->audioNode.get())->adapterCleanup();
   }
 
   return Result<std::tuple<std::vector<std::string>, double, double>, std::string>::Ok(
@@ -467,7 +468,7 @@ static void cleanupStartedRecorder(
 void IOSAudioRecorder::connect(const std::shared_ptr<utils::graph::NodeHandle> &node)
 {
   std::scoped_lock lock(adapterNodeMutex_);
-  adapterNode_ = node;
+  adapterNodeHandle_ = node;
   isConnected_.store(true, std::memory_order_release);
   connectedConfigured_.store(false, std::memory_order_release);
 
@@ -478,10 +479,11 @@ static void cleanupStartedRecorder(
       return;
     }
 
-    adapterNode_->init(
-        [nativeRecorder_ getResolvedBufferSize],
-        resolvedInputFormat.channelCount,
-        resolvedInputFormat.sampleRate);
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle_->audioNode.get())
+        ->init(
+            [nativeRecorder_ getBufferSize],
+            resolvedInputFormat.channelCount,
+            resolvedInputFormat.sampleRate);
     connectedConfigured_.store(true, std::memory_order_release);
   }
 }
@@ -491,18 +493,18 @@ static void cleanupStartedRecorder(
 /// This method should be called from the JS thread only.
 void IOSAudioRecorder::disconnect()
 {
-  std::shared_ptr<RecorderAdapterNode> adapterNode;
+  std::shared_ptr<utils::graph::NodeHandle> adapterNodeHandle;
   bool hadConnection = false;
   {
     std::scoped_lock lock(adapterNodeMutex_);
     hadConnection = isConnected();
     connectedConfigured_.store(false, std::memory_order_release);
     isConnected_.store(false, std::memory_order_release);
-    adapterNode = std::move(adapterNode_);
+    adapterNodeHandle = std::move(adapterNodeHandle_);
   }
 
-  if (hadConnection && adapterNode != nullptr) {
-    adapterNode->adapterCleanup();
+  if (hadConnection && adapterNodeHandle != nullptr) {
+    static_cast<RecorderAdapterNode *>(adapterNodeHandle->audioNode.get())->adapterCleanup();
   }
 }
 

From f9c78721d312ea942938e3f8c7a82af66409045a Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Tue, 21 Apr 2026 18:41:21 +0200
Subject: [PATCH 38/38] feat: tail time handling

---
 .../src/examples/ConvolverIR/ConvolverIR.tsx  |   1 -
 .../common/cpp/audioapi/core/AudioNode.cpp    |  97 +++++-
 .../common/cpp/audioapi/core/AudioNode.h      |  66 +++-
 .../core/effects/BiquadFilterNode.cpp         |  23 ++
 .../audioapi/core/effects/BiquadFilterNode.h  |  16 +
 .../audioapi/core/effects/ConvolverNode.cpp   |  35 ++-
 .../cpp/audioapi/core/effects/ConvolverNode.h |   8 +-
 .../cpp/audioapi/core/effects/DelayNode.cpp   |  16 +-
 .../cpp/audioapi/core/effects/DelayNode.h     |   4 -
 .../core/effects/delay/DelayWriter.cpp        |   8 +
 .../audioapi/core/effects/delay/DelayWriter.h |   8 +
 .../common/cpp/audioapi/types/NodeOptions.h   |   8 +
 .../src/core/effects/TailProcessingTest.cpp   | 284 ++++++++++++++++++
 13 files changed, 552 insertions(+), 22 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/test/src/core/effects/TailProcessingTest.cpp

diff --git a/apps/common-app/src/examples/ConvolverIR/ConvolverIR.tsx b/apps/common-app/src/examples/ConvolverIR/ConvolverIR.tsx
index e59012f42..2f831a4b9 100644
--- a/apps/common-app/src/examples/ConvolverIR/ConvolverIR.tsx
+++ b/apps/common-app/src/examples/ConvolverIR/ConvolverIR.tsx
@@ -72,7 +72,6 @@ const ConvolverIR: FC = () => {
       return;
     }
     bufferSourceRef.current?.stop(0);
-    await AudioManager.setAudioSessionActivity(false);
     setIsPlaying(false);
   }, []);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
index 0b2134e05..8c1a0a120 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.cpp
@@ -4,7 +4,10 @@
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
 
+#include <cstdint>
+#include <cstring>
 #include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -23,7 +26,21 @@ AudioNode::AudioNode(
 }
 
 bool AudioNode::canBeDestructed() const {
-  return true;
+  // Tail-bearing nodes must not be destroyed mid-tail: even if the node is
+  // orphaned and has no live inputs, audio that has not yet been rendered
+  // would otherwise be lost. Once the tail has fully drained, the node
+  // becomes destructible.
+  return !requiresTailProcessing_ || tailState_ == TailState::FINISHED;
+}
+
+bool AudioNode::isProcessable() const {
+  if (GraphObject::isProcessable()) {
+    return true;
+  }
+  // Even after a downstream disconnect flips processableState_ to
+  // NOT_PROCESSABLE, a tail-bearing node must keep being scheduled until its
+  // impulse response has decayed. Otherwise the tail would never play out.
+  return requiresTailProcessing_ && tailState_ != TailState::FINISHED;
 }
 
 size_t AudioNode::getChannelCount() const {
@@ -34,4 +51,82 @@ bool AudioNode::requiresTailProcessing() const {
   return requiresTailProcessing_;
 }
 
+namespace {
+
+// Branch-free silence check over a contiguous float span. Reinterprets each
+// sample as its IEEE-754 bit pattern and ORs them together with the sign bit
+// masked out, so `-0.0f` is treated as silent (matching `== 0.0f`). The lack
+// of an in-loop branch lets the compiler auto-vectorize this tight loop.
+[[nodiscard]] inline bool spanIsSilent(const float *data, size_t count) noexcept {
+  constexpr std::uint32_t kSignMask = 0x7FFFFFFFu;
+  std::uint32_t acc = 0;
+  for (size_t i = 0; i < count; ++i) {
+    std::uint32_t bits;
+    std::memcpy(&bits, data + i, sizeof(bits));
+    acc |= (bits & kSignMask);
+  }
+  return acc == 0;
+}
+
+} // namespace
+
+bool AudioNode::isInputSilent(const std::vector<const DSPAudioBuffer *> &inputs) const {
+  // No inputs means upstream is gone (or this node never had any). Either
+  // way the mixer below would feed silence to processNode, so treat it as
+  // silent input here.
+  if (inputs.empty()) {
+    return true;
+  }
+  for (const DSPAudioBuffer *input : inputs) {
+    if (input == nullptr) {
+      continue;
+    }
+    const size_t channels = input->getNumberOfChannels();
+    for (size_t c = 0; c < channels; ++c) {
+      auto *channel = input->getChannel(c);
+      if (channel == nullptr) {
+        continue;
+      }
+      const auto span = channel->span();
+      if (!spanIsSilent(span.data(), span.size())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void AudioNode::updateTailStateForQuantum(
+    const std::vector<const DSPAudioBuffer *> &inputs,
+    int numFrames) {
+  const bool silent = isInputSilent(inputs);
+
+  if (!silent) {
+    // Any non-silent sample re-arms the tail: the node is being driven again
+    // and we must not stop it mid-stream.
+    tailState_ = TailState::ACTIVE;
+    tailFramesRemaining_ = 0;
+    return;
+  }
+
+  switch (tailState_) {
+    case TailState::ACTIVE:
+      tailState_ = TailState::SIGNALLED_TO_STOP;
+      tailFramesRemaining_ = computeTailFrames();
+      if (tailFramesRemaining_ <= 0) {
+        tailState_ = TailState::FINISHED;
+      }
+      break;
+    case TailState::SIGNALLED_TO_STOP:
+      tailFramesRemaining_ -= numFrames;
+      if (tailFramesRemaining_ <= 0) {
+        tailState_ = TailState::FINISHED;
+      }
+      break;
+    case TailState::FINISHED:
+      // Stay finished; will be reset to ACTIVE if non-silent input returns.
+      break;
+  }
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
index 93ec4d95c..cfd8cdc2a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioNode.h
@@ -11,6 +11,7 @@
 
 #include <cassert>
 #include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <utility>
 #include <vector>
@@ -80,6 +81,33 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   /// @note JS Thread only
   [[nodiscard]] bool requiresTailProcessing() const;
 
+  /// @brief Tail-processing lifecycle state.
+  ///
+  /// Audio-thread only. Drives the "node has a non-zero impulse response that
+  /// must be played out after its inputs go silent" behavior required by the
+  /// Web Audio spec for nodes such as BiquadFilter, Delay and Convolver.
+  ///
+  /// Transitions (in `processInputs`, gated by `requiresTailProcessing_`):
+  /// - any quantum with non-silent input        : * -> ACTIVE (re-arm)
+  /// - first silent quantum after ACTIVE        : ACTIVE -> SIGNALLED_TO_STOP,
+  ///                                              tailFramesRemaining_ = computeTailFrames()
+  /// - subsequent silent quanta                 : tailFramesRemaining_ -= numFrames
+  ///                                              once <= 0, SIGNALLED_TO_STOP -> FINISHED
+  enum class TailState : std::uint8_t {
+    ACTIVE,
+    SIGNALLED_TO_STOP,
+    FINISHED,
+  };
+
+  /// @brief Returns whether this node should be processed during audio iteration.
+  ///
+  /// Extends the base GraphObject rule with: a tail-bearing node remains
+  /// processable until its tail has fully drained, even after its
+  /// `processableState_` was flipped to NOT_PROCESSABLE by a downstream
+  /// disconnect.
+  /// @note Audio Thread only.
+  [[nodiscard]] bool isProcessable() const override;
+
   template <typename F>
   bool scheduleAudioEvent(F &&event) noexcept {
     if (std::shared_ptr<BaseAudioContext> context = context_.lock()) {
@@ -126,9 +154,19 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
   const ChannelInterpretation channelInterpretation_ = ChannelInterpretation::SPEAKERS;
   const bool requiresTailProcessing_;
 
+  /// @brief Tail-processing audio-thread state. Only mutated when
+  /// `requiresTailProcessing_` is true.
+  TailState tailState_ = TailState::ACTIVE;
+  int tailFramesRemaining_ = 0;
+
   /// @brief Implementation of processing logic for AudioNode.
-  /// Mixes input buffers and calls processNode.
+  /// Mixes input buffers, runs the tail-state transition (when this node
+  /// requires tail processing), and calls processNode.
   void processInputs(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames) override {
+    if (requiresTailProcessing_) {
+      updateTailStateForQuantum(inputs, numFrames);
+    }
+
     getInputBuffer()->zero();
 
     for (const DSPAudioBuffer *input : inputs) {
@@ -138,7 +176,33 @@ class AudioNode : public utils::graph::GraphObject, public std::enable_shared_fr
     processNode(numFrames);
   }
 
+  /// @brief Returns the tail length in audio frames for the current node
+  /// state. Called when transitioning into `SIGNALLED_TO_STOP` so that the
+  /// frame counter starts from a fresh, up-to-date value.
+  ///
+  /// Default 0 — overriders are tail-bearing nodes (Biquad, Convolver,
+  /// DelayWriter). The implementation may read audio-thread-owned state
+  /// (filter coefficients, IR length, max delay).
+  ///
+  /// @note Audio Thread only.
+  [[nodiscard]] virtual int computeTailFrames() const {
+    return 0;
+  }
+
+  /// @brief Returns whether the set of input buffers carries no signal this
+  /// quantum. Default scans every sample. Tail-bearing nodes whose audio
+  /// inputs come from outside the graph (none today, but plausible) may
+  /// override.
+  ///
+  /// @note Audio Thread only.
+  [[nodiscard]] virtual bool isInputSilent(const std::vector<const DSPAudioBuffer *> &inputs) const;
+
   virtual void processNode(int) = 0;
+
+ private:
+  /// @brief Drives `tailState_` for one render quantum. Called from
+  /// `processInputs` only when `requiresTailProcessing_` is true.
+  void updateTailStateForQuantum(const std::vector<const DSPAudioBuffer *> &inputs, int numFrames);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
index d880d7921..0f4071b75 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.cpp
@@ -32,6 +32,8 @@
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
 
+#include <algorithm>
+#include <cmath>
 #include <memory>
 
 // https://webaudio.github.io/Audio-EQ-Cookbook/audio-eq-cookbook.html - math
@@ -389,6 +391,9 @@ void BiquadFilterNode::processNode(int framesToProcess) {
 
     auto coeffs = applyFilter(frequency, Q, gain, detune, type_);
 
+    // Cache for computeTailFrames(); read on the same thread.
+    lastA2_ = coeffs.a2;
+
     float x1, x2, y1, y2; // NOLINT(cppcoreguidelines-init-variables)
 
     auto numChannels = audioBuffer_->getNumberOfChannels();
@@ -429,6 +434,24 @@ void BiquadFilterNode::processNode(int framesToProcess) {
   }
 }
 
+int BiquadFilterNode::computeTailFrames() const {
+  // For a stable biquad H(z) = (b0 + b1 z^-1 + b2 z^-2) / (1 + a1 z^-1 + a2 z^-2),
+  // the poles are roots of z^2 + a1 z + a2. Their product equals a2, so the
+  // larger pole magnitude is bounded by sqrt(|a2|). Using that as `r`, the
+  // impulse decays roughly like `r^n`; the number of frames until it drops
+  // below kTailEpsilon is `ceil(log(eps)/log(r))`.
+  const double r = std::min(std::sqrt(std::abs(lastA2_)), 0.999);
+  if (r <= 0.0) {
+    return 0;
+  }
+  const double frames = std::ceil(std::log(kTailEpsilon) / std::log(r));
+  const int cap = static_cast<int>(kMaxTailSeconds * getContextSampleRate());
+  if (!std::isfinite(frames) || frames <= 0.0) {
+    return 0;
+  }
+  return std::min(static_cast<int>(frames), cap);
+}
+
 } // namespace audioapi
 
 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers, readability-magic-numbers, readability-identifier-length)
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h
index de45fa9f3..f9adbf8e1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/BiquadFilterNode.h
@@ -70,13 +70,29 @@ class BiquadFilterNode : public AudioNode {
  protected:
   void processNode(int framesToProcess) override;
 
+  /// @brief IIR tail length, derived from the dominant pole magnitude of the
+  /// most recently applied filter coefficients (`r ≈ sqrt(|a2|)`). Returns
+  /// the number of frames until the impulse response decays below
+  /// `kTailEpsilon`, capped at `kMaxTailSeconds * sampleRate`.
+  /// @note Audio Thread only.
+  [[nodiscard]] int computeTailFrames() const override;
+
  private:
+  static constexpr double kTailEpsilon = 1e-4;   // -80 dB
+  static constexpr float kMaxTailSeconds = 0.5f; // safety cap
+
   const std::shared_ptr<AudioParam> frequencyParam_;
   const std::shared_ptr<AudioParam> detuneParam_;
   const std::shared_ptr<AudioParam> QParam_;
   const std::shared_ptr<AudioParam> gainParam_;
   BiquadFilterType type_;
 
+  /// Most recently applied `a2` coefficient, cached on the audio thread by
+  /// `processNode`. Used by `computeTailFrames` to estimate decay length.
+  /// `r = sqrt(|a2|)` is a conservative upper bound on the dominant pole
+  /// magnitude for stable biquads.
+  double lastA2_ = 0.0;
+
   // delayed samples, one per channel
   DSPAudioArray x1_;
   DSPAudioArray x2_;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
index 762770171..8ff0f898d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.cpp
@@ -15,9 +15,7 @@ ConvolverNode::ConvolverNode(
     const ConvolverOptions &options)
     : AudioNode(context, options),
       gainCalibrationSampleRate_(context->getSampleRate()),
-      remainingSegments_(0),
       internalBufferIndex_(0),
-      signalledToStop_(false),
       scaleFactor_(1.0f),
       intermediateBuffer_(nullptr),
       buffer_(nullptr),
@@ -43,8 +41,8 @@ void ConvolverNode::setBuffer(
     context->getDisposer()->dispose(std::move(threadPool_));
   }
 
-  for (auto it = convolvers_.begin(); it != convolvers_.end(); ++it) {
-    context->getDisposer()->dispose(std::move(*it));
+  for (auto &convolver : convolvers_) {
+    context->getDisposer()->dispose(std::move(convolver));
   }
 
   if (internalBuffer_ != nullptr) {
@@ -62,6 +60,13 @@ void ConvolverNode::setBuffer(
   intermediateBuffer_ = intermediateBuffer;
   scaleFactor_ = scaleFactor;
   internalBufferIndex_ = 0;
+
+  // Re-arm the tail: a brand-new IR may have a completely different length,
+  // and any pending tail countdown from the previous IR is now meaningless.
+  // The base-class state machine will recompute computeTailFrames() the next
+  // time the input goes silent.
+  tailState_ = TailState::ACTIVE;
+  tailFramesRemaining_ = 0;
 }
 
 float ConvolverNode::calculateNormalizationScale(const std::shared_ptr<AudioBuffer> &buffer) const {
@@ -99,14 +104,13 @@ void ConvolverNode::processNode(int framesToProcess) {
     printf(
         "[AUDIOAPI WARN] convolver requires 128 buffer size for each render quantum, otherwise quality of convolution is very poor\n");
   }
-  if (signalledToStop_) {
-    if (remainingSegments_ > 0) {
-      remainingSegments_--;
-    } else {
-      signalledToStop_ = false;
-      internalBufferIndex_ = 0;
-      return;
-    }
+
+  // Once the base-class tail counter has fully drained, stop convolving and
+  // emit silence; the IR's contribution has decayed beyond audibility.
+  if (tailState_ == TailState::FINISHED) {
+    audioBuffer_->zero();
+    internalBufferIndex_ = 0;
+    return;
   }
 
   if (internalBufferIndex_ < framesToProcess) {
@@ -134,6 +138,13 @@ void ConvolverNode::processNode(int framesToProcess) {
   }
 }
 
+int ConvolverNode::computeTailFrames() const {
+  // The convolver's impulse response equals the IR buffer itself, so a full
+  // tail equals one IR length of samples. If no IR has been set yet, there
+  // is nothing to ring out.
+  return buffer_ ? static_cast<int>(buffer_->getSize()) : 0;
+}
+
 void ConvolverNode::performConvolution(const std::shared_ptr<DSPAudioBuffer> &processingBuffer) {
   if (processingBuffer->getNumberOfChannels() == 1) {
     for (int i = 0; i < convolvers_.size(); ++i) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
index b31b620f0..5c1486822 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/ConvolverNode.h
@@ -38,11 +38,15 @@ class ConvolverNode : public AudioNode {
  protected:
   void processNode(int framesToProcess) override;
 
+  /// @brief Tail length equals the impulse-response length in frames. A
+  /// freshly loaded IR makes the convolver ring for at least its own length
+  /// after the input goes silent.
+  /// @note Audio Thread only.
+  [[nodiscard]] int computeTailFrames() const override;
+
  private:
   const float gainCalibrationSampleRate_;
-  size_t remainingSegments_;
   size_t internalBufferIndex_;
-  bool signalledToStop_;
   float scaleFactor_;
   std::shared_ptr<DSPAudioBuffer> intermediateBuffer_;
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
index e754b78af..7dd37cd4f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.cpp
@@ -24,7 +24,21 @@ DelayNode::DelayNode(const std::shared_ptr<BaseAudioContext> &context, const Del
               channelCount_,
               context->getSampleRate())) {
   delayLine_ = std::make_shared<DelayLine>(delayBuffer_, delayTimeParam_);
-  delayReader_ = std::make_unique<DelayReader>(context, options, delayLine_);
+
+  // Tail processing belongs to the writer: when the writer's upstream goes
+  // silent, the writer must keep filling the ring with zeros for one full
+  // `maxDelayTime` so that the reader naturally drains to silence. The
+  // reader has no audio inputs (its data comes from the shared ring) and is
+  // GC'd via the linkNodes(reader, writer) propagation, so it sets
+  // `requiresTailProcessing = false` to opt out of the base-class state
+  // machine that would otherwise consider it permanently "silent".
+  AudioNodeOptions readerOptions = options;
+  // Reader has no audio inputs (its data comes from the shared ring) and
+  // does not own the tail — see comment above.
+  readerOptions.numberOfInputs = 0;
+  readerOptions.requiresTailProcessing = false;
+
+  delayReader_ = std::make_unique<DelayReader>(context, readerOptions, delayLine_);
   delayWriter_ = std::make_unique<DelayWriter>(context, options, delayLine_);
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
index 36680b24f..7f3949146 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/DelayNode.h
@@ -29,12 +29,8 @@ class DelayNode : public AudioNode {
   };
 
  private:
-  enum class BufferAction : uint8_t { READ, WRITE };
   const std::shared_ptr<AudioParam> delayTimeParam_;
   std::shared_ptr<AudioBuffer> delayBuffer_;
-  size_t readIndex_ = 0;
-  bool signalledToStop_ = false;
-  int remainingFrames_ = 0;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp
index ed4bba8cc..e653842de 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.cpp
@@ -36,4 +36,12 @@ void DelayWriter::processNode(int framesToProcess) {
       delayBuffer, audioBuffer_, framesToProcess, writeIndex, delay_ring::BufferAction::WRITE);
 }
 
+int DelayWriter::computeTailFrames() const {
+  // `getMaxValue()` of the delayTime param was set to `maxDelayTime` by the
+  // owning DelayNode constructor.
+  const auto sampleRate = delayLine_->getBuffer() ? delayLine_->getBuffer()->getSampleRate() : 0.0f;
+  const float maxDelaySeconds = delayLine_->getDelayTimeParam()->getMaxValue();
+  return static_cast<int>(maxDelaySeconds * sampleRate);
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h
index fa7616e3a..5abaffffb 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/effects/delay/DelayWriter.h
@@ -21,6 +21,14 @@ class DelayWriter : public AudioNode {
 
   void processNode(int framesToProcess) override;
 
+ protected:
+  /// @brief Tail length equals one full `maxDelayTime` worth of frames: the
+  /// writer must keep filling the ring with zeros for at least that long
+  /// after upstream goes silent so the reader can drain the audio currently
+  /// stored in the ring.
+  /// @note Audio Thread only.
+  [[nodiscard]] int computeTailFrames() const override;
+
  private:
   std::shared_ptr<DelayLine> delayLine_;
 };
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
index 8acbbede4..b19466e10 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
@@ -88,6 +88,14 @@ struct BiquadFilterOptions : AudioNodeOptions {
   float detune = 0.0f;
   float Q = 1.0f;
   float gain = 0.0f;
+
+  BiquadFilterOptions() {
+    requiresTailProcessing = true;
+  }
+
+  explicit BiquadFilterOptions(AudioNodeOptions options) : AudioNodeOptions(options) {
+    requiresTailProcessing = true;
+  }
 };
 
 struct OscillatorOptions : AudioScheduledSourceNodeOptions {
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/effects/TailProcessingTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/effects/TailProcessingTest.cpp
new file mode 100644
index 000000000..66844fabd
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/effects/TailProcessingTest.cpp
@@ -0,0 +1,284 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/core/effects/delay/DelayLine.h>
+#include <audioapi/core/effects/delay/DelayWriter.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/types/NodeOptions.h>
+#include <audioapi/utils/AudioArray.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+#include <memory>
+#include <vector>
+
+using namespace audioapi;
+
+// NOLINTBEGIN
+
+namespace {
+
+constexpr int kQuantum = 128;
+constexpr int kSampleRate = 44100;
+
+// Builds a single-channel buffer that is either fully silent or filled with
+// a constant non-zero value.
+std::shared_ptr<DSPAudioBuffer> makeBuffer(bool nonZero, int channels = 2) {
+  auto buf = std::make_shared<DSPAudioBuffer>(kQuantum, channels, kSampleRate);
+  if (nonZero) {
+    for (int c = 0; c < channels; ++c) {
+      for (size_t i = 0; i < buf->getSize(); ++i) {
+        (*buf->getChannel(c))[i] = 0.5f;
+      }
+    }
+  } else {
+    buf->zero();
+  }
+  return buf;
+}
+
+// Test harness exposing `processInputs` and the protected tail-state fields
+// so we can drive and inspect the state machine deterministically.
+template <typename NodeT>
+class TailHarness : public NodeT {
+ public:
+  using NodeT::NodeT;
+
+  // Hand-built equivalent of `process(inputs, n)` that does not require a
+  // full graph: forwards a vector of raw buffer pointers straight into the
+  // base-class `processInputs`. The mixing path uses these as inputs.
+  void runQuantum(const std::vector<const DSPAudioBuffer *> &inputs) {
+    this->processInputs(inputs, kQuantum);
+  }
+
+  AudioNode::TailState tailState() const {
+    return this->tailState_;
+  }
+  int tailFramesRemaining() const {
+    return this->tailFramesRemaining_;
+  }
+  int computeTail() const {
+    return this->computeTailFrames();
+  }
+  using NodeT::canBeDestructed;
+  using NodeT::isProcessable;
+};
+
+class TailProcessingTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::shared_ptr<OfflineAudioContext> context;
+  std::shared_ptr<AudioDestinationNode> destination;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_shared<OfflineAudioContext>(
+        2, 5 * kSampleRate, kSampleRate, eventRegistry, RuntimeRegistry{});
+    destination = std::make_shared<AudioDestinationNode>(context);
+    context->initialize(destination.get());
+  }
+};
+
+// ─── BiquadFilter ─────────────────────────────────────────────────────────
+
+TEST_F(TailProcessingTest, BiquadFilterDeclaresTailProcessing) {
+  BiquadFilterOptions opts{};
+  EXPECT_TRUE(opts.requiresTailProcessing);
+
+  auto biquad = std::make_shared<BiquadFilterNode>(context, opts);
+  EXPECT_TRUE(biquad->requiresTailProcessing());
+}
+
+TEST_F(TailProcessingTest, BiquadFilterStartsActiveAndStaysSoUnderInput) {
+  TailHarness<BiquadFilterNode> biquad(context, BiquadFilterOptions());
+
+  auto nonSilent = makeBuffer(/*nonZero=*/true);
+  std::vector<const DSPAudioBuffer *> inputs{nonSilent.get()};
+
+  EXPECT_EQ(biquad.tailState(), AudioNode::TailState::ACTIVE);
+
+  for (int q = 0; q < 4; ++q) {
+    biquad.runQuantum(inputs);
+  }
+
+  EXPECT_EQ(biquad.tailState(), AudioNode::TailState::ACTIVE);
+  EXPECT_TRUE(biquad.isProcessable());
+  EXPECT_FALSE(biquad.canBeDestructed()) << "An ACTIVE tail-bearing node must not be destructible";
+}
+
+TEST_F(TailProcessingTest, BiquadFilterDrainsTailAfterInputGoesSilent) {
+  TailHarness<BiquadFilterNode> biquad(context, BiquadFilterOptions());
+
+  auto nonSilent = makeBuffer(/*nonZero=*/true);
+  auto silent = makeBuffer(/*nonZero=*/false);
+
+  // One non-silent quantum primes the filter coefficients (lastA2_).
+  biquad.runQuantum({nonSilent.get()});
+  ASSERT_EQ(biquad.tailState(), AudioNode::TailState::ACTIVE);
+
+  // First silent quantum signals stop and seeds the countdown.
+  biquad.runQuantum({silent.get()});
+  EXPECT_EQ(biquad.tailState(), AudioNode::TailState::SIGNALLED_TO_STOP);
+  const int initialTail = biquad.tailFramesRemaining();
+  EXPECT_GT(initialTail, 0);
+
+  // The countdown decreases by `kQuantum` per silent quantum.
+  biquad.runQuantum({silent.get()});
+  if (biquad.tailState() == AudioNode::TailState::SIGNALLED_TO_STOP) {
+    EXPECT_LE(biquad.tailFramesRemaining(), initialTail - kQuantum);
+  }
+
+  // Drain the rest until FINISHED.
+  for (int q = 0; q < 1000 && biquad.tailState() != AudioNode::TailState::FINISHED; ++q) {
+    biquad.runQuantum({silent.get()});
+  }
+  EXPECT_EQ(biquad.tailState(), AudioNode::TailState::FINISHED);
+  EXPECT_TRUE(biquad.canBeDestructed());
+  // Once finished and downstream is gone, isProcessable() falls back to the
+  // base GraphObject rule (NOT_PROCESSABLE by default).
+  EXPECT_FALSE(biquad.isProcessable());
+}
+
+TEST_F(TailProcessingTest, BiquadFilterReArmsOnNewInput) {
+  TailHarness<BiquadFilterNode> biquad(context, BiquadFilterOptions());
+
+  auto nonSilent = makeBuffer(/*nonZero=*/true);
+  auto silent = makeBuffer(/*nonZero=*/false);
+
+  biquad.runQuantum({nonSilent.get()});
+  biquad.runQuantum({silent.get()});
+  ASSERT_EQ(biquad.tailState(), AudioNode::TailState::SIGNALLED_TO_STOP);
+
+  // A non-silent quantum should restore ACTIVE and reset the counter.
+  biquad.runQuantum({nonSilent.get()});
+  EXPECT_EQ(biquad.tailState(), AudioNode::TailState::ACTIVE);
+  EXPECT_EQ(biquad.tailFramesRemaining(), 0);
+}
+
+TEST_F(TailProcessingTest, BiquadFilterTailLengthFollowsCoefficients) {
+  TailHarness<BiquadFilterNode> biquad(context, BiquadFilterOptions());
+
+  // Without ever running processNode, lastA2_ is 0 → tail is 0 frames.
+  EXPECT_EQ(biquad.computeTail(), 0);
+
+  // After processing one quantum of audio the coefficients are populated and
+  // the tail length should be a positive, finite number of frames bounded
+  // by the 0.5-second cap.
+  auto nonSilent = makeBuffer(/*nonZero=*/true);
+  biquad.runQuantum({nonSilent.get()});
+
+  const int tail = biquad.computeTail();
+  EXPECT_GE(tail, 0);
+  EXPECT_LE(tail, static_cast<int>(0.5f * kSampleRate));
+}
+
+// ─── DelayWriter ──────────────────────────────────────────────────────────
+
+TEST_F(TailProcessingTest, DelayWriterTailEqualsMaxDelayInFrames) {
+  DelayOptions opts{};
+  opts.maxDelayTime = 0.25f;
+  auto delayNode = std::make_shared<DelayNode>(context, opts);
+
+  // The DelayNode's writer is tail-bearing; query computeTailFrames via the
+  // public AudioNode contract by reaching through `delayWriter_`.
+  auto *writer = static_cast<DelayWriter *>(delayNode->delayWriter_.get());
+
+  // We can't call computeTailFrames directly (protected), but we can verify
+  // requiresTailProcessing is on and exercise the state machine via the
+  // base-class hooks instead. The numerical equivalence of the tail length
+  // is covered by the DrainsTail test below.
+  EXPECT_TRUE(writer->requiresTailProcessing());
+}
+
+TEST_F(TailProcessingTest, DelayWriterDrainsTailAfterInputSilences) {
+  DelayOptions opts{};
+  opts.maxDelayTime = (10.0f * kQuantum) / kSampleRate; // 10 quanta of tail
+  auto delayNode = std::make_shared<DelayNode>(context, opts);
+
+  // Re-create the writer as a TailHarness so we can poke its private state.
+  // The writer just needs the same DelayLine; share it.
+  TailHarness<DelayWriter> writer(context, opts, delayNode->delayLine_);
+
+  auto nonSilent = makeBuffer(/*nonZero=*/true);
+  auto silent = makeBuffer(/*nonZero=*/false);
+
+  writer.runQuantum({nonSilent.get()});
+  ASSERT_EQ(writer.tailState(), AudioNode::TailState::ACTIVE);
+
+  // First silent quantum starts the countdown of ~10 quanta.
+  writer.runQuantum({silent.get()});
+  ASSERT_EQ(writer.tailState(), AudioNode::TailState::SIGNALLED_TO_STOP);
+  EXPECT_GT(writer.tailFramesRemaining(), 0);
+  EXPECT_LE(writer.tailFramesRemaining(), 10 * kQuantum);
+
+  for (int q = 0; q < 64 && writer.tailState() != AudioNode::TailState::FINISHED; ++q) {
+    writer.runQuantum({silent.get()});
+  }
+  EXPECT_EQ(writer.tailState(), AudioNode::TailState::FINISHED);
+  EXPECT_TRUE(writer.canBeDestructed());
+}
+
+// ─── ConvolverNode ────────────────────────────────────────────────────────
+
+TEST_F(TailProcessingTest, ConvolverDeclaresTailProcessing) {
+  ConvolverOptions opts{};
+  EXPECT_TRUE(opts.requiresTailProcessing);
+
+  auto conv = std::make_shared<ConvolverNode>(context, opts);
+  EXPECT_TRUE(conv->requiresTailProcessing());
+}
+
+TEST_F(TailProcessingTest, ConvolverWithoutBufferHasZeroTail) {
+  TailHarness<ConvolverNode> conv(context, ConvolverOptions());
+
+  // No IR loaded yet → no tail, regardless of input history.
+  EXPECT_EQ(conv.computeTail(), 0);
+
+  auto nonSilent = makeBuffer(/*nonZero=*/true);
+  auto silent = makeBuffer(/*nonZero=*/false);
+  conv.runQuantum({nonSilent.get()});
+  conv.runQuantum({silent.get()});
+
+  // SIGNALLED_TO_STOP with a 0-frame countdown collapses to FINISHED in the
+  // same quantum.
+  EXPECT_EQ(conv.tailState(), AudioNode::TailState::FINISHED);
+  EXPECT_TRUE(conv.canBeDestructed());
+}
+
+TEST_F(TailProcessingTest, ConvolverTailLengthEqualsIRLength) {
+  TailHarness<ConvolverNode> conv(context, ConvolverOptions());
+
+  // Build a minimal IR buffer. We deliberately avoid constructing real
+  // convolvers/threadpool/internal buffers: setBuffer only reads the IR's
+  // length and resets tail bookkeeping — the convolution path (processNode)
+  // is not exercised here.
+  constexpr size_t kIrFrames = 2048;
+  auto ir = std::make_shared<AudioBuffer>(kIrFrames, 1, kSampleRate);
+
+  conv.setBuffer(
+      ir,
+      /*convolvers=*/{},
+      /*threadPool=*/nullptr,
+      /*internalBuffer=*/nullptr,
+      /*intermediateBuffer=*/nullptr,
+      /*scaleFactor=*/1.0f);
+
+  EXPECT_EQ(conv.computeTail(), static_cast<int>(kIrFrames));
+
+  // setBuffer must also re-arm the tail state machine.
+  EXPECT_EQ(conv.tailState(), AudioNode::TailState::ACTIVE);
+  EXPECT_EQ(conv.tailFramesRemaining(), 0);
+  EXPECT_FALSE(conv.canBeDestructed()) << "A newly-armed convolver with a tail must stay alive";
+
+  // Swapping to a shorter IR updates the tail length on next silence.
+  constexpr size_t kShorterFrames = 512;
+  auto shorterIr = std::make_shared<AudioBuffer>(kShorterFrames, 1, kSampleRate);
+  conv.setBuffer(shorterIr, {}, nullptr, nullptr, nullptr, 1.0f);
+  EXPECT_EQ(conv.computeTail(), static_cast<int>(kShorterFrames));
+}
+
+// NOLINTEND
+} // namespace