react-native-tvos 0.81.4-0 → 0.82.0-0

package/ReactCommon/jsi/jsi/test/testlib.cpp

@@ -176,6 +176,57 @@ TEST_P(JSITest, ObjectTest) {
   Array names = obj.getPropertyNames(rt);
   EXPECT_EQ(names.size(rt), 1);
   EXPECT_EQ(names.getValueAtIndex(rt, 0).getString(rt).utf8(rt), "a");
+
+  // This Runtime Decorator is used to test the default implementation of
+  // Runtime::has/get/setProperty with Value overload
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    explicit RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    Value getProperty(const Object& object, const Value& name) override {
+      return Runtime::getProperty(object, name);
+    }
+
+    bool hasProperty(const Object& object, const Value& name) override {
+      return Runtime::hasProperty(object, name);
+    }
+
+    void setPropertyValue(
+        const Object& object,
+        const Value& name,
+        const Value& value) override {
+      Runtime::setPropertyValue(object, name, value);
+    }
+  };
+
+  RD rd = RD(rt);
+
+  obj = eval("const obj = {}; obj;").getObject(rd);
+  auto propVal = Value(123);
+  obj.setProperty(rd, propVal, 456);
+  EXPECT_TRUE(obj.hasProperty(rd, propVal));
+  auto getRes = obj.getProperty(rd, propVal);
+  EXPECT_EQ(getRes.getNumber(), 456);
+
+  /// The property is non-writable so it should fail
+  obj = eval(
+            "Object.defineProperty(obj, '456', {"
+            "  value: 10,"
+            "  writable: false,});")
+            .getObject(rd);
+  auto unwritableProp = Value(456);
+  EXPECT_THROW(obj.setProperty(rd, unwritableProp, 1), JSError);
+
+  auto badObjKey = eval(
+      "var badObj = {"
+      "    toString: function() {"
+      "        throw new Error('something went wrong');"
+      "    }"
+      "};"
+      "badObj;");
+  EXPECT_THROW(obj.setProperty(rd, badObjKey, 123), JSError);
+  EXPECT_THROW(obj.hasProperty(rd, badObjKey), JSError);
+  EXPECT_THROW(obj.getProperty(rd, badObjKey), JSError);
 }
 
 TEST_P(JSITest, HostObjectTest) {
@@ -1877,7 +1928,68 @@ TEST_P(JSITest, CastInterface) {
   auto randomUuid = UUID{0xf2cd96cf, 0x455e, 0x42d9, 0x850a, 0x13e2cde59b8b};
   auto ptr = rd.castInterface(randomUuid);
 
-  EXPECT_EQ(ptr, nullptr);
+  // Use == instead of EXPECT_EQ to avoid ambiguous operator usage due to the
+  // type of 'ptr'.
+  EXPECT_TRUE(ptr == nullptr);
+}
+
+TEST_P(JSITest, DeleteProperty) {
+  // This Runtime Decorator is used to test the default implementation of
+  // Runtime::deleteProperty
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    explicit RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    void deleteProperty(const Object& object, const PropNameID& name) override {
+      Runtime::deleteProperty(object, name);
+    }
+    void deleteProperty(const Object& object, const String& name) override {
+      Runtime::deleteProperty(object, name);
+    }
+    void deleteProperty(const Object& object, const Value& name) override {
+      Runtime::deleteProperty(object, name);
+    }
+  };
+  RD rd = RD(rt);
+  auto obj = eval("obj = {1:2, foo: 'bar', 3: 4, salt:'pepper'}").getObject(rd);
+
+  auto prop = PropNameID::forAscii(rd, "1");
+  auto hasRes = obj.hasProperty(rd, prop);
+  EXPECT_TRUE(hasRes);
+  obj.deleteProperty(rd, prop);
+  hasRes = obj.hasProperty(rd, prop);
+  EXPECT_FALSE(hasRes);
+
+  auto str = String::createFromAscii(rd, "foo");
+  hasRes = obj.hasProperty(rd, str);
+  EXPECT_TRUE(hasRes);
+  obj.deleteProperty(rd, str);
+  hasRes = obj.hasProperty(rd, str);
+  EXPECT_FALSE(hasRes);
+
+  auto valProp = Value(3);
+  hasRes = obj.hasProperty(rd, "3");
+  EXPECT_TRUE(hasRes);
+  obj.deleteProperty(rd, valProp);
+  auto getRes = obj.getProperty(rd, "3");
+  EXPECT_TRUE(getRes.isUndefined());
+
+  hasRes = obj.hasProperty(rd, "salt");
+  EXPECT_TRUE(hasRes);
+  obj.deleteProperty(rd, "salt");
+  hasRes = obj.hasProperty(rd, "salt");
+  EXPECT_FALSE(hasRes);
+
+  obj = eval(
+            "const obj = {};"
+            "Object.defineProperty(obj, 'prop', {"
+            "  value: 10,"
+            "  configurable: false,});"
+            "obj;")
+            .getObject(rd);
+  EXPECT_THROW(obj.deleteProperty(rd, "prop"), JSError);
+  hasRes = obj.hasProperty(rd, "prop");
+  EXPECT_TRUE(hasRes);
 }
 
 INSTANTIATE_TEST_CASE_P(

package/ReactCommon/jsiexecutor/React-jsiexecutor.podspec

@@ -29,9 +29,10 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard() }
   s.header_dir             = "jsireact"
 
-  s.dependency "React-cxxreact", version
-  s.dependency "React-jsi", version
-  s.dependency "React-perflogger", version
+  s.dependency "React-cxxreact"
+  s.dependency "React-jsi"
+  s.dependency "React-perflogger"
+  add_dependency(s, "React-debug")
   add_dependency(s, "React-runtimeexecutor", :additional_framework_paths => ["platform/ios"])
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
   add_dependency(s, "React-jsinspectorcdp", :framework_name => 'jsinspector_moderncdp')

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -58,7 +58,7 @@ namespace {
 
 // basename_r isn't in all iOS SDKs, so use this simple version instead.
 std::string simpleBasename(const std::string& path) {
-  size_t pos = path.rfind("/");
+  size_t pos = path.rfind('/');
   return (pos != std::string::npos) ? path.substr(pos) : path;
 }
 

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.h

@@ -67,7 +67,9 @@ class BigStringBuffer : public jsi::Buffer {
   std::unique_ptr<const JSBigString> script_;
 };
 
-class JSIExecutor : public JSExecutor {
+class [[deprecated(
+    "This API will be removed along with the legacy architecture.")]] JSIExecutor
+    : public JSExecutor {
  public:
   using RuntimeInstaller = std::function<void(jsi::Runtime& runtime)>;
 

package/ReactCommon/jsiexecutor/jsireact/JSINativeModules.h

@@ -21,7 +21,8 @@ namespace facebook::react {
 /**
  * Holds and creates JS representations of the modules in ModuleRegistry
  */
-class JSINativeModules {
+class [[deprecated(
+    "This API will be removed along with the legacy architecture.")]] JSINativeModules {
  public:
   explicit JSINativeModules(std::shared_ptr<ModuleRegistry> moduleRegistry);
   jsi::Value getModule(jsi::Runtime& rt, const jsi::PropNameID& name);

package/ReactCommon/jsinspector-modern/CMakeLists.txt

@@ -25,6 +25,7 @@ target_link_libraries(jsinspector
         jsinspector_tracing
         react_featureflags
         runtimeexecutor
+        reactperflogger
 )
 target_compile_reactnative_options(jsinspector PRIVATE)
 if(${CMAKE_BUILD_TYPE} MATCHES Debug OR REACT_NATIVE_DEBUG_OPTIMIZED)

package/ReactCommon/jsinspector-modern/ExecutionContext.h

@@ -9,7 +9,6 @@
 
 #include "UniqueMonostate.h"
 
-#include <cinttypes>
 #include <optional>
 #include <string>
 #include <unordered_set>
@@ -19,7 +18,7 @@ namespace facebook::react::jsinspector_modern {
 
 struct ExecutionContextDescription {
   int32_t id{};
-  std::string origin{""};
+  std::string origin;
   std::string name{"<anonymous>"};
   std::optional<std::string> uniqueId;
 };

package/ReactCommon/jsinspector-modern/FallbackRuntimeAgentDelegate.cpp

@@ -9,6 +9,7 @@
 
 #include <chrono>
 #include <string>
+#include <utility>
 
 using namespace std::chrono;
 using namespace std::literals::string_view_literals;
@@ -26,7 +27,8 @@ FallbackRuntimeAgentDelegate::FallbackRuntimeAgentDelegate(
     FrontendChannel frontendChannel,
     const SessionState& sessionState,
     std::string engineDescription)
-    : frontendChannel_(frontendChannel), engineDescription_(engineDescription) {
+    : frontendChannel_(std::move(frontendChannel)),
+      engineDescription_(std::move(engineDescription)) {
   if (sessionState.isLogDomainEnabled) {
     sendFallbackRuntimeWarning();
   }

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -36,18 +36,23 @@ namespace facebook::react::jsinspector_modern {
 class HostAgent::Impl final {
  public:
   explicit Impl(
-      HostAgent& hostAgent,
-      FrontendChannel frontendChannel,
+      HostAgent& /*hostAgent*/,
+      const FrontendChannel& frontendChannel,
       HostTargetController& targetController,
       HostTargetMetadata hostMetadata,
       SessionState& sessionState,
-      VoidExecutor executor)
+      VoidExecutor executor,
+      std::optional<tracing::TraceRecordingState> traceRecordingToEmit)
       : frontendChannel_(frontendChannel),
         targetController_(targetController),
         hostMetadata_(std::move(hostMetadata)),
         sessionState_(sessionState),
         networkIOAgent_(NetworkIOAgent(frontendChannel, std::move(executor))),
-        tracingAgent_(TracingAgent(frontendChannel)) {}
+        tracingAgent_(TracingAgent(
+            frontendChannel,
+            sessionState,
+            targetController,
+            std::move(traceRecordingToEmit))) {}
 
   ~Impl() {
     if (isPausedInDebuggerOverlayVisible_) {
@@ -63,10 +68,13 @@ class HostAgent::Impl final {
     }
   }
 
-  void handleRequest(const cdp::PreparsedRequest& req) {
-    bool shouldSendOKResponse = false;
-    bool isFinishedHandlingRequest = false;
+ private:
+  struct RequestHandlingState {
+    bool isFinishedHandlingRequest{false};
+    bool shouldSendOKResponse{false};
+  };
 
+  RequestHandlingState tryHandleRequest(const cdp::PreparsedRequest& req) {
     // Domain enable/disable requests: write to state (because we're the
     // top-level Agent in the Session), trigger any side effects, and decide
     // whether we are finished handling the request (or need to delegate to the
@@ -85,14 +93,20 @@ class HostAgent::Impl final {
             *hostMetadata_.integrationName);
       }
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = false;
-    } else if (req.method == "Log.disable") {
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Log.disable") {
       sessionState_.isLogDomainEnabled = false;
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = false;
-    } else if (req.method == "Runtime.enable") {
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Runtime.enable") {
       sessionState_.isRuntimeDomainEnabled = true;
 
       if (fuseboxClientType_ == FuseboxClientType::Unknown) {
@@ -103,43 +117,61 @@ class HostAgent::Impl final {
         sendNonFuseboxNotice();
       }
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = false;
-    } else if (req.method == "Runtime.disable") {
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Runtime.disable") {
       sessionState_.isRuntimeDomainEnabled = false;
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = false;
-    } else if (req.method == "Debugger.enable") {
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Debugger.enable") {
       sessionState_.isDebuggerDomainEnabled = true;
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = false;
-    } else if (req.method == "Debugger.disable") {
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Debugger.disable") {
       sessionState_.isDebuggerDomainEnabled = false;
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = false;
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
     }
+
     // Methods other than domain enables/disables: handle anything we know how
-    // to handle, and delegate to the InstanceAgent otherwise.
-    else if (req.method == "Page.reload") {
+    // to handle, and delegate to the InstanceAgent otherwise. (In some special
+    // cases we may handle the request *and* delegate to the InstanceAgent for
+    // some side effect.)
+    if (req.method == "Page.reload") {
       targetController_.getDelegate().onReload({
           .ignoreCache =
-              req.params.isObject() && req.params.count("ignoreCache")
+              req.params.isObject() && (req.params.count("ignoreCache") != 0u)
               ? std::optional(req.params.at("ignoreCache").asBool())
               : std::nullopt,
           .scriptToEvaluateOnLoad = req.params.isObject() &&
-                  req.params.count("scriptToEvaluateOnLoad")
+                  (req.params.count("scriptToEvaluateOnLoad") != 0u)
               ? std::optional(
                     req.params.at("scriptToEvaluateOnLoad").asString())
               : std::nullopt,
       });
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = true;
-    } else if (req.method == "Overlay.setPausedInDebuggerMessage") {
-      auto message = req.params.isObject() && req.params.count("message")
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Overlay.setPausedInDebuggerMessage") {
+      auto message =
+          req.params.isObject() && (req.params.count("message") != 0u)
           ? std::optional(req.params.at("message").asString())
           : std::nullopt;
       if (!isPausedInDebuggerOverlayVisible_ && message.has_value()) {
@@ -152,9 +184,12 @@ class HostAgent::Impl final {
           .message = message,
       });
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = true;
-    } else if (req.method == "ReactNativeApplication.enable") {
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "ReactNativeApplication.enable") {
       sessionState_.isReactNativeApplicationDomainEnabled = true;
       fuseboxClientType_ = FuseboxClientType::Fusebox;
 
@@ -166,44 +201,112 @@ class HostAgent::Impl final {
           "ReactNativeApplication.metadataUpdated",
           createHostMetadataPayload(hostMetadata_)));
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = true;
-    } else if (req.method == "ReactNativeApplication.disable") {
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "ReactNativeApplication.disable") {
       sessionState_.isReactNativeApplicationDomainEnabled = false;
 
-      shouldSendOKResponse = true;
-      isFinishedHandlingRequest = true;
-    } else if (req.method == "Tracing.start") {
-      if (sessionState_.isDebuggerDomainEnabled) {
-        frontendChannel_(cdp::jsonError(
-            req.id,
-            cdp::ErrorCode::InternalError,
-            "Debugger domain is expected to be disabled before starting Tracing"));
-
-        return;
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Runtime.addBinding") {
+      // @cdp Runtime.addBinding and @cdp Runtime.removeBinding are explicitly
+      // supported at any time during a session, even while the JS runtime
+      // hasn't been created yet. For this reason they are handled by the
+      // HostAgent.
+      std::string bindingName = req.params["name"].getString();
+
+      ExecutionContextSelector contextSelector =
+          ExecutionContextSelector::all();
+
+      if (req.params.count("executionContextId") != 0u) {
+        auto executionContextId = req.params["executionContextId"].getInt();
+        if (executionContextId < (int64_t)std::numeric_limits<int32_t>::min() ||
+            executionContextId > (int64_t)std::numeric_limits<int32_t>::max()) {
+          frontendChannel_(cdp::jsonError(
+              req.id,
+              cdp::ErrorCode::InvalidParams,
+              "Invalid execution context id"));
+          return {
+              .isFinishedHandlingRequest = true,
+              .shouldSendOKResponse = false,
+          };
+        }
+        contextSelector =
+            ExecutionContextSelector::byId((int32_t)executionContextId);
+
+        if (req.params.count("executionContextName") != 0u) {
+          frontendChannel_(cdp::jsonError(
+              req.id,
+              cdp::ErrorCode::InvalidParams,
+              "executionContextName is mutually exclusive with executionContextId"));
+          return {
+              .isFinishedHandlingRequest = true,
+              .shouldSendOKResponse = false,
+          };
+        }
+      } else if (req.params.count("executionContextName") != 0u) {
+        contextSelector = ExecutionContextSelector::byName(
+            req.params["executionContextName"].getString());
       }
 
-      // We delegate handling of this request to TracingAgent. If not handled,
-      // then something unexpected happened - don't send an OK response.
-      shouldSendOKResponse = false;
-      isFinishedHandlingRequest = false;
+      sessionState_.subscribedBindings[bindingName].insert(contextSelector);
+
+      // We need this request to percolate down to the RuntimeAgent via the
+      // InstanceAgent. If there isn't a RuntimeAgent, it's OK: the next
+      // RuntimeAgent will pick up the binding via session state.
+      return {
+          .isFinishedHandlingRequest = false,
+          .shouldSendOKResponse = true,
+      };
+    }
+    if (req.method == "Runtime.removeBinding") {
+      // @cdp Runtime.removeBinding has no targeting by execution context. We
+      // interpret it to mean "unsubscribe, and stop installing the binding on
+      // all new contexts". This diverges slightly from V8, which continues
+      // to install the binding on new contexts after it's "removed", but *only*
+      // if the subscription is targeted by context name.
+      sessionState_.subscribedBindings.erase(req.params["name"].getString());
+
+      // Because of the above, we don't need to pass this request down to the
+      // RuntimeAgent.
+      return {
+          .isFinishedHandlingRequest = true,
+          .shouldSendOKResponse = true,
+      };
     }
 
-    if (!isFinishedHandlingRequest &&
+    return {
+        .isFinishedHandlingRequest = false,
+        .shouldSendOKResponse = false,
+    };
+  }
+
+ public:
+  void handleRequest(const cdp::PreparsedRequest& req) {
+    const RequestHandlingState requestState = tryHandleRequest(req);
+
+    if (!requestState.isFinishedHandlingRequest &&
         networkIOAgent_.handleRequest(req, targetController_.getDelegate())) {
       return;
     }
 
-    if (!isFinishedHandlingRequest && tracingAgent_.handleRequest(req)) {
+    if (!requestState.isFinishedHandlingRequest &&
+        tracingAgent_.handleRequest(req)) {
       return;
     }
 
-    if (!isFinishedHandlingRequest && instanceAgent_ &&
+    if (!requestState.isFinishedHandlingRequest && instanceAgent_ &&
         instanceAgent_->handleRequest(req)) {
       return;
     }
 
-    if (shouldSendOKResponse) {
+    if (requestState.shouldSendOKResponse) {
       frontendChannel_(cdp::jsonResult(req.id));
       return;
     }
@@ -212,8 +315,6 @@ class HostAgent::Impl final {
   }
 
   void setCurrentInstanceAgent(std::shared_ptr<InstanceAgent> instanceAgent) {
-    tracingAgent_.setCurrentInstanceAgent(instanceAgent);
-
     auto previousInstanceAgent = std::move(instanceAgent_);
     instanceAgent_ = std::move(instanceAgent);
 
@@ -331,7 +432,8 @@ class HostAgent::Impl final {
       HostTargetController& targetController,
       HostTargetMetadata hostMetadata,
       SessionState& sessionState,
-      VoidExecutor executor) {}
+      VoidExecutor executor,
+      std::optional<tracing::TraceRecordingState> traceRecordingToEmit) {}
 
   void handleRequest(const cdp::PreparsedRequest& req) {}
   void setCurrentInstanceAgent(std::shared_ptr<InstanceAgent> agent) {}
@@ -344,14 +446,16 @@ HostAgent::HostAgent(
     HostTargetController& targetController,
     HostTargetMetadata hostMetadata,
     SessionState& sessionState,
-    VoidExecutor executor)
+    VoidExecutor executor,
+    std::optional<tracing::TraceRecordingState> traceRecordingToEmit)
     : impl_(std::make_unique<Impl>(
           *this,
           frontendChannel,
           targetController,
           std::move(hostMetadata),
           sessionState,
-          std::move(executor))) {}
+          std::move(executor),
+          std::move(traceRecordingToEmit))) {}
 
 HostAgent::~HostAgent() = default;
 
@@ -364,4 +468,17 @@ void HostAgent::setCurrentInstanceAgent(
   impl_->setCurrentInstanceAgent(std::move(instanceAgent));
 }
 
+#pragma mark - Tracing
+
+HostTracingAgent::HostTracingAgent(tracing::TraceRecordingState& state)
+    : tracing::TargetTracingAgent(state) {}
+
+void HostTracingAgent::setTracedInstance(InstanceTarget* instanceTarget) {
+  if (instanceTarget != nullptr) {
+    instanceTracingAgent_ = instanceTarget->createTracingAgent(state_);
+  } else {
+    instanceTracingAgent_ = nullptr;
+  }
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostAgent.h

@@ -12,6 +12,7 @@
 #include <jsinspector-modern/InspectorInterfaces.h>
 #include <jsinspector-modern/InstanceAgent.h>
 #include <jsinspector-modern/cdp/CdpJson.h>
+#include <jsinspector-modern/tracing/TargetTracingAgent.h>
 
 namespace facebook::react::jsinspector_modern {
 
@@ -35,13 +36,16 @@ 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,
       HostTargetMetadata hostMetadata,
       SessionState& sessionState,
-      VoidExecutor executor);
+      VoidExecutor executor,
+      std::optional<tracing::TraceRecordingState> traceRecordingToEmit);
 
   HostAgent(const HostAgent&) = delete;
   HostAgent(HostAgent&&) = delete;
@@ -75,4 +79,25 @@ class HostAgent final {
   std::unique_ptr<Impl> impl_;
 };
 
+#pragma mark - Tracing
+
+/**
+ * An Agent that handles Tracing events for a particular InstanceTarget.
+ *
+ * Lifetime of this agent is bound to the lifetime of the Tracing session -
+ * HostTargetTraceRecording.
+ */
+class HostTracingAgent : tracing::TargetTracingAgent {
+ public:
+  explicit HostTracingAgent(tracing::TraceRecordingState& state);
+
+  /**
+   * Registers the InstanceTarget with this tracing agent.
+   */
+  void setTracedInstance(InstanceTarget* instanceTarget);
+
+ private:
+  std::shared_ptr<InstanceTracingAgent> instanceTracingAgent_{nullptr};
+};
+
 } // namespace facebook::react::jsinspector_modern