react-native-tvos 0.82.1-0 → 0.83.0-0

package/ReactCommon/jsinspector-modern/HostAgent.h

@@ -36,21 +36,18 @@ class HostAgent final {
    * \param hostMetadata Metadata about the host that created this agent.
    * \param sessionState The state of the session that created this agent.
    * \param executor A void executor to be used by async-aware handlers.
-   * \param traceRecordingToEmit If set, this is the trace that Host has
-   * requested to display in the Frontend.
    */
   HostAgent(
-      const FrontendChannel& frontendChannel,
-      HostTargetController& targetController,
+      const FrontendChannel &frontendChannel,
+      HostTargetController &targetController,
       HostTargetMetadata hostMetadata,
-      SessionState& sessionState,
-      VoidExecutor executor,
-      std::optional<tracing::TraceRecordingState> traceRecordingToEmit);
+      SessionState &sessionState,
+      VoidExecutor executor);
 
-  HostAgent(const HostAgent&) = delete;
-  HostAgent(HostAgent&&) = delete;
-  HostAgent& operator=(const HostAgent&) = delete;
-  HostAgent& operator=(HostAgent&&) = delete;
+  HostAgent(const HostAgent &) = delete;
+  HostAgent(HostAgent &&) = delete;
+  HostAgent &operator=(const HostAgent &) = delete;
+  HostAgent &operator=(HostAgent &&) = delete;
 
   ~HostAgent();
 
@@ -59,7 +56,7 @@ class HostAgent final {
    * \c FrontendChannel synchronously or asynchronously.
    * \param req The parsed request.
    */
-  void handleRequest(const cdp::PreparsedRequest& req);
+  void handleRequest(const cdp::PreparsedRequest &req);
 
   /**
    * Replace the current InstanceAgent with the given one and notify the
@@ -69,6 +66,25 @@ class HostAgent final {
    */
   void setCurrentInstanceAgent(std::shared_ptr<InstanceAgent> agent);
 
+  /**
+   * Returns whether this HostAgent is part of the session that has an active
+   * Fusebox client connecte, i.e. with Chrome DevTools Frontend fork for React
+   * Native.
+   */
+  bool hasFuseboxClientConnected() const;
+
+  /**
+   * Emits the trace recording that was captured externally, not via the
+   * CDP-initiated request.
+   */
+  void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) const;
+
+  /**
+   * Emits a system state changed event when the number of ReactHost instances
+   * changes.
+   */
+  void emitSystemStateChanged(bool isSingleHost) const;
+
  private:
   // We use the private implementation idiom to ensure this class has the same
   // layout regardless of whether REACT_NATIVE_DEBUGGER_ENABLED is defined. The
@@ -89,12 +105,12 @@ class HostAgent final {
  */
 class HostTracingAgent : tracing::TargetTracingAgent {
  public:
-  explicit HostTracingAgent(tracing::TraceRecordingState& state);
+  explicit HostTracingAgent(tracing::TraceRecordingState &state);
 
   /**
    * Registers the InstanceTarget with this tracing agent.
    */
-  void setTracedInstance(InstanceTarget* instanceTarget);
+  void setTracedInstance(InstanceTarget *instanceTarget);
 
  private:
   std::shared_ptr<InstanceTracingAgent> instanceTracingAgent_{nullptr};

package/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -34,8 +34,7 @@ class HostTargetSession {
       std::unique_ptr<IRemoteConnection> remote,
       HostTargetController& targetController,
       HostTargetMetadata hostMetadata,
-      VoidExecutor executor,
-      std::optional<tracing::TraceRecordingState> traceRecordingToEmit)
+      VoidExecutor executor)
       : remote_(std::make_shared<RAIIRemoteConnection>(std::move(remote))),
         frontendChannel_(
             [remoteWeak = std::weak_ptr(remote_)](std::string_view message) {
@@ -48,8 +47,7 @@ class HostTargetSession {
             targetController,
             std::move(hostMetadata),
             state_,
-            std::move(executor),
-            std::move(traceRecordingToEmit)) {}
+            std::move(executor)) {}
 
   /**
    * Called by CallbackLocalConnection to send a message to this Session's
@@ -65,8 +63,9 @@ class HostTargetSession {
           cdp::jsonError(std::nullopt, cdp::ErrorCode::ParseError, e.what()));
       return;
     } catch (const cdp::TypeError& e) {
-      frontendChannel_(cdp::jsonError(
-          std::nullopt, cdp::ErrorCode::InvalidRequest, e.what()));
+      frontendChannel_(
+          cdp::jsonError(
+              std::nullopt, cdp::ErrorCode::InvalidRequest, e.what()));
       return;
     }
 
@@ -103,6 +102,19 @@ class HostTargetSession {
     }
   }
 
+  /**
+   * Returns whether the ReactNativeApplication CDP domain is enabled.
+   *
+   * Chrome DevTools Frontend enables this domain as a client.
+   */
+  bool hasFuseboxClient() const {
+    return hostAgent_.hasFuseboxClientConnected();
+  }
+
+  void emitTraceRecording(tracing::TraceRecordingState traceRecording) const {
+    hostAgent_.emitExternalTraceRecording(std::move(traceRecording));
+  }
+
  private:
   // Owned by this instance, but shared (weakly) with the frontend channel
   std::shared_ptr<RAIIRemoteConnection> remote_;
@@ -159,28 +171,30 @@ class HostRuntimeBinding {
       HostTarget& target,
       std::string name,
       std::function<void(std::string)> callback)
-      : connection_(target.connect(std::make_unique<CallbackRemoteConnection>(
-            [callback = std::move(callback)](const std::string& message) {
-              auto parsedMessage = folly::parseJson(message);
-
-              // Ignore initial Runtime.addBinding response
-              if (parsedMessage["id"] == 0 &&
-                  parsedMessage["result"].isObject() &&
-                  parsedMessage["result"].empty()) {
-                return;
-              }
-
-              // Assert that we only intercept bindingCalled responses
-              assert(
-                  parsedMessage["method"].asString() ==
-                  "Runtime.bindingCalled");
-              callback(parsedMessage["params"]["payload"].asString());
-            }))) {
+      : connection_(target.connect(
+            std::make_unique<CallbackRemoteConnection>(
+                [callback = std::move(callback)](const std::string& message) {
+                  auto parsedMessage = folly::parseJson(message);
+
+                  // Ignore initial Runtime.addBinding response
+                  if (parsedMessage["id"] == 0 &&
+                      parsedMessage["result"].isObject() &&
+                      parsedMessage["result"].empty()) {
+                    return;
+                  }
+
+                  // Assert that we only intercept bindingCalled responses
+                  assert(
+                      parsedMessage["method"].asString() ==
+                      "Runtime.bindingCalled");
+                  callback(parsedMessage["params"]["payload"].asString());
+                }))) {
     // Install runtime binding
-    connection_->sendMessage(cdp::jsonRequest(
-        0,
-        "Runtime.addBinding",
-        folly::dynamic::object("name", std::move(name))));
+    connection_->sendMessage(
+        cdp::jsonRequest(
+            0,
+            "Runtime.addBinding",
+            folly::dynamic::object("name", std::move(name))));
   }
 
  private:
@@ -192,8 +206,8 @@ std::shared_ptr<HostTarget> HostTarget::create(
     VoidExecutor executor) {
   std::shared_ptr<HostTarget> hostTarget{new HostTarget(delegate)};
   hostTarget->setExecutor(std::move(executor));
-  if (InspectorFlags::getInstance().getPerfMonitorV2Enabled()) {
-    hostTarget->installPerfMetricsBinding();
+  if (InspectorFlags::getInstance().getPerfIssuesEnabled()) {
+    hostTarget->installPerfIssuesBinding();
   }
   return hostTarget;
 }
@@ -208,8 +222,7 @@ std::unique_ptr<ILocalConnection> HostTarget::connect(
       std::move(connectionToFrontend),
       controller_,
       delegate_.getMetadata(),
-      makeVoidExecutor(executorFromThis()),
-      delegate_.unstable_getTraceRecordingThatWillBeEmittedOnInitialization());
+      makeVoidExecutor(executorFromThis()));
   session->setCurrentInstance(currentInstance_.get());
   sessions_.insert(std::weak_ptr(session));
   return std::make_unique<CallbackLocalConnection>(
@@ -279,14 +292,14 @@ void HostTarget::sendCommand(HostCommand command) {
   });
 }
 
-void HostTarget::installPerfMetricsBinding() {
+void HostTarget::installPerfIssuesBinding() {
   perfMonitorUpdateHandler_ =
       std::make_unique<PerfMonitorUpdateHandler>(delegate_);
   perfMetricsBinding_ = std::make_unique<HostRuntimeBinding>(
       *this, // Used immediately
-      "__chromium_devtools_metrics_reporter",
+      "__react_native_perf_issues_reporter",
       [this](const std::string& message) {
-        perfMonitorUpdateHandler_->handlePerfMetricsUpdate(message);
+        perfMonitorUpdateHandler_->handlePerfIssueAdded(message);
       });
 }
 
@@ -361,4 +374,32 @@ folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata) {
   return result;
 }
 
+bool HostTarget::hasActiveSessionWithFuseboxClient() const {
+  bool hasActiveFuseboxSession = false;
+  sessions_.forEach([&](HostTargetSession& session) {
+    hasActiveFuseboxSession |= session.hasFuseboxClient();
+  });
+  return hasActiveFuseboxSession;
+}
+
+void HostTarget::emitTraceRecordingForFirstFuseboxClient(
+    tracing::TraceRecordingState traceRecording) const {
+  bool emitted = false;
+  sessions_.forEach([&](HostTargetSession& session) {
+    if (emitted) {
+      /**
+       * TraceRecordingState object is not copiable for performance reasons,
+       * because it could contain large Runtime sampling profile object.
+       *
+       * This approach would not work with multi-client debugger setup.
+       */
+      return;
+    }
+    if (session.hasFuseboxClient()) {
+      session.emitTraceRecording(std::move(traceRecording));
+      emitted = true;
+    }
+  });
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostTarget.h

@@ -45,12 +45,12 @@ class HostTarget;
 class HostTargetTraceRecording;
 
 struct HostTargetMetadata {
-  std::optional<std::string> appDisplayName;
-  std::optional<std::string> appIdentifier;
-  std::optional<std::string> deviceName;
+  std::optional<std::string> appDisplayName{};
+  std::optional<std::string> appIdentifier{};
+  std::optional<std::string> deviceName{};
   std::optional<std::string> integrationName;
-  std::optional<std::string> platform;
-  std::optional<std::string> reactNativeVersion;
+  std::optional<std::string> platform{};
+  std::optional<std::string> reactNativeVersion{};
 };
 
 /**
@@ -61,10 +61,10 @@ struct HostTargetMetadata {
 class HostTargetDelegate : public LoadNetworkResourceDelegate {
  public:
   HostTargetDelegate() = default;
-  HostTargetDelegate(const HostTargetDelegate&) = delete;
-  HostTargetDelegate(HostTargetDelegate&&) = delete;
-  HostTargetDelegate& operator=(const HostTargetDelegate&) = delete;
-  HostTargetDelegate& operator=(HostTargetDelegate&&) = delete;
+  HostTargetDelegate(const HostTargetDelegate &) = delete;
+  HostTargetDelegate(HostTargetDelegate &&) = delete;
+  HostTargetDelegate &operator=(const HostTargetDelegate &) = delete;
+  HostTargetDelegate &operator=(HostTargetDelegate &&) = delete;
 
   // TODO(moti): This is 1:1 the shape of the corresponding CDP message -
   // consider reusing typed/generated CDP interfaces when we have those.
@@ -79,9 +79,9 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
     /**
      * Equality operator, useful for unit tests
      */
-    inline bool operator==(const PageReloadRequest& rhs) const {
-      return ignoreCache == rhs.ignoreCache &&
-          scriptToEvaluateOnLoad == rhs.scriptToEvaluateOnLoad;
+    inline bool operator==(const PageReloadRequest &rhs) const
+    {
+      return ignoreCache == rhs.ignoreCache && scriptToEvaluateOnLoad == rhs.scriptToEvaluateOnLoad;
     }
   };
 
@@ -94,8 +94,8 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
     /**
      * Equality operator, useful for unit tests
      */
-    inline bool operator==(
-        const OverlaySetPausedInDebuggerMessageRequest& rhs) const {
+    inline bool operator==(const OverlaySetPausedInDebuggerMessageRequest &rhs) const
+    {
       return message == rhs.message;
     }
   };
@@ -113,7 +113,7 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
    * the thread on which messages are dispatched to the session (that is, where
    * ILocalConnection::sendMessage was called).
    */
-  virtual void onReload(const PageReloadRequest& request) = 0;
+  virtual void onReload(const PageReloadRequest &request) = 0;
 
   /**
    * Called when the debugger requests that the "paused in debugger" overlay be
@@ -125,15 +125,13 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
    * the timing and payload of these messages are fully controlled by the
    * client.
    */
-  virtual void onSetPausedInDebuggerMessage(
-      const OverlaySetPausedInDebuggerMessageRequest& request) = 0;
+  virtual void onSetPausedInDebuggerMessage(const OverlaySetPausedInDebuggerMessageRequest &request) = 0;
 
   /**
    * [Experimental] Called when the runtime has new data for the V2 Perf
    * Monitor overlay. This is called on the inspector thread.
    */
-  virtual void unstable_onPerfMonitorUpdate(
-      const PerfMonitorUpdateRequest& /*request*/) {}
+  virtual void unstable_onPerfIssueAdded(const PerfIssuePayload & /*issue*/) {}
 
   /**
    * Called by NetworkIOAgent on handling a `Network.loadNetworkResource` CDP
@@ -142,8 +140,9 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
    * of headers, data chunks, and errors.
    */
   void loadNetworkResource(
-      const LoadNetworkResourceRequest& /*params*/,
-      ScopedExecutor<NetworkRequestListener> /*executor*/) override {
+      const LoadNetworkResourceRequest & /*params*/,
+      ScopedExecutor<NetworkRequestListener> /*executor*/) override
+  {
     throw NotImplementedException(
         "LoadNetworkResourceDelegate.loadNetworkResource is not implemented by this host target delegate.");
   }
@@ -156,8 +155,8 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
    * \return the trace recording state if there is one that needs to be
    * displayed, otherwise std::nullopt.
    */
-  virtual std::optional<tracing::TraceRecordingState>
-  unstable_getTraceRecordingThatWillBeEmittedOnInitialization() {
+  virtual std::optional<tracing::TraceRecordingState> unstable_getTraceRecordingThatWillBeEmittedOnInitialization()
+  {
     return std::nullopt;
   }
 };
@@ -168,12 +167,19 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
  */
 class HostTargetController final {
  public:
-  explicit HostTargetController(HostTarget& target);
+  explicit HostTargetController(HostTarget &target);
 
-  HostTargetDelegate& getDelegate();
+  HostTargetDelegate &getDelegate();
 
   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
@@ -207,7 +213,7 @@ class HostTargetController final {
   tracing::TraceRecordingState stopTracing();
 
  private:
-  HostTarget& target_;
+  HostTarget &target_;
   size_t pauseOverlayCounter_{0};
 };
 
@@ -216,8 +222,7 @@ class HostTargetController final {
  * "Host" in React Native's architecture - the entity that manages the
  * lifecycle of a React Instance.
  */
-class JSINSPECTOR_EXPORT HostTarget
-    : public EnableExecutorFromThis<HostTarget> {
+class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget> {
  public:
   /**
    * Constructs a new HostTarget.
@@ -232,14 +237,12 @@ class JSINSPECTOR_EXPORT HostTarget
    * that such destructor calls are safe - e.g. if using a lambda as the
    * executor, all captured values must be safe to destroy from any thread.
    */
-  static std::shared_ptr<HostTarget> create(
-      HostTargetDelegate& delegate,
-      VoidExecutor executor);
-
-  HostTarget(const HostTarget&) = delete;
-  HostTarget(HostTarget&&) = delete;
-  HostTarget& operator=(const HostTarget&) = delete;
-  HostTarget& operator=(HostTarget&&) = delete;
+  static std::shared_ptr<HostTarget> create(HostTargetDelegate &delegate, VoidExecutor executor);
+
+  HostTarget(const HostTarget &) = delete;
+  HostTarget(HostTarget &&) = delete;
+  HostTarget &operator=(const HostTarget &) = delete;
+  HostTarget &operator=(HostTarget &&) = delete;
   ~HostTarget();
 
   /**
@@ -249,8 +252,7 @@ class JSINSPECTOR_EXPORT HostTarget
    * is destroyed, on the same thread where HostTarget's constructor and
    * destructor execute.
    */
-  std::unique_ptr<ILocalConnection> connect(
-      std::unique_ptr<IRemoteConnection> connectionToFrontend);
+  std::unique_ptr<ILocalConnection> connect(std::unique_ptr<IRemoteConnection> connectionToFrontend);
 
   /**
    * Registers an instance with this HostTarget.
@@ -262,14 +264,14 @@ class JSINSPECTOR_EXPORT HostTarget
    * (or the HostTarget is destroyed). \pre There isn't currently an instance
    * registered with this HostTarget.
    */
-  InstanceTarget& registerInstance(InstanceTargetDelegate& delegate);
+  InstanceTarget &registerInstance(InstanceTargetDelegate &delegate);
 
   /**
    * Unregisters an instance from this HostTarget.
    * \param instance The InstanceTarget reference previously returned by
    * registerInstance.
    */
-  void unregisterInstance(InstanceTarget& instance);
+  void unregisterInstance(InstanceTarget &instance);
 
   /**
    * Sends an imperative command to the HostTarget. May be called from any
@@ -284,8 +286,7 @@ class JSINSPECTOR_EXPORT HostTarget
    *
    * \param state A reference to the state of the active trace recording.
    */
-  std::shared_ptr<HostTracingAgent> createTracingAgent(
-      tracing::TraceRecordingState& state);
+  std::shared_ptr<HostTracingAgent> createTracingAgent(tracing::TraceRecordingState &state);
 
   /**
    * Starts trace recording for this HostTarget.
@@ -305,6 +306,25 @@ class JSINSPECTOR_EXPORT HostTarget
    */
   tracing::TracingState tracingState() const;
 
+  /**
+   * Returns whether there is an active session with the Fusebox client, i.e.
+   * with Chrome DevTools Frontend fork for React Native.
+   */
+  bool hasActiveSessionWithFuseboxClient() const;
+
+  /**
+   * Emits the trace recording for the first active session with the Fusebox
+   * client.
+   *
+   * @see \c hasActiveFrontendSession
+   */
+  void emitTraceRecordingForFirstFuseboxClient(tracing::TraceRecordingState traceRecording) const;
+
+  /**
+   * Emits a system state changed event to all active sessions.
+   */
+  void emitSystemStateChanged(bool isSingleHost) const;
+
  private:
   /**
    * Constructs a new HostTarget.
@@ -313,9 +333,9 @@ class JSINSPECTOR_EXPORT HostTarget
    * receive events from this HostTarget. The caller is responsible for ensuring
    * that the HostTargetDelegate outlives this object.
    */
-  HostTarget(HostTargetDelegate& delegate);
+  HostTarget(HostTargetDelegate &delegate);
 
-  HostTargetDelegate& delegate_;
+  HostTargetDelegate &delegate_;
   WeakList<HostTargetSession> sessions_;
   HostTargetController controller_{*this};
   // executionContextManager_ is a shared_ptr to guarantee its validity while
@@ -335,20 +355,22 @@ class JSINSPECTOR_EXPORT HostTarget
    */
   std::unique_ptr<HostTargetTraceRecording> traceRecording_{nullptr};
 
-  inline HostTargetDelegate& getDelegate() {
+  inline HostTargetDelegate &getDelegate()
+  {
     return delegate_;
   }
 
-  inline bool hasInstance() const {
+  inline bool hasInstance() const
+  {
     return currentInstance_ != nullptr;
   }
 
   /**
-   * Install a runtime binding subscribing to the Interaction to Next Paint
-   * (INP) live metric, which we broadcast to the V2 Perf Monitor overlay
-   * via \ref HostTargetDelegate::unstable_onPerfMonitorUpdate.
+   * [Experimental] Install a runtime binding subscribing to new Peformance
+   * Issues, which we broadcast to the V2 Perf Monitor overlay via
+   * \ref HostTargetDelegate::unstable_onPerfMonitorUpdate.
    */
-  void installPerfMetricsBinding();
+  void installPerfIssuesBinding();
 
   // Necessary to allow HostAgent to access HostTarget's internals in a
   // controlled way (i.e. only HostTargetController gets friend access, while
@@ -356,6 +378,6 @@ class JSINSPECTOR_EXPORT HostTarget
   friend class HostTargetController;
 };
 
-folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata);
+folly::dynamic createHostMetadataPayload(const HostTargetMetadata &metadata);
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostTargetTraceRecording.h

@@ -28,22 +28,22 @@ namespace facebook::react::jsinspector_modern {
  */
 class HostTargetTraceRecording {
  public:
-  explicit HostTargetTraceRecording(
-      tracing::Mode tracingMode,
-      HostTarget& hostTarget);
+  explicit HostTargetTraceRecording(tracing::Mode tracingMode, HostTarget &hostTarget);
 
-  inline bool isBackgroundInitiated() const {
+  inline bool isBackgroundInitiated() const
+  {
     return tracingMode_ == tracing::Mode::Background;
   }
 
-  inline bool isUserInitiated() const {
+  inline bool isUserInitiated() const
+  {
     return tracingMode_ == tracing::Mode::CDP;
   }
 
   /**
    * Updates the current traced Instance for this recording.
    */
-  void setTracedInstance(InstanceTarget* instanceTarget);
+  void setTracedInstance(InstanceTarget *instanceTarget);
 
   /**
    * Starts the recording.
@@ -68,7 +68,7 @@ class HostTargetTraceRecording {
   /**
    * The Host for which this Trace Recording is going to happen.
    */
-  HostTarget& hostTarget_;
+  HostTarget &hostTarget_;
 
   /**
    * The state of the current Trace Recording.

package/ReactCommon/jsinspector-modern/InspectorFlags.cpp

@@ -17,6 +17,10 @@ InspectorFlags& InspectorFlags::getInstance() {
   return instance;
 }
 
+bool InspectorFlags::getAssertSingleHostState() const {
+  return loadFlagsAndAssertUnchanged().assertSingleHostState;
+}
+
 bool InspectorFlags::getFuseboxEnabled() const {
   if (fuseboxDisabledForTest_) {
     return false;
@@ -33,8 +37,8 @@ bool InspectorFlags::getNetworkInspectionEnabled() const {
   return loadFlagsAndAssertUnchanged().networkInspectionEnabled;
 }
 
-bool InspectorFlags::getPerfMonitorV2Enabled() const {
-  return loadFlagsAndAssertUnchanged().perfMonitorV2Enabled;
+bool InspectorFlags::getPerfIssuesEnabled() const {
+  return loadFlagsAndAssertUnchanged().perfIssuesEnabled;
 }
 
 void InspectorFlags::dangerouslyResetFlags() {
@@ -48,6 +52,8 @@ void InspectorFlags::dangerouslyDisableFuseboxForTest() {
 const InspectorFlags::Values& InspectorFlags::loadFlagsAndAssertUnchanged()
     const {
   InspectorFlags::Values newValues = {
+      .assertSingleHostState =
+          ReactNativeFeatureFlags::fuseboxAssertSingleHostState(),
       .fuseboxEnabled =
 #if defined(REACT_NATIVE_DEBUGGER_ENABLED)
           true,
@@ -63,9 +69,7 @@ const InspectorFlags::Values& InspectorFlags::loadFlagsAndAssertUnchanged()
       .networkInspectionEnabled =
           ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
           ReactNativeFeatureFlags::fuseboxNetworkInspectionEnabled(),
-      .perfMonitorV2Enabled =
-          ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
-          ReactNativeFeatureFlags::perfMonitorV2Enabled(),
+      .perfIssuesEnabled = ReactNativeFeatureFlags::perfIssuesEnabled(),
   };
 
   if (cachedValues_.has_value() && !inconsistentFlagsStateLogged_) {

package/ReactCommon/jsinspector-modern/InspectorFlags.h

@@ -17,7 +17,13 @@ namespace facebook::react::jsinspector_modern {
  */
 class InspectorFlags {
  public:
-  static InspectorFlags& getInstance();
+  static InspectorFlags &getInstance();
+
+  /**
+   * Flag determining if the inspector backend should strictly assert that only
+   * a single host is registered.
+   */
+  bool getAssertSingleHostState() const;
 
   /**
    * Flag determining if the modern CDP backend should be enabled.
@@ -38,7 +44,7 @@ class InspectorFlags {
   /**
    * Flag determining if the V2 in-app Performance Monitor is enabled.
    */
-  bool getPerfMonitorV2Enabled() const;
+  bool getPerfIssuesEnabled() const;
 
   /**
    * Forcibly disable the main `getFuseboxEnabled()` flag. This should ONLY be
@@ -54,23 +60,24 @@ class InspectorFlags {
 
  private:
   struct Values {
+    bool assertSingleHostState;
     bool fuseboxEnabled;
     bool isProfilingBuild;
     bool networkInspectionEnabled;
-    bool perfMonitorV2Enabled;
-    bool operator==(const Values&) const = default;
+    bool perfIssuesEnabled;
+    bool operator==(const Values &) const = default;
   };
 
   InspectorFlags() = default;
-  InspectorFlags(const InspectorFlags&) = delete;
-  InspectorFlags& operator=(const InspectorFlags&) = default;
+  InspectorFlags(const InspectorFlags &) = delete;
+  InspectorFlags &operator=(const InspectorFlags &) = default;
   ~InspectorFlags() = default;
 
   mutable std::optional<Values> cachedValues_;
   mutable bool inconsistentFlagsStateLogged_{false};
   bool fuseboxDisabledForTest_{false};
 
-  const Values& loadFlagsAndAssertUnchanged() const;
+  const Values &loadFlagsAndAssertUnchanged() const;
 };
 
 } // namespace facebook::react::jsinspector_modern