react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.cpp

@@ -72,29 +72,78 @@ void InspectorPackagerConnection::Impl::handleProxyMessage(
 
 void InspectorPackagerConnection::Impl::sendEventToAllConnections(
     const std::string& event) {
-  for (auto& connection : inspectorSessions_) {
-    connection.second.localConnection->sendMessage(event);
+  for (auto& pageEntry : inspectorSessionsByPage_) {
+    for (auto& sessionEntry : pageEntry.second) {
+      sessionEntry.second.localConnection->sendMessage(event);
+    }
   }
 }
 
 void InspectorPackagerConnection::Impl::closeAllConnections() {
-  for (auto& connection : inspectorSessions_) {
-    connection.second.localConnection->disconnect();
+  while (!inspectorSessionsByPage_.empty()) {
+    auto pageIt = inspectorSessionsByPage_.begin();
+    while (pageIt != inspectorSessionsByPage_.end() &&
+           !pageIt->second.empty()) {
+      pageIt = disconnectSession({
+          pageIt,
+          pageIt->second.begin(),
+      });
+    }
   }
-  inspectorSessions_.clear();
+}
+
+std::optional<std::pair<
+    InspectorPackagerConnection::Impl::InspectorSessionsByPage::iterator,
+    InspectorPackagerConnection::Impl::PageSessions::iterator>>
+InspectorPackagerConnection::Impl::findPageAndSession(
+    const folly::const_dynamic_view& payload,
+    std::string_view caller) {
+  std::string pageId = payload.descend("pageId").string_or(INVALID);
+  auto proxySessionId = payload.descend("sessionId").string_or("");
+
+  auto pageIt = inspectorSessionsByPage_.find(pageId);
+  if (pageIt == inspectorSessionsByPage_.end()) {
+    LOG(WARNING) << caller << ": page not found (pageId=" << pageId << ")";
+    return std::nullopt;
+  }
+
+  auto& pageSessions = pageIt->second;
+  auto sessionIt = pageSessions.find(proxySessionId);
+  if (sessionIt == pageSessions.end()) {
+    LOG(WARNING) << caller << ": session not found (pageId=" << pageId
+                 << ", sessionId=" << proxySessionId << ")";
+    return std::nullopt;
+  }
+
+  return std::make_pair(pageIt, sessionIt);
 }
 
 void InspectorPackagerConnection::Impl::handleConnect(
     const folly::const_dynamic_view& payload) {
   std::string pageId = payload.descend("pageId").string_or(INVALID);
-  auto existingConnectionIt = inspectorSessions_.find(pageId);
-  if (existingConnectionIt != inspectorSessions_.end()) {
-    auto existingConnection = std::move(existingConnectionIt->second);
-    inspectorSessions_.erase(existingConnectionIt);
-    existingConnection.localConnection->disconnect();
-    LOG(WARNING) << "Already connected: " << pageId;
+  auto proxySessionId = payload.descend("sessionId").string_or("");
+
+  // An empty or missing proxySessionId switches us to legacy single-session
+  // mode.
+  if (proxySessionId.empty()) {
+    disconnectNonLegacySessions(pageId);
+  }
+
+  auto pageIt = inspectorSessionsByPage_.try_emplace(pageId).first;
+
+  auto sessionIt = pageIt->second.find(proxySessionId);
+  if (sessionIt != pageIt->second.end()) {
+    LOG(WARNING) << "Duplicate session, disconnecting (pageId=" << pageId
+                 << ", sessionId=" << proxySessionId << ")";
+    disconnectSession({pageIt, sessionIt});
+    // NOTE: At least as far back as D52134592, receiving a second
+    // `connect` message for the same page (and more specifically
+    // since D90174642, for the same proxySessionId) has been handled by
+    // disconnecting the previous session and returning *without* creating a new
+    // one. This seems like a bug and requires more investigation.
     return;
   }
+
   int pageIdInt = 0;
   try {
     pageIdInt = std::stoi(pageId);
@@ -105,60 +154,102 @@ void InspectorPackagerConnection::Impl::handleConnect(
   auto sessionId = nextSessionId_++;
   auto remoteConnection =
       std::make_unique<InspectorPackagerConnection::Impl::RemoteConnection>(
-          weak_from_this(), pageId, sessionId);
+          weak_from_this(), pageId, sessionId, proxySessionId);
   auto& inspector = getInspectorInstance();
   auto inspectorConnection =
       inspector.connect(pageIdInt, std::move(remoteConnection));
   if (!inspectorConnection) {
     LOG(INFO) << "Connection to page " << pageId << " rejected";
 
-    // RemoteConnection::onDisconnect(), if the connection even calls it,  will
-    // be a no op (because the session is not added to `inspectorSessions_`), so
-    // let's always notify the remote client of the disconnection ourselves.
+    // RemoteConnection::onDisconnect(), if the connection even calls it, will
+    // be a no op (because the session is not added to
+    // `inspectorSessionsByPage_`), so let's always notify the remote client
+    // of the disconnection ourselves.
+    folly::dynamic disconnectPayload =
+        folly::dynamic::object("pageId", pageId)("sessionId", proxySessionId);
     sendToPackager(
         folly::dynamic::object("event", "disconnect")(
-            "payload", folly::dynamic::object("pageId", pageId)));
+            "payload", std::move(disconnectPayload)));
     return;
   }
-  inspectorSessions_.emplace(
-      pageId,
+  pageIt->second.emplace(
+      proxySessionId,
       Session{
           .localConnection = std::move(inspectorConnection),
-          .sessionId = sessionId});
+          .sessionId = sessionId,
+          .proxySessionId = proxySessionId});
 }
 
 void InspectorPackagerConnection::Impl::handleDisconnect(
     const folly::const_dynamic_view& payload) {
-  std::string pageId = payload.descend("pageId").string_or(INVALID);
-  auto inspectorConnection = removeConnectionForPage(pageId);
-  if (inspectorConnection) {
-    inspectorConnection->disconnect();
+  if (auto sessionIterators = findPageAndSession(payload, "disconnect")) {
+    disconnectSession(*sessionIterators);
   }
 }
 
-std::unique_ptr<ILocalConnection>
-InspectorPackagerConnection::Impl::removeConnectionForPage(
+InspectorPackagerConnection::Impl::InspectorSessionsByPage::iterator
+InspectorPackagerConnection::Impl::disconnectSession(
+    std::pair<InspectorSessionsByPage::iterator, PageSessions::iterator>
+        sessionIterators) {
+  auto [pageIt, sessionIt] = sessionIterators;
+  auto& pageSessions = pageIt->second;
+  auto connection = std::move(sessionIt->second.localConnection);
+  pageSessions.erase(sessionIt);
+
+  // Clean up empty page entry
+  if (pageSessions.empty()) {
+    inspectorSessionsByPage_.erase(pageIt);
+    pageIt = inspectorSessionsByPage_.end();
+  }
+
+  if (connection) {
+    connection->disconnect();
+  }
+
+  return pageIt;
+}
+
+void InspectorPackagerConnection::Impl::disconnectNonLegacySessions(
     const std::string& pageId) {
-  auto it = inspectorSessions_.find(pageId);
-  if (it != inspectorSessions_.end()) {
-    auto connection = std::move(it->second);
-    inspectorSessions_.erase(it);
-    return std::move(connection.localConnection);
+  auto pageIt = inspectorSessionsByPage_.find(pageId);
+  if (pageIt == inspectorSessionsByPage_.end() || pageIt->second.empty()) {
+    return;
+  }
+
+  bool logged = false;
+  while (pageIt != inspectorSessionsByPage_.end()) {
+    // Find first non-legacy session (non-empty proxySessionId)
+    auto sessionIt = std::find_if(
+        pageIt->second.begin(), pageIt->second.end(), [](const auto& entry) {
+          return !entry.first.empty();
+        });
+
+    if (sessionIt == pageIt->second.end()) {
+      break;
+    }
+
+    if (!logged) {
+      LOG(WARNING)
+          << "Switching to legacy single-session mode, disconnecting non-legacy "
+             "sessions (pageId="
+          << pageId << ")";
+      logged = true;
+    }
+
+    pageIt = disconnectSession({pageIt, sessionIt});
   }
-  return nullptr;
 }
 
 void InspectorPackagerConnection::Impl::handleWrappedEvent(
     const folly::const_dynamic_view& payload) {
-  std::string pageId = payload.descend("pageId").string_or(INVALID);
   std::string wrappedEvent = payload.descend("wrappedEvent").string_or(INVALID);
-  auto connectionIt = inspectorSessions_.find(pageId);
-  if (connectionIt == inspectorSessions_.end()) {
-    LOG(WARNING) << "Not connected to page: " << pageId
-                 << " , failed trying to handle event: " << wrappedEvent;
+
+  auto maybeSession = findPageAndSession(payload, "wrappedEvent");
+  if (!maybeSession) {
     return;
   }
-  connectionIt->second.localConnection->sendMessage(wrappedEvent);
+  auto [pageIt, sessionIt] = *maybeSession;
+  sessionIt->second.localConnection->sendMessage(wrappedEvent);
 }
 
 folly::dynamic InspectorPackagerConnection::Impl::pages() {
@@ -172,8 +263,12 @@ folly::dynamic InspectorPackagerConnection::Impl::pages() {
     pageDescription["title"] = appName_ + " (" + deviceName_ + ")";
     pageDescription["description"] = page.description + " [C++ connection]";
     pageDescription["app"] = appName_;
-    pageDescription["capabilities"] =
+
+    folly::dynamic capabilities =
         targetCapabilitiesToDynamic(page.capabilities);
+    // Report device-level multi-debugger support capability
+    capabilities["supportsMultipleDebuggers"] = true;
+    pageDescription["capabilities"] = std::move(capabilities);
 
     array.push_back(pageDescription);
   }
@@ -218,9 +313,13 @@ void InspectorPackagerConnection::Impl::didClose() {
 }
 
 void InspectorPackagerConnection::Impl::onPageRemoved(int pageId) {
-  auto connection = removeConnectionForPage(std::to_string(pageId));
-  if (connection) {
-    connection->disconnect();
+  auto pageIt = inspectorSessionsByPage_.find(std::to_string(pageId));
+
+  while (pageIt != inspectorSessionsByPage_.end() && !pageIt->second.empty()) {
+    pageIt = disconnectSession({
+        pageIt,
+        pageIt->second.begin(),
+    });
   }
 }
 
@@ -291,18 +390,24 @@ void InspectorPackagerConnection::Impl::sendToPackager(
 void InspectorPackagerConnection::Impl::scheduleSendToPackager(
     folly::dynamic message,
     SessionId sourceSessionId,
-    const std::string& sourcePageId) {
+    const std::string& sourcePageId,
+    const std::string& sourceProxySessionId) {
   delegate_->scheduleCallback(
       [weakSelf = weak_from_this(),
        message = std::move(message),
        sourceSessionId,
-       sourcePageId]() mutable {
+       sourcePageId,
+       sourceProxySessionId]() mutable {
         auto strongSelf = weakSelf.lock();
         if (!strongSelf) {
           return;
         }
-        auto sessionIt = strongSelf->inspectorSessions_.find(sourcePageId);
-        if (sessionIt != strongSelf->inspectorSessions_.end() &&
+        auto pageIt = strongSelf->inspectorSessionsByPage_.find(sourcePageId);
+        if (pageIt == strongSelf->inspectorSessionsByPage_.end()) {
+          return;
+        }
+        auto sessionIt = pageIt->second.find(sourceProxySessionId);
+        if (sessionIt != pageIt->second.end() &&
             sessionIt->second.sessionId == sourceSessionId) {
           strongSelf->sendToPackager(std::move(message));
         }
@@ -333,10 +438,12 @@ void InspectorPackagerConnection::Impl::disposeWebSocket() {
 InspectorPackagerConnection::Impl::RemoteConnection::RemoteConnection(
     std::weak_ptr<InspectorPackagerConnection::Impl> owningPackagerConnection,
     std::string pageId,
-    SessionId sessionId)
+    SessionId sessionId,
+    std::string proxySessionId)
     : owningPackagerConnection_(std::move(owningPackagerConnection)),
       pageId_(std::move(pageId)),
-      sessionId_(sessionId) {}
+      sessionId_(sessionId),
+      proxySessionId_(std::move(proxySessionId)) {}
 
 void InspectorPackagerConnection::Impl::RemoteConnection::onMessage(
     std::string message) {
@@ -344,22 +451,25 @@ void InspectorPackagerConnection::Impl::RemoteConnection::onMessage(
   if (!owningPackagerConnectionStrong) {
     return;
   }
+  folly::dynamic payload = folly::dynamic::object("pageId", pageId_)(
+      "wrappedEvent", message)("sessionId", proxySessionId_);
   owningPackagerConnectionStrong->scheduleSendToPackager(
-      folly::dynamic::object("event", "wrappedEvent")(
-          "payload",
-          folly::dynamic::object("pageId", pageId_)("wrappedEvent", message)),
+      folly::dynamic::object("event", "wrappedEvent")("payload", payload),
       sessionId_,
-      pageId_);
+      pageId_,
+      proxySessionId_);
 }
 
 void InspectorPackagerConnection::Impl::RemoteConnection::onDisconnect() {
   auto owningPackagerConnectionStrong = owningPackagerConnection_.lock();
   if (owningPackagerConnectionStrong) {
+    folly::dynamic payload =
+        folly::dynamic::object("pageId", pageId_)("sessionId", proxySessionId_);
     owningPackagerConnectionStrong->scheduleSendToPackager(
-        folly::dynamic::object("event", "disconnect")(
-            "payload", folly::dynamic::object("pageId", pageId_)),
+        folly::dynamic::object("event", "disconnect")("payload", payload),
         sessionId_,
-        pageId_);
+        pageId_,
+        proxySessionId_);
   }
 }
 

package/ReactCommon/jsinspector-modern/InspectorPackagerConnectionImpl.h

@@ -39,7 +39,6 @@ class InspectorPackagerConnection::Impl : public IWebSocketDelegate,
   void connect();
   void closeQuietly();
   void sendEventToAllConnections(const std::string &event);
-  std::unique_ptr<ILocalConnection> removeConnectionForPage(const std::string &pageId);
 
   /**
    * Send a message to the packager as soon as possible. This method is safe
@@ -47,14 +46,21 @@ class InspectorPackagerConnection::Impl : public IWebSocketDelegate,
    * is sent, in which case the message will be dropped. The message is also
    * dropped if the session is no longer valid.
    */
-  void scheduleSendToPackager(folly::dynamic message, SessionId sourceSessionId, const std::string &sourcePageId);
+  void scheduleSendToPackager(
+      folly::dynamic message,
+      SessionId sourceSessionId,
+      const std::string &sourcePageId,
+      const std::string &sourceProxySessionId);
 
  private:
   struct Session {
     std::unique_ptr<ILocalConnection> localConnection;
     SessionId sessionId;
+    std::string proxySessionId; // Session ID assigned by the proxy
   };
   class RemoteConnection;
+  using PageSessions = std::unordered_map<std::string /* proxySessionId */, Session>;
+  using InspectorSessionsByPage = std::unordered_map<std::string /* pageId */, PageSessions>;
 
   Impl(
       std::string url,
@@ -68,6 +74,31 @@ class InspectorPackagerConnection::Impl : public IWebSocketDelegate,
   void handleConnect(const folly::const_dynamic_view &payload);
   void handleWrappedEvent(const folly::const_dynamic_view &payload);
   void handleProxyMessage(const folly::const_dynamic_view &message);
+
+  /**
+   * Finds the page and session and referenced by the given message payload.
+   * Returns a pair of valid (dereferenceable) iterators if found, or nullopt otherwise.
+   * Supports both legacy single-session mode (proxySessionId == missing or empty) and multi-session mode
+   * (proxySessionId == some unique identifier assigned by the proxy).
+   */
+  std::optional<std::pair<InspectorSessionsByPage::iterator, PageSessions::iterator>> findPageAndSession(
+      const folly::const_dynamic_view &payload,
+      std::string_view caller);
+
+  /**
+   * Given a pair of (dereferenceable) iterators as returned by findPageAndSession, disconnects the
+   * given session. Invalidates the session iterator and may invalidate the page iterator. Returns
+   * the page iterator if still valid, or the corresponding end() iterator otherwise - this is
+   * useful when disconnecting multiple sessions in a loop.
+   */
+  InspectorSessionsByPage::iterator disconnectSession(
+      std::pair<InspectorSessionsByPage::iterator, PageSessions::iterator> sessionIterators);
+
+  /**
+   * Switch to legacy single-session mode.
+   */
+  void disconnectNonLegacySessions(const std::string &pageId);
+
   folly::dynamic pages();
   void reconnect();
   void closeAllConnections();
@@ -90,7 +121,9 @@ class InspectorPackagerConnection::Impl : public IWebSocketDelegate,
   const std::string appName_;
   const std::unique_ptr<InspectorPackagerConnectionDelegate> delegate_;
 
-  std::unordered_map<std::string, Session> inspectorSessions_;
+  // Nested map: pageId → (proxySessionId → Session)
+  // Supports multiple concurrent debugger sessions per page
+  InspectorSessionsByPage inspectorSessionsByPage_;
   std::unique_ptr<IWebSocket> webSocket_;
   bool connected_{false};
   bool closed_{false};
@@ -107,7 +140,8 @@ class InspectorPackagerConnection::Impl::RemoteConnection : public IRemoteConnec
   RemoteConnection(
       std::weak_ptr<InspectorPackagerConnection::Impl> owningPackagerConnection,
       std::string pageId,
-      SessionId sessionId);
+      SessionId sessionId,
+      std::string proxySessionId);
 
   // IRemoteConnection methods
   void onMessage(std::string message) override;
@@ -117,6 +151,7 @@ class InspectorPackagerConnection::Impl::RemoteConnection : public IRemoteConnec
   const std::weak_ptr<InspectorPackagerConnection::Impl> owningPackagerConnection_;
   const std::string pageId_;
   const SessionId sessionId_;
+  const std::string proxySessionId_;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/NetworkIOAgent.cpp

@@ -259,6 +259,13 @@ class Stream : public NetworkRequestListener,
 };
 } // namespace
 
+NetworkIOAgent::~NetworkIOAgent() {
+  if (networkAgentId_) {
+    NetworkHandler::getInstance().disableAgent(*networkAgentId_);
+    networkAgentId_ = std::nullopt;
+  }
+}
+
 bool NetworkIOAgent::handleRequest(
     const cdp::PreparsedRequest& req,
     LoadNetworkResourceDelegate& delegate) {
@@ -278,15 +285,17 @@ bool NetworkIOAgent::handleRequest(
 
     // @cdp Network.enable support is experimental.
     if (req.method == "Network.enable") {
-      networkHandler.setFrontendChannel(frontendChannel_);
-      networkHandler.enable();
+      networkAgentId_ = networkHandler.enableAgent(frontendChannel_);
       // NOTE: Domain enable/disable responses are sent by HostAgent.
       return false;
     }
 
     // @cdp Network.disable support is experimental.
     if (req.method == "Network.disable") {
-      networkHandler.disable();
+      if (networkAgentId_) {
+        networkHandler.disableAgent(*networkAgentId_);
+        networkAgentId_ = std::nullopt;
+      }
       // NOTE: Domain enable/disable responses are sent by HostAgent.
       return false;
     }

package/ReactCommon/jsinspector-modern/NetworkIOAgent.h

@@ -211,6 +211,13 @@ class NetworkIOAgent {
   {
   }
 
+  ~NetworkIOAgent();
+
+  NetworkIOAgent(const NetworkIOAgent &) = delete;
+  NetworkIOAgent &operator=(const NetworkIOAgent &) = delete;
+  NetworkIOAgent(NetworkIOAgent &&) = delete;
+  NetworkIOAgent &operator=(NetworkIOAgent &&) = delete;
+
   /**
    * Handle a CDP request. The response will be sent over the provided
    * \c FrontendChannel synchronously or asynchronously.
@@ -247,6 +254,12 @@ class NetworkIOAgent {
    */
   unsigned long nextStreamId_{0};
 
+  /**
+   * If non-nullopt, indicates that this agent has enabled the Network domain
+   * via NetworkHandler, storing the agent ID for cleanup.
+   */
+  std::optional<size_t> networkAgentId_;
+
   /**
    * Begin loading an HTTP resource, delegating platform-specific
    * implementation, responding to the frontend on headers received or on error.

package/ReactCommon/jsinspector-modern/RuntimeAgent.cpp

@@ -155,9 +155,15 @@ RuntimeTracingAgent::RuntimeTracingAgent(
   if (state.enabledCategories.contains(tracing::Category::JavaScriptSampling)) {
     targetController_.enableSamplingProfiler();
   }
+  if (state.mode == tracing::Mode::CDP) {
+    targetController_.emitTracingStateChange(true);
+  }
 }
 
 RuntimeTracingAgent::~RuntimeTracingAgent() {
+  if (state_.mode == tracing::Mode::CDP) {
+    targetController_.emitTracingStateChange(false);
+  }
   if (state_.enabledCategories.contains(
           tracing::Category::JavaScriptSampling)) {
     targetController_.disableSamplingProfiler();

package/ReactCommon/jsinspector-modern/RuntimeTarget.cpp

@@ -8,7 +8,8 @@
 #include "SessionState.h"
 
 #include <jsinspector-modern/RuntimeTarget.h>
-#include <jsinspector-modern/tracing/PerformanceTracer.h>
+#include <jsinspector-modern/RuntimeTargetGlobalStateObserver.h>
+#include <jsinspector-modern/RuntimeTargetTracingStateObserver.h>
 
 #include <utility>
 
@@ -16,21 +17,6 @@ using namespace facebook::jsi;
 
 namespace facebook::react::jsinspector_modern {
 
-namespace {
-
-void emitSessionStatusChangeForObserverWithValue(
-    jsi::Runtime& runtime,
-    const jsi::Value& value) {
-  auto globalObj = runtime.global();
-  auto observer =
-      globalObj.getPropertyAsObject(runtime, "__DEBUGGER_SESSION_OBSERVER__");
-  auto onSessionStatusChange =
-      observer.getPropertyAsFunction(runtime, "onSessionStatusChange");
-  onSessionStatusChange.call(runtime, value);
-}
-
-} // namespace
-
 std::shared_ptr<RuntimeTarget> RuntimeTarget::create(
     const ExecutionContextDescription& executionContextDescription,
     RuntimeTargetDelegate& delegate,
@@ -57,6 +43,7 @@ void RuntimeTarget::installGlobals() {
   // NOTE: RuntimeTarget::installDebuggerSessionObserver is in
   // RuntimeTargetDebuggerSessionObserver.cpp
   installDebuggerSessionObserver();
+  installTracingStateObserver();
   // NOTE: RuntimeTarget::installNetworkReporterAPI is in
   // RuntimeTargetNetwork.cpp
   installNetworkReporterAPI();
@@ -144,7 +131,11 @@ void RuntimeTarget::installBindingHandler(const std::string& bindingName) {
 void RuntimeTarget::emitDebuggerSessionCreated() {
   jsExecutor_([selfExecutor = executorFromThis()](jsi::Runtime& runtime) {
     try {
-      emitSessionStatusChangeForObserverWithValue(runtime, jsi::Value(true));
+      emitGlobalStateObserverChange(
+          runtime,
+          "__DEBUGGER_SESSION_OBSERVER__",
+          "onSessionStatusChange",
+          true);
     } catch (jsi::JSError&) {
       // Suppress any errors, they should not be visible to the user
       // and should not affect runtime.
@@ -155,7 +146,28 @@ void RuntimeTarget::emitDebuggerSessionCreated() {
 void RuntimeTarget::emitDebuggerSessionDestroyed() {
   jsExecutor_([selfExecutor = executorFromThis()](jsi::Runtime& runtime) {
     try {
-      emitSessionStatusChangeForObserverWithValue(runtime, jsi::Value(false));
+      emitGlobalStateObserverChange(
+          runtime,
+          "__DEBUGGER_SESSION_OBSERVER__",
+          "onSessionStatusChange",
+          false);
+    } catch (jsi::JSError&) {
+      // Suppress any errors, they should not be visible to the user
+      // and should not affect runtime.
+    }
+  });
+}
+
+void RuntimeTarget::installTracingStateObserver() {
+  jsExecutor_([](jsi::Runtime& runtime) {
+    jsinspector_modern::installTracingStateObserver(runtime);
+  });
+}
+
+void RuntimeTarget::emitTracingStateChange(bool isTracing) {
+  jsExecutor_([isTracing](jsi::Runtime& runtime) {
+    try {
+      emitTracingStateObserverChange(runtime, isTracing);
     } catch (jsi::JSError&) {
       // Suppress any errors, they should not be visible to the user
       // and should not affect runtime.
@@ -281,6 +293,10 @@ RuntimeTargetController::collectSamplingProfile() {
   return target_.collectSamplingProfile();
 }
 
+void RuntimeTargetController::emitTracingStateChange(bool isTracing) {
+  target_.emitTracingStateChange(isTracing);
+}
+
 void RuntimeTargetController::notifyDomainStateChanged(
     Domain domain,
     bool enabled,

package/ReactCommon/jsinspector-modern/RuntimeTarget.h

@@ -21,6 +21,7 @@
 #include <jsinspector-modern/tracing/TraceRecordingState.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 
 #ifndef JSINSPECTOR_EXPORT
@@ -147,6 +148,11 @@ class RuntimeTargetController {
    */
   tracing::RuntimeSamplingProfile collectSamplingProfile();
 
+  /**
+   * Emits a tracing state change to JavaScript via the tracing state observer.
+   */
+  void emitTracingStateChange(bool isTracing);
+
  private:
   RuntimeTarget &target_;
 };
@@ -262,6 +268,7 @@ class JSINSPECTOR_EXPORT RuntimeTarget : public EnableExecutorFromThis<RuntimeTa
    * session - HostTargetTraceRecording.
    */
   std::weak_ptr<RuntimeTracingAgent> tracingAgent_;
+
   /**
    * Start sampling profiler for a particular JavaScript runtime.
    */
@@ -304,6 +311,13 @@ class JSINSPECTOR_EXPORT RuntimeTarget : public EnableExecutorFromThis<RuntimeTa
    */
   void installDebuggerSessionObserver();
 
+  /**
+   * Installs __TRACING_STATE_OBSERVER__ object on the JavaScript's global
+   * object, which can be referenced from JavaScript side for determining the
+   * status of performance tracing.
+   */
+  void installTracingStateObserver();
+
   /**
    * Installs the private __NETWORK_REPORTER__ object on the Runtime's
    * global object.
@@ -322,6 +336,11 @@ class JSINSPECTOR_EXPORT RuntimeTarget : public EnableExecutorFromThis<RuntimeTa
    */
   void emitDebuggerSessionDestroyed();
 
+  /**
+   * Emits a tracing state change to JavaScript via the tracing state observer.
+   */
+  void emitTracingStateChange(bool isTracing);
+
   /**
    * \returns a globally unique ID for a network request.
    * May be called from any thread as long as the RuntimeTarget is valid.