react-native-audio-api 1.0.0 → 1.1.0-nightly-1df11c0-20261105

package/common/cpp/audioapi/core/utils/graph/AudioGraph.cpp

@@ -16,6 +16,18 @@ auto AudioGraph::operator[](std::uint32_t index) const -> const Vertex & {
   return nodes[index];
 }
 
+auto AudioGraph::operator[](const NodeHandle &handle) -> Vertex & {
+  return nodes[handle.index_];
+}
+
+auto AudioGraph::operator[](const NodeHandle &handle) const -> const Vertex & {
+  return nodes[handle.index_];
+}
+
+std::uint32_t AudioGraph::indexOf(const NodeHandle &handle) const {
+  return handle.index_;
+}
+
 size_t AudioGraph::size() const {
   return nodes.size();
 }
@@ -43,7 +55,7 @@ void AudioGraph::markDirty() {
 }
 
 void AudioGraph::addNode(std::shared_ptr<NodeHandle> handle) {
-  handle->index = static_cast<std::uint32_t>(nodes.size());
+  handle->index_ = static_cast<std::uint32_t>(nodes.size());
   nodes.emplace_back(std::move(handle));
 }
 
@@ -120,7 +132,7 @@ void AudioGraph::sortAndCompact() {
     if (b != e) {
       nodes[b] = std::move(nodes[e]);
     }
-    nodes[b].handle->index = b;
+    nodes[b].handle->index_ = b;
     b++;
   }
 
@@ -242,7 +254,7 @@ void AudioGraph::kahn_toposort() {
   // 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].handle->index_ = i;
     }
     nodes[i].target_place = -1;
   }

package/common/cpp/audioapi/core/utils/graph/AudioGraph.h

@@ -103,6 +103,16 @@ class AudioGraph {
   /// @brief Access node by flat-vector index (const).
   [[nodiscard]] const Vertex &operator[](std::uint32_t index) const;
 
+  /// @brief Access the node a handle refers to, at its current position.
+  [[nodiscard]] Vertex &operator[](const NodeHandle &handle);
+
+  /// @brief Access the node a handle refers to, at its current position (const).
+  [[nodiscard]] const Vertex &operator[](const NodeHandle &handle) const;
+
+  /// @brief Current flat-vector position of the handle's node.
+  /// @note Valid only until the next sortAndCompact(); never cache it across threads.
+  [[nodiscard]] std::uint32_t indexOf(const NodeHandle &handle) const;
+
   /// @brief Number of live nodes in the graph.
   [[nodiscard]] size_t size() const;
 

package/common/cpp/audioapi/core/utils/graph/Graph.cpp

@@ -82,7 +82,7 @@ void Graph::advanceUnpulledNodes(std::size_t currentSampleFrame) {
 Graph::HostVertex *Graph::addNode(std::unique_ptr<GraphObject> audioNode) {
   // collectDisposedNodes();
 
-  auto handle = std::make_shared<NodeHandle>(0, std::move(audioNode));
+  auto handle = std::make_shared<NodeHandle>(std::move(audioNode));
   auto [hostNode, event] = hostGraph.addNode(handle);
 
   sendNodeGrowIfNeeded();

package/common/cpp/audioapi/core/utils/graph/HostGraph.cpp

@@ -298,8 +298,7 @@ auto HostGraph::removeNode(HostVertex *node) -> Result<AGEvent, GraphError> {
 
   node->ghost = true;
 
-  return Ok(
-      [h = node->handle](AudioGraph &graph, auto &) mutable { graph[h->index].orphaned = true; });
+  return Ok([h = node->handle](AudioGraph &graph, auto &) mutable { graph[*h].orphaned = true; });
 }
 
 auto HostGraph::addEdge(HostVertex *from, HostVertex *to) -> Result<AGEvent, GraphError> {
@@ -355,7 +354,7 @@ auto HostGraph::addEdge(HostVertex *from, HostVertex *to) -> Result<AGEvent, Gra
         disposer.dispose(toNode->exchangeInputScratch(std::move(*reservedInputs)));
         // dispose the unique_ptr
         disposer.dispose(std::move(reservedInputs));
-        graph.pool().push(graph[hTo->index].input_head, hFrom->index);
+        graph.pool().push(graph[*hTo].input_head, graph.indexOf(*hFrom));
         graph.markDirty();
       });
 }
@@ -395,7 +394,7 @@ auto HostGraph::removeEdge(HostVertex *from, HostVertex *to) -> Result<AGEvent,
                 AudioGraph &graph, auto &disposer) mutable {
     applyChannelNegotiations(*negotiations, disposer);
     disposer.dispose(std::move(negotiations));
-    graph.pool().remove(graph[hTo->index].input_head, hFrom->index);
+    graph.pool().remove(graph[*hTo].input_head, graph.indexOf(*hFrom));
     graph.markDirty();
   });
 }
@@ -406,8 +405,6 @@ auto HostGraph::removeAllEdges(HostVertex *from) -> Result<AGEvent, GraphError>
     return Err(GraphError::NODE_NOT_FOUND);
   }
 
-  auto pairs = std::vector<std::pair<std::uint32_t, std::uint32_t>>();
-  pairs.reserve(from->outputs.size());
   auto formerOutputs = std::vector<HostVertex *>();
   formerOutputs.reserve(from->outputs.size());
 
@@ -417,7 +414,6 @@ auto HostGraph::removeAllEdges(HostVertex *from) -> Result<AGEvent, GraphError>
       to->inputs.erase(itIn);
     }
     edgeCount_--;
-    pairs.emplace_back(from->handle->index, to->handle->index);
     formerOutputs.push_back(to);
   }
   from->outputs.clear();
@@ -432,15 +428,23 @@ auto HostGraph::removeAllEdges(HostVertex *from) -> Result<AGEvent, GraphError>
   // that lost this input re-derives its layout.
   auto negotiations = collectNegotiations(++channelLayoutTerm_, formerOutputs);
 
-  return Ok([pairs = std::move(pairs), negotiations = std::move(negotiations)](
-                AudioGraph &graph, auto &disposer) mutable {
+  auto formerOutputHandles = std::vector<std::shared_ptr<NodeHandle>>();
+  formerOutputHandles.reserve(from->outputs.size());
+  std::ranges::for_each(formerOutputs, [&formerOutputHandles](const auto *to) {
+    formerOutputHandles.push_back(to->handle);
+  });
+
+  return Ok([hFrom = from->handle,
+             formerOutputHandles = std::move(formerOutputHandles),
+             negotiations = std::move(negotiations)](AudioGraph &graph, auto &disposer) mutable {
     applyChannelNegotiations(*negotiations, disposer);
     disposer.dispose(std::move(negotiations));
-    for (const auto &[fromIdx, toIdx] : pairs) {
-      graph.pool().remove(graph[toIdx].input_head, fromIdx);
+    for (const auto &hTo : formerOutputHandles) {
+      graph.pool().remove(graph[*hTo].input_head, graph.indexOf(*hFrom));
     }
     graph.markDirty();
-    disposer.dispose(std::move(pairs));
+    // Off the audio thread, so these handle releases never run here.
+    disposer.dispose(std::move(formerOutputHandles));
   });
 }
 
@@ -510,7 +514,7 @@ std::optional<HostGraph::AGEvent> HostGraph::linkNodes(HostVertex *from, HostVer
   linkCount_++;
 
   return AGEvent([hFrom = from->handle, hTo = to->handle](AudioGraph &graph, auto &) mutable {
-    graph.pool().push(graph[hFrom->index].link_head, hTo->index);
+    graph.pool().push(graph[*hFrom].link_head, graph.indexOf(*hTo));
     graph.markDirty();
   });
 }

package/common/cpp/audioapi/core/utils/graph/NodeHandle.cpp

@@ -4,7 +4,6 @@
 
 namespace audioapi::utils::graph {
 
-NodeHandle::NodeHandle(std::uint32_t index, std::unique_ptr<GraphObject> audioNode)
-    : audioNode(std::move(audioNode)), index(index) {}
+NodeHandle::NodeHandle(std::unique_ptr<GraphObject> audioNode) : audioNode(std::move(audioNode)) {}
 
 } // namespace audioapi::utils::graph

package/common/cpp/audioapi/core/utils/graph/NodeHandle.h

@@ -10,8 +10,8 @@ namespace audioapi::utils::graph {
 /// @brief Shared handle bridging HostGraph and AudioGraph.
 ///
 /// A single heap allocation stores both the payload node and the mutable
-/// index into AudioGraph's flat vector. AudioGraph updates the index during
-/// compaction and topological sort.
+/// index into AudioGraph's flat vector. AudioGraph assigns the index in
+/// addNode() and updates it during compaction and topological sort.
 ///
 /// Ownership model (shared_ptr):
 /// - Created on the main thread via std::make_shared.
@@ -21,11 +21,18 @@ 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.
+///
+/// The position is private to AudioGraph: only the audio thread may read it,
+/// through `AudioGraph::operator[](const NodeHandle &)` or `AudioGraph::indexOf`,
+/// because every toposort and compaction rewrites it.
 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);
+  explicit NodeHandle(std::unique_ptr<GraphObject> audioNode);
+
+ private:
+  friend class AudioGraph;
+  std::uint32_t index_ = 0; // current position in AudioGraph::nodes
 };
 
 } // namespace audioapi::utils::graph

package/common/cpp/audioapi/core/utils/graph/README.md

@@ -23,7 +23,7 @@ It has very limited task that needs to be performed very fast, so it is designed
 `InputPool.hpp` contains the `InputPool` class which is responsible for managing the pool of edges. It is designed to be as efficient as possible, so it uses a free list to manage the pool of edges. It also provides API for allocating and deallocating edges. It is designed to be used on the audio thread, so it is not thread safe and should be used within the `AudioGraph` class. Or its events.
 
 ## NodeHandle
-`NodeHandle.hpp` contains the `NodeHandle` class which is responsible for managing node index in AudioGraph. Indices are 32 bit to minimize memory usage and maximize cache efficiency. So it is only to be used in `AGEvent` closures to reference nodes in `AudioGraph` only having a handle to it.
+`NodeHandle.h` contains the `NodeHandle` class which is responsible for managing node index in AudioGraph. Indices are 32 bit to minimize memory usage and maximize cache efficiency. So it is only to be used in `AGEvent` closures to reference nodes in `AudioGraph` only having a handle to it.
 
 ## Disposer
 `Disposer.hpp` contains the `Disposer` class which is responsible for managing the disposal of nodes and edges. It is designed to be used on single thread. It has a worker thread that we can offload destruction onto through SPSC queue. It is more robust then previous implementation allowing wide range of payloads to be disposed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "1.0.0",
+  "version": "1.1.0-nightly-1df11c0-20261105",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"