@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactCommon/jsinspector-modern/tests/HostTargetTest.cpp

@@ -217,6 +217,59 @@ TEST_F(HostTargetProtocolTest, PageReloadMethod) {
                          })");
 }
 
+TEST_F(HostTargetProtocolTest, PageAddAndRemoveScriptToEvaluateOnNewDocument) {
+  InSequence s;
+
+  // The first registered script gets identifier "1".
+  EXPECT_CALL(fromPage(), onMessage(JsonEq(R"({
+                                               "id": 1,
+                                               "result": {"identifier": "1"}
+                                             })")))
+      .RetiresOnSaturation();
+  toPage_->sendMessage(R"({
+                           "id": 1,
+                           "method": "Page.addScriptToEvaluateOnNewDocument",
+                           "params": {"source": "globalThis.__a = 1;"}
+                         })");
+
+  // The second registration gets a distinct, monotonically increasing id "2".
+  EXPECT_CALL(fromPage(), onMessage(JsonEq(R"({
+                                               "id": 2,
+                                               "result": {"identifier": "2"}
+                                             })")))
+      .RetiresOnSaturation();
+  toPage_->sendMessage(R"({
+                           "id": 2,
+                           "method": "Page.addScriptToEvaluateOnNewDocument",
+                           "params": {"source": "globalThis.__b = 2;"}
+                         })");
+
+  // Removing a registered script succeeds with an empty result.
+  EXPECT_CALL(fromPage(), onMessage(JsonEq(R"({
+                                               "id": 3,
+                                               "result": {}
+                                             })")))
+      .RetiresOnSaturation();
+  toPage_->sendMessage(R"({
+                           "id": 3,
+                           "method": "Page.removeScriptToEvaluateOnNewDocument",
+                           "params": {"identifier": "1"}
+                         })");
+
+  // Removing an unknown identifier is a lenient no-op that still succeeds
+  // (matching Chrome's behaviour).
+  EXPECT_CALL(fromPage(), onMessage(JsonEq(R"({
+                                               "id": 4,
+                                               "result": {}
+                                             })")))
+      .RetiresOnSaturation();
+  toPage_->sendMessage(R"({
+                           "id": 4,
+                           "method": "Page.removeScriptToEvaluateOnNewDocument",
+                           "params": {"identifier": "999"}
+                         })");
+}
+
 TEST_F(HostTargetProtocolTest, OverlaySetPausedInDebuggerMessageMethod) {
   InSequence s;
 

package/ReactCommon/jsinspector-modern/tracing/HostTracingProfile.h

@@ -23,9 +23,22 @@ namespace facebook::react::jsinspector_modern::tracing {
  * messages.
  */
 struct HostTracingProfile {
+  HostTracingProfile() = default;
+
+  // Explicitly move-only: FrameTimingSequence and RuntimeSamplingProfile are
+  // not copyable, so the implicit copy constructor is ill-formed the moment it
+  // is instantiated. Plain C++ never instantiates it, but Swift's C++ interop
+  // does when these headers are reached from an imported module, turning it
+  // into a hard compile error (Xcode 26.3).
+  HostTracingProfile(const HostTracingProfile &) = delete;
+  HostTracingProfile &operator=(const HostTracingProfile &) = delete;
+  HostTracingProfile(HostTracingProfile &&) = default;
+  HostTracingProfile &operator=(HostTracingProfile &&) = default;
+  ~HostTracingProfile() = default;
+
   // The ID of the OS-level process that this Trace Recording is associated
   // with.
-  ProcessId processId;
+  ProcessId processId{};
 
   // The timestamp at which this Trace Recording started.
   HighResTimeStamp startTime;

package/ReactCommon/jsinspector-modern/tracing/TraceRecordingState.h

@@ -31,6 +31,17 @@ struct TraceRecordingState {
   {
   }
 
+  // Explicitly move-only: RuntimeSamplingProfile is not copyable, so the
+  // implicit copy constructor is ill-formed the moment it is instantiated.
+  // Plain C++ never instantiates it, but Swift's C++ interop (ClangImporter)
+  // does when a consumer imports these headers as part of a module, turning
+  // it into a hard compile error (Xcode 26.3).
+  TraceRecordingState(const TraceRecordingState &) = delete;
+  TraceRecordingState &operator=(const TraceRecordingState &) = delete;
+  TraceRecordingState(TraceRecordingState &&) = default;
+  TraceRecordingState &operator=(TraceRecordingState &&) = default;
+  ~TraceRecordingState() = default;
+
   // The mode of this Trace Recording.
   tracing::Mode mode;
 

package/ReactCommon/react/bridging/ArrayBuffer.h

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <span>
+#include <string>
+
+#include <react/bridging/Base.h>
+
+namespace facebook::react {
+
+namespace detail {
+
+/**
+ * An owning implementation of jsi::MutableBuffer backed by a std::vector.
+ * Use this when the source of the bytes cannot be guaranteed to outlive the
+ * buffer (for example, returning data to JS from an asynchronous native call,
+ * or copying a JS ArrayBuffer argument before storing it).
+ */
+class OwnedBytesBuffer final : public jsi::MutableBuffer {
+ public:
+  explicit OwnedBytesBuffer(std::vector<uint8_t> bytes) noexcept : bytes_(std::move(bytes)) {}
+
+  size_t size() const override
+  {
+    return bytes_.size();
+  }
+
+  uint8_t *data() override
+  {
+    return bytes_.data();
+  }
+
+ private:
+  std::vector<uint8_t> bytes_;
+};
+
+} // namespace detail
+
+template <>
+struct Bridging<jsi::ArrayBuffer> {
+  static jsi::ArrayBuffer fromJs(jsi::Runtime &rt, const jsi::Object &obj)
+  {
+    if (!obj.isArrayBuffer(rt)) {
+      throw jsi::JSError(rt, "Expected ArrayBuffer");
+    }
+    return obj.getArrayBuffer(rt);
+  }
+
+  static jsi::Value toJs(jsi::Runtime &rt, jsi::ArrayBuffer buf)
+  {
+    return {rt, buf};
+  }
+};
+
+/* AsyncArrayBuffer holds ArrayBuffer bytes for use off the JS thread. Move-only.
+ *
+ * Always backed by a shared_ptr<jsi::MutableBuffer>: either one borrowed from
+ * a native-backed jsi::ArrayBuffer or an internal adapter wrapping owned
+ * bytes. May outlive the TurboModule call and be transferred across threads;
+ * concurrent reads and writes to the buffer contents (the bytes returned by
+ * data()) must be synchronized externally.
+ */
+class AsyncArrayBuffer {
+ public:
+  AsyncArrayBuffer(const AsyncArrayBuffer &) = delete;
+  AsyncArrayBuffer &operator=(const AsyncArrayBuffer &) = delete;
+  AsyncArrayBuffer(AsyncArrayBuffer &&) noexcept = default;
+  AsyncArrayBuffer &operator=(AsyncArrayBuffer &&) noexcept = default;
+  ~AsyncArrayBuffer() = default;
+
+  // Zero-copy if the input has a native MutableBuffer; copies otherwise.
+  static AsyncArrayBuffer acquire(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer)
+  {
+    throwIfDetached(rt, buffer, "AsyncArrayBuffer::acquire");
+    if (auto mutableBuf = buffer.tryGetMutableBuffer(rt)) {
+      return AsyncArrayBuffer{std::move(mutableBuf)};
+    }
+    return copyBytes(rt, buffer);
+  }
+
+  // Zero-copy. Throws if the input has no native MutableBuffer.
+  static AsyncArrayBuffer borrow(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer)
+  {
+    throwIfDetached(rt, buffer, "AsyncArrayBuffer::borrow");
+    auto mutableBuf = buffer.tryGetMutableBuffer(rt);
+    if (!mutableBuf) {
+      throw jsi::JSError(
+          rt,
+          "AsyncArrayBuffer::borrow: ArrayBuffer has no native MutableBuffer. "
+          "Use AsyncArrayBuffer::acquire(rt, buffer) when the buffer origin is unknown.");
+    }
+    return AsyncArrayBuffer{std::move(mutableBuf)};
+  }
+
+  // Always copies.
+  static AsyncArrayBuffer copy(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer)
+  {
+    throwIfDetached(rt, buffer, "AsyncArrayBuffer::copy");
+    return copyBytes(rt, buffer);
+  }
+
+  // Wraps an existing MutableBuffer. Safe to call from any thread.
+  static AsyncArrayBuffer wrap(std::shared_ptr<jsi::MutableBuffer> buffer) noexcept
+  {
+    return AsyncArrayBuffer{std::move(buffer)};
+  }
+
+  // Takes ownership of a byte vector. Safe to call from any thread.
+  static AsyncArrayBuffer wrap(std::vector<uint8_t> bytes)
+  {
+    return AsyncArrayBuffer{std::make_shared<detail::OwnedBytesBuffer>(std::move(bytes))};
+  }
+
+  uint8_t *data() noexcept
+  {
+    return buffer_->data();
+  }
+
+  const uint8_t *data() const noexcept
+  {
+    return buffer_->data();
+  }
+
+  size_t size() const noexcept
+  {
+    return buffer_->size();
+  }
+
+  // Returns the underlying MutableBuffer. Used by
+  // Bridging<AsyncArrayBuffer>::toJs to hand the buffer back to JS without a
+  // copy. Always non-null.
+  std::shared_ptr<jsi::MutableBuffer> getMutableBuffer() const noexcept
+  {
+    return buffer_;
+  }
+
+ private:
+  explicit AsyncArrayBuffer(std::shared_ptr<jsi::MutableBuffer> buffer) noexcept : buffer_{std::move(buffer)} {}
+
+  static AsyncArrayBuffer copyBytes(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer)
+  {
+    auto bytes = std::span(buffer.data(rt), buffer.size(rt));
+    return wrap(std::vector<uint8_t>(bytes.begin(), bytes.end()));
+  }
+
+  // Best-effort detached check. jsi::ArrayBuffer::detached relies on the JS-level
+  // `detached` property, which some runtimes (e.g. Hermes) don't implement and
+  // signal by throwing. In that case we silently skip the check rather than
+  // surfacing a confusing error from an unrelated method.
+  static void throwIfDetached(jsi::Runtime &rt, const jsi::ArrayBuffer &buffer, const char *callerName)
+  {
+    bool detached = false;
+    try {
+      detached = buffer.detached(rt);
+    } catch (const jsi::JSINativeException &) {
+      return;
+    }
+    if (detached) {
+      throw jsi::JSError(rt, std::string(callerName) + ": ArrayBuffer is detached");
+    }
+  }
+
+  std::shared_ptr<jsi::MutableBuffer> buffer_;
+};
+
+template <>
+struct Bridging<AsyncArrayBuffer> {
+  static jsi::Value toJs(jsi::Runtime &rt, AsyncArrayBuffer buffer)
+  {
+    return {rt, rt.createArrayBuffer(buffer.getMutableBuffer())};
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/react/bridging/Bridging.h

@@ -9,6 +9,7 @@
 
 #include <react/bridging/AString.h>
 #include <react/bridging/Array.h>
+#include <react/bridging/ArrayBuffer.h>
 #include <react/bridging/Bool.h>
 #include <react/bridging/Class.h>
 #include <react/bridging/Dynamic.h>

package/ReactCommon/react/bridging/Convert.h

@@ -63,6 +63,8 @@ struct ConverterBase {
         return std::move(value).getObject(rt_).getArray(rt_);
       } else if constexpr (std::is_same_v<BaseT, jsi::Function>) {
         return std::move(value).getObject(rt_).getFunction(rt_);
+      } else if constexpr (std::is_same_v<BaseT, jsi::ArrayBuffer>) {
+        return std::move(value).asObject(rt_).getArrayBuffer(rt_);
       }
     } else {
       return std::move(value_);
@@ -117,6 +119,11 @@ struct Converter<jsi::Value> : public ConverterBase<jsi::Value> {
   {
     return std::move(value_).asObject(rt_).asFunction(rt_);
   }
+
+  operator jsi::ArrayBuffer() &&
+  {
+    return std::move(value_).asObject(rt_).getArrayBuffer(rt_);
+  }
 };
 
 template <>
@@ -132,6 +139,11 @@ struct Converter<jsi::Object> : public ConverterBase<jsi::Object> {
   {
     return std::move(value_).asFunction(rt_);
   }
+
+  operator jsi::ArrayBuffer() &&
+  {
+    return std::move(value_).getArrayBuffer(rt_);
+  }
 };
 
 template <typename T>

package/ReactCommon/react/bridging/React-bridging.podspec

@@ -0,0 +1,44 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-bridging"
+  s.version                = version
+  s.summary                = "-"
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("*.{cpp,h}", "*.h")
+  s.header_dir             = "react/bridging"
+  s.pod_target_xcconfig    = {
+    "USE_HEADERMAP" => "YES",
+    "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+    "DEFINES_MODULE" => "YES"
+  }
+
+  resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_bridging")
+
+  s.dependency "React-jsi"
+  s.dependency "React-callinvoker"
+  s.dependency "React-timing"
+
+  add_rn_third_party_dependencies(s)
+  add_rncore_dependency(s)
+end

package/ReactCommon/react/bridging/tests/BridgingTest.cpp

@@ -5,6 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+#include <span>
+#include <utility>
+
 #include "BridgingTest.h"
 
 namespace facebook::react {
@@ -17,6 +20,7 @@ TEST_F(BridgingTest, jsiTest) {
   jsi::Value object = jsi::Object(rt);
   jsi::Value array = jsi::Array::createWithElements(rt, value, object);
   jsi::Value func = function("() => {}");
+  jsi::Value arrayBuffer = eval("new ArrayBuffer(0)");
 
   // The bridging mechanism needs to know how to copy and downcast values.
   EXPECT_NO_THROW(bridging::fromJs<jsi::Value>(rt, value, invoker));
@@ -24,6 +28,7 @@ TEST_F(BridgingTest, jsiTest) {
   EXPECT_NO_THROW(bridging::fromJs<jsi::Object>(rt, object, invoker));
   EXPECT_NO_THROW(bridging::fromJs<jsi::Array>(rt, array, invoker));
   EXPECT_NO_THROW(bridging::fromJs<jsi::Function>(rt, func, invoker));
+  EXPECT_NO_THROW(bridging::fromJs<jsi::ArrayBuffer>(rt, arrayBuffer, invoker));
 
   // Should throw when attempting an invalid cast.
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Object>(rt, value, invoker));
@@ -31,6 +36,7 @@ TEST_F(BridgingTest, jsiTest) {
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, object, invoker));
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, string, invoker));
   EXPECT_JSI_THROW(bridging::fromJs<jsi::Array>(rt, func, invoker));
+  EXPECT_JSI_THROW(bridging::fromJs<jsi::ArrayBuffer>(rt, value, invoker));
 
   // Should be able to generically no-op convert JSI.
   EXPECT_NO_THROW(bridging::toJs(rt, value, invoker));
@@ -69,11 +75,6 @@ TEST_F(BridgingTest, numberTest) {
       -42,
       static_cast<uint32_t>(
           bridging::toJs(rt, static_cast<uint32_t>(-42)).asNumber()));
-
-  EXPECT_FALSE(
-      -42 ==
-      static_cast<int32_t>(
-          bridging::toJs(rt, static_cast<uint32_t>(-42)).asNumber()));
 }
 
 TEST_F(BridgingTest, stringTest) {
@@ -200,9 +201,8 @@ TEST_F(BridgingTest, functionTest) {
   auto object = jsi::Object(rt);
   object.setProperty(rt, "foo", "bar");
 
-  auto lambda = [](std::map<std::string, std::string> map, std::string key) {
-    return map[key];
-  };
+  auto lambda = [](std::map<std::string, std::string> map,
+                   const std::string& key) { return map[key]; };
 
   auto func = bridging::toJs(rt, lambda, invoker);
 
@@ -285,7 +285,8 @@ TEST_F(BridgingTest, syncCallbackImplicitBridgingTest) {
 TEST_F(BridgingTest, asyncCallbackTest) {
   std::string output;
 
-  auto func = std::function<void(std::string)>([&](auto str) { output = str; });
+  auto func = std::function<void(std::string)>(
+      [&](auto str) { output = std::move(str); });
 
   auto cb = bridging::fromJs<AsyncCallback<decltype(func), std::string>>(
       rt, function("(func, str) => func(str)"), invoker);
@@ -309,7 +310,9 @@ TEST_F(BridgingTest, asyncCallbackTest) {
 
 TEST_F(BridgingTest, asyncCallbackInvalidation) {
   std::string output;
-  std::function<void(std::string)> func = [&](auto str) { output = str; };
+  std::function<void(std::string)> func = [&](auto str) {
+    output = std::move(str);
+  };
 
   auto jsCallback = bridging::fromJs<AsyncCallback<>>(
       rt, bridging::toJs(rt, func, invoker), invoker);
@@ -327,7 +330,8 @@ TEST_F(BridgingTest, asyncCallbackInvalidation) {
 
 TEST_F(BridgingTest, asyncCallbackImplicitBridgingTest) {
   std::string output;
-  auto func = std::function<void(std::string)>([&](auto str) { output = str; });
+  auto func = std::function<void(std::string)>(
+      [&](auto str) { output = std::move(str); });
   { // Value
     auto cb = bridging::fromJs<AsyncCallback<decltype(func), jsi::Value, int>>(
         rt, function("(func, a, b) => func(a + b)"), invoker);
@@ -780,6 +784,176 @@ TEST_F(BridgingTest, dynamicTest) {
   EXPECT_TRUE(undefinedFromJsResult.isNull());
 }
 
+TEST_F(BridgingTest, arrayBufferTest) {
+  auto rawBuf = eval("new ArrayBuffer(7)");
+  auto buf = bridging::fromJs<jsi::ArrayBuffer>(rt, rawBuf, invoker);
+  EXPECT_EQ(7, buf.size(rt));
+
+  auto typedArrayBuf = eval("new Uint8Array([1, 2, 3]).buffer");
+  auto fromTa = bridging::fromJs<jsi::ArrayBuffer>(rt, typedArrayBuf, invoker);
+  EXPECT_EQ(3, fromTa.size(rt));
+
+  auto jsVal = bridging::toJs(rt, std::move(buf), invoker);
+  EXPECT_TRUE(jsVal.isArrayBuffer(rt));
+  auto roundTrip = bridging::fromJs<jsi::ArrayBuffer>(rt, jsVal, invoker);
+  EXPECT_EQ(7, roundTrip.size(rt));
+
+  EXPECT_JSI_THROW(
+      bridging::fromJs<jsi::ArrayBuffer>(rt, jsi::Value(1), invoker));
+}
+
+TEST_F(BridgingTest, asyncArrayBufferConstructorTest) {
+  // JS-heap-allocated buffer: acquire() copies into an internal buffer.
+  {
+    auto jsBuf = eval("new Uint8Array([10, 20, 30]).buffer")
+                     .asObject(rt)
+                     .getArrayBuffer(rt);
+    auto safe = AsyncArrayBuffer::acquire(rt, jsBuf);
+    EXPECT_EQ(3, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(10, data[0]);
+    EXPECT_EQ(20, data[1]);
+    EXPECT_EQ(30, data[2]);
+  }
+
+  // ArrayBuffer created from a native MutableBuffer: acquire() returns the
+  // same bytes. Whether it's zero-copy depends on whether the runtime
+  // implements tryGetMutableBuffer (e.g. Hermes does not, so acquire falls
+  // back to a copy).
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{1, 2, 3, 4});
+    auto* rawPtr = nativeBuf.get();
+    auto jsBuf = jsi::ArrayBuffer(rt, nativeBuf);
+    auto safe = AsyncArrayBuffer::acquire(rt, jsBuf);
+    EXPECT_EQ(4, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(1, data[0]);
+    EXPECT_EQ(4, data[3]);
+    if (jsBuf.tryGetMutableBuffer(rt) != nullptr) {
+      EXPECT_EQ(rawPtr, safe.getMutableBuffer().get());
+    }
+  }
+}
+
+TEST_F(BridgingTest, asyncArrayBufferBorrowThrowsOnJsHeapTest) {
+  // JS-heap-allocated buffer: borrow throws.
+  auto jsBuf = eval("new ArrayBuffer(4)").asObject(rt).getArrayBuffer(rt);
+  EXPECT_JSI_THROW(AsyncArrayBuffer::borrow(rt, jsBuf));
+}
+
+TEST_F(BridgingTest, asyncArrayBufferBorrowNativeBackedTest) {
+  // Native-backed buffer: borrow succeeds zero-copy on runtimes that implement
+  // tryGetMutableBuffer; otherwise borrow throws (since there is no native
+  // MutableBuffer to hand back).
+  auto nativeBuf =
+      std::make_shared<detail::OwnedBytesBuffer>(std::vector<uint8_t>{5, 6, 7});
+  auto* rawPtr = nativeBuf.get();
+  auto jsBuf = jsi::ArrayBuffer(rt, nativeBuf);
+  if (jsBuf.tryGetMutableBuffer(rt) == nullptr) {
+    EXPECT_JSI_THROW(AsyncArrayBuffer::borrow(rt, jsBuf));
+    return;
+  }
+  auto safe = AsyncArrayBuffer::borrow(rt, jsBuf);
+  EXPECT_EQ(3, safe.size());
+  auto data = std::span(safe.data(), safe.size());
+  EXPECT_EQ(5, data[0]);
+  EXPECT_EQ(rawPtr, safe.getMutableBuffer().get());
+}
+
+TEST_F(BridgingTest, asyncArrayBufferCopyTest) {
+  // JS-heap-allocated buffer: copy succeeds.
+  {
+    auto jsBuf = eval("new Uint8Array([100, 200]).buffer")
+                     .asObject(rt)
+                     .getArrayBuffer(rt);
+    auto safe = AsyncArrayBuffer::copy(rt, jsBuf);
+    EXPECT_EQ(2, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(100, data[0]);
+    EXPECT_EQ(200, data[1]);
+  }
+
+  // Native-backed buffer: copy() still copies into an internal buffer.
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{9, 8, 7});
+    auto* rawPtr = nativeBuf.get();
+    auto jsBuf = jsi::ArrayBuffer(rt, nativeBuf);
+    auto safe = AsyncArrayBuffer::copy(rt, jsBuf);
+    EXPECT_EQ(3, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(9, data[0]);
+    EXPECT_NE(rawPtr, safe.getMutableBuffer().get());
+  }
+}
+
+TEST_F(BridgingTest, asyncArrayBufferMoveTest) {
+  auto jsBuf =
+      eval("new Uint8Array([1, 2, 3]).buffer").asObject(rt).getArrayBuffer(rt);
+  auto safe = AsyncArrayBuffer::acquire(rt, jsBuf);
+  EXPECT_EQ(3, safe.size());
+
+  auto moved = std::move(safe);
+  EXPECT_EQ(3, moved.size());
+  auto data = std::span(moved.data(), moved.size());
+  EXPECT_EQ(1, data[0]);
+}
+
+TEST_F(BridgingTest, asyncArrayBufferWrapTest) {
+  // wrap(shared_ptr<MutableBuffer>): zero-copy, same underlying buffer.
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{1, 2, 3});
+    auto* rawPtr = nativeBuf.get();
+    auto safe = AsyncArrayBuffer::wrap(nativeBuf);
+    EXPECT_EQ(3, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(1, data[0]);
+    EXPECT_EQ(3, data[2]);
+    EXPECT_EQ(rawPtr, safe.getMutableBuffer().get());
+  }
+
+  // wrap(vector<uint8_t>): bytes are owned by an internal MutableBuffer.
+  {
+    auto safe = AsyncArrayBuffer::wrap(std::vector<uint8_t>{10, 20, 30, 40});
+    EXPECT_EQ(4, safe.size());
+    auto data = std::span(safe.data(), safe.size());
+    EXPECT_EQ(10, data[0]);
+    EXPECT_EQ(40, data[3]);
+    EXPECT_NE(nullptr, safe.getMutableBuffer());
+  }
+}
+
+TEST_F(BridgingTest, asyncArrayBufferBridgingTest) {
+  // toJs with native-backed buffer: JS ArrayBuffer backed by the same
+  // MutableBuffer.
+  {
+    auto nativeBuf = std::make_shared<detail::OwnedBytesBuffer>(
+        std::vector<uint8_t>{5, 6, 7});
+    auto safe = AsyncArrayBuffer::wrap(nativeBuf);
+    auto jsVal = bridging::toJs(rt, std::move(safe), invoker);
+    EXPECT_TRUE(jsVal.asObject(rt).isArrayBuffer(rt));
+    auto jsBuf = jsVal.asObject(rt).getArrayBuffer(rt);
+    EXPECT_EQ(3, jsBuf.size(rt));
+    auto data = std::span(jsBuf.data(rt), jsBuf.size(rt));
+    EXPECT_EQ(5, data[0]);
+    EXPECT_EQ(7, data[2]);
+  }
+
+  // toJs with owned bytes: JS ArrayBuffer contains the correct data.
+  {
+    auto safe = AsyncArrayBuffer::wrap(std::vector<uint8_t>{100, 200});
+    auto jsVal = bridging::toJs(rt, std::move(safe), invoker);
+    EXPECT_TRUE(jsVal.asObject(rt).isArrayBuffer(rt));
+    auto jsBuf = jsVal.asObject(rt).getArrayBuffer(rt);
+    EXPECT_EQ(2, jsBuf.size(rt));
+    auto data = std::span(jsBuf.data(rt), jsBuf.size(rt));
+    EXPECT_EQ(100, data[0]);
+    EXPECT_EQ(200, data[1]);
+  }
+}
+
 TEST_F(BridgingTest, highResTimeStampTest) {
   HighResTimeStamp timestamp = HighResTimeStamp::now();
   EXPECT_EQ(

package/ReactCommon/react/bridging/tests/ClassTest.cpp

@@ -42,6 +42,14 @@ struct TestClass {
     callback();
   }
 
+  size_t byteLength(jsi::Runtime& rt, jsi::ArrayBuffer buffer) {
+    return buffer.size(rt);
+  }
+
+  jsi::ArrayBuffer echo(jsi::Runtime& /*unused*/, jsi::ArrayBuffer buffer) {
+    return buffer;
+  }
+
  private:
   std::shared_ptr<CallInvoker> invoker_;
 };
@@ -99,6 +107,20 @@ TEST_F(BridgingTest, callFromJsTest) {
   EXPECT_TRUE(called);
 }
 
+TEST_F(BridgingTest, arrayBufferCallFromJsTest) {
+  auto instance = TestClass(invoker);
+  auto buf = eval("new ArrayBuffer(5)").asObject(rt).getArrayBuffer(rt);
+  EXPECT_EQ(
+      5,
+      bridging::callFromJs<size_t>(
+          rt, &TestClass::byteLength, invoker, &instance, std::move(buf)));
+
+  auto buf2 = eval("new ArrayBuffer(9)").asObject(rt).getArrayBuffer(rt);
+  auto out = bridging::callFromJs<jsi::ArrayBuffer>(
+      rt, &TestClass::echo, invoker, &instance, std::move(buf2));
+  EXPECT_EQ(9, out.size(rt));
+}
+
 struct MethodReturnTypeCastingTestObject {
  public:
   explicit MethodReturnTypeCastingTestObject(int value) : value_(value) {}

package/ReactCommon/react/cxxstableapi/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+# Header-only: the cxxstableapi guards are pure preprocessor headers, so this is
+# an INTERFACE library. Headers resolve as <react/cxxstableapi/*.h> via the
+# shared ${REACT_COMMON_DIR} include root.
+add_library(react_cxxstableapi INTERFACE)
+
+target_include_directories(react_cxxstableapi INTERFACE ${REACT_COMMON_DIR})
+target_compile_reactnative_options(react_cxxstableapi INTERFACE)
+target_compile_options(react_cxxstableapi INTERFACE -Wpedantic)