@depup/react-native 0.86.2-depup.0 → 0.87.1-depup.0

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -21,8 +21,10 @@
 #include <folly/json.h>
 #include <jsinspector-modern/cdp/CdpJson.h>
 
+#include <algorithm>
 #include <chrono>
 #include <functional>
+#include <string>
 #include <string_view>
 
 using namespace std::chrono;
@@ -236,6 +238,53 @@ class HostAgent::Impl final {
         };
       }
     }
+    if (req.method == "Page.addScriptToEvaluateOnNewDocument") {
+      // @cdp Page.addScriptToEvaluateOnNewDocument registers a script that
+      // will be evaluated in every new JS runtime created for this Host
+      // (e.g. after a reload), BEFORE the app's main bundle runs. We store
+      // it as session state and let each new RuntimeAgent replay it onto its
+      // runtime, mirroring the handling of @cdp Runtime.addBinding. Per CDP
+      // semantics the script does NOT run in the runtime that is current
+      // when it is registered; the client must reload to apply it.
+      std::string source =
+          req.params.isObject() && (req.params.count("source") != 0u)
+          ? req.params.at("source").asString()
+          : std::string();
+      std::string identifier =
+          std::to_string(sessionState_.nextScriptToEvaluateOnNewDocumentId++);
+      sessionState_.scriptsToEvaluateOnNewDocument.push_back(
+          {.identifier = identifier, .source = std::move(source)});
+
+      frontendChannel_(
+          cdp::jsonResult(
+              req.id, folly::dynamic::object("identifier", identifier)));
+
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = false,
+      };
+    }
+    if (req.method == "Page.removeScriptToEvaluateOnNewDocument") {
+      std::string identifier =
+          req.params.isObject() && (req.params.count("identifier") != 0u)
+          ? req.params.at("identifier").asString()
+          : std::string();
+      auto& scripts = sessionState_.scriptsToEvaluateOnNewDocument;
+      scripts.erase(
+          std::remove_if(
+              scripts.begin(),
+              scripts.end(),
+              [&identifier](
+                  const SessionState::ScriptToEvaluateOnNewDocument& script) {
+                return script.identifier == identifier;
+              }),
+          scripts.end());
+
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = true,
+      };
+    }
     if (req.method == "Overlay.setPausedInDebuggerMessage") {
       auto message =
           req.params.isObject() && (req.params.count("message") != 0u)
@@ -397,6 +446,11 @@ class HostAgent::Impl final {
       return;
     }
 
+    if (requestState.isFinishedHandlingRequest) {
+      // The handler already sent its own response via frontendChannel_.
+      return;
+    }
+
     throw NotImplementedException(req.method);
   }
 

package/ReactCommon/jsinspector-modern/HostTarget.h

@@ -252,13 +252,6 @@ class HostTargetController final {
 
   bool hasInstance() const;
 
-  /**
-   * [Experimental] Install a runtime binding subscribing to new Performance
-   * Issues, which we broadcast to the V2 Perf Monitor overlay via
-   * \ref HostTargetDelegate::unstable_onPerfIssueAdded.
-   */
-  void installPerfIssuesBinding();
-
   /**
    * Increments the target's pause overlay counter. The counter represents the
    * exact number of Agents that have (concurrently) requested the pause

package/ReactCommon/jsinspector-modern/HostTargetTraceRecording.cpp

@@ -64,13 +64,16 @@ tracing::HostTracingProfile HostTargetTraceRecording::stop() {
   auto startTime = *startTime_;
   startTime_.reset();
 
-  return tracing::HostTracingProfile{
-      .processId = oscompat::getCurrentProcessId(),
-      .startTime = startTime,
-      .frameTimings = frameTimings_.pruneExpiredAndExtract(),
-      .instanceTracingProfiles = std::move(state.instanceTracingProfiles),
-      .runtimeSamplingProfiles = std::move(state.runtimeSamplingProfiles),
-  };
+  // Member-wise assignment instead of designated initializers:
+  // HostTracingProfile declares its special members (move-only) and is no
+  // longer an aggregate.
+  tracing::HostTracingProfile profile;
+  profile.processId = oscompat::getCurrentProcessId();
+  profile.startTime = startTime;
+  profile.frameTimings = frameTimings_.pruneExpiredAndExtract();
+  profile.instanceTracingProfiles = std::move(state.instanceTracingProfiles);
+  profile.runtimeSamplingProfiles = std::move(state.runtimeSamplingProfiles);
+  return profile;
 }
 
 void HostTargetTraceRecording::recordFrameTimings(

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.cpp

@@ -341,9 +341,12 @@ void InspectorPackagerConnection::Impl::connect() {
     webSocket_ = delegate_->connectWebSocket(url_, weak_from_this());
   } catch (const std::exception& e) {
     LOG(ERROR) << "Failed to create WebSocket connection: " << e.what();
-    reconnect();
+    webSocket_.reset();
   } catch (...) {
     LOG(ERROR) << "Failed to create WebSocket connection: unknown error";
+    webSocket_.reset();
+  }
+  if (!webSocket_ && !closed_) {
     reconnect();
   }
 }

package/ReactCommon/jsinspector-modern/React-jsinspector.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

package/ReactCommon/jsinspector-modern/RuntimeAgent.cpp

@@ -33,6 +33,13 @@ RuntimeAgent::RuntimeAgent(
     }
   }
 
+  // Replay any scripts registered via @cdp
+  // Page.addScriptToEvaluateOnNewDocument onto this newly created runtime, in
+  // registration order, so they evaluate before the app's main bundle.
+  for (const auto& script : sessionState_.scriptsToEvaluateOnNewDocument) {
+    targetController_.installScriptToEvaluateOnNewDocument(script.source);
+  }
+
   if (sessionState_.isRuntimeDomainEnabled) {
     targetController_.notifyDomainStateChanged(
         RuntimeTargetController::Domain::Runtime, true, *this);

package/ReactCommon/jsinspector-modern/RuntimeTarget.cpp

@@ -130,6 +130,21 @@ void RuntimeTarget::installBindingHandler(const std::string& bindingName) {
   });
 }
 
+void RuntimeTarget::installScriptToEvaluateOnNewDocument(
+    const std::string& source) {
+  jsExecutor_([source](jsi::Runtime& runtime) {
+    try {
+      runtime.evaluateJavaScript(
+          std::make_shared<jsi::StringBuffer>(source),
+          "<addScriptToEvaluateOnNewDocument>");
+    } catch (jsi::JSIException&) {
+      // Swallow exceptions thrown while evaluating the injected script so a
+      // faulty script cannot break the app. This mirrors how
+      // installBindingHandler isolates binding-setup failures.
+    }
+  });
+}
+
 void RuntimeTarget::installFastRefreshHandler() {
   jsExecutor_([selfExecutor = executorFromThis()](jsi::Runtime& runtime) {
     auto globalObj = runtime.global();
@@ -313,6 +328,11 @@ void RuntimeTargetController::installBindingHandler(
   target_.installBindingHandler(bindingName);
 }
 
+void RuntimeTargetController::installScriptToEvaluateOnNewDocument(
+    const std::string& source) {
+  target_.installScriptToEvaluateOnNewDocument(source);
+}
+
 void RuntimeTargetController::enableSamplingProfiler() {
   target_.enableSamplingProfiler();
 }

package/ReactCommon/jsinspector-modern/RuntimeTarget.h

@@ -129,6 +129,14 @@ class RuntimeTargetController {
    */
   void installBindingHandler(const std::string &bindingName);
 
+  /**
+   * Evaluates the given JavaScript source on the runtime's thread before any
+   * user code runs. Used to replay @cdp
+   * Page.addScriptToEvaluateOnNewDocument scripts onto a freshly created
+   * runtime.
+   */
+  void installScriptToEvaluateOnNewDocument(const std::string &source);
+
   /**
    * Notifies the target that an agent has received an enable or disable
    * message for the given domain.
@@ -289,6 +297,14 @@ class JSINSPECTOR_EXPORT RuntimeTarget : public EnableExecutorFromThis<RuntimeTa
    */
   void installBindingHandler(const std::string &bindingName);
 
+  /**
+   * Evaluates the given JavaScript source on the runtime's thread before any
+   * user code runs. Used to replay @cdp
+   * Page.addScriptToEvaluateOnNewDocument scripts onto a freshly created
+   * runtime.
+   */
+  void installScriptToEvaluateOnNewDocument(const std::string &source);
+
   /**
    * Installs any global values we want to expose to framework/user JavaScript
    * code.

package/ReactCommon/jsinspector-modern/SessionState.h

@@ -14,6 +14,7 @@
 #include <string_view>
 #include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 namespace facebook::react::jsinspector_modern {
 
@@ -43,6 +44,36 @@ struct SessionState {
    */
   std::unordered_map<std::string, ExecutionContextSelectorSet> subscribedBindings;
 
+  /**
+   * A single script registered during this session using @cdp
+   * Page.addScriptToEvaluateOnNewDocument.
+   */
+  struct ScriptToEvaluateOnNewDocument {
+    /** Opaque identifier returned to the frontend, used by @cdp
+     * Page.removeScriptToEvaluateOnNewDocument. */
+    std::string identifier;
+    /** The JavaScript source to evaluate. */
+    std::string source;
+  };
+
+  /**
+   * Scripts registered during this session using @cdp
+   * Page.addScriptToEvaluateOnNewDocument, in registration order.
+   *
+   * Like subscribedBindings, these are treated as session state: each new
+   * RuntimeAgent replays them onto its runtime so they evaluate before any
+   * user code (i.e. before the app's main bundle). Per CDP semantics they do
+   * NOT run in the runtime that is current when they are registered - the
+   * client must trigger a reload (@cdp Page.reload) for them to take effect.
+   */
+  std::vector<ScriptToEvaluateOnNewDocument> scriptsToEvaluateOnNewDocument;
+
+  /**
+   * Monotonic counter for generating the identifiers returned from @cdp
+   * Page.addScriptToEvaluateOnNewDocument.
+   */
+  unsigned int nextScriptToEvaluateOnNewDocumentId{1};
+
   /**
    * Messages logged through the HostAgent::sendConsoleMessage and
    * InstanceAgent::sendConsoleMessage utilities that have not yet been sent to

package/ReactCommon/jsinspector-modern/cdp/React-jsinspectorcdp.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

package/ReactCommon/jsinspector-modern/network/React-jsinspectornetwork.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

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/React-jsinspectortracing.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

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/jsitooling/React-jsitooling.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

package/ReactCommon/logger/React-logger.podspec

@@ -9,7 +9,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

package/ReactCommon/oscompat/React-oscompat.podspec

@@ -8,7 +8,7 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
 version = package['version']
 
-source = { :git => 'https://github.com/react/react-native.git' }
+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")

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>