react-native-tvos 0.78.0-0rc4 → 0.79.0-0

package/ReactCommon/jsi/jsi/jsi.cpp

@@ -163,6 +163,45 @@ std::u16string convertUTF8ToUTF16(const std::string& utf8) {
   return ret;
 }
 
+// Given a unsigned number, which is less than 16, return the hex character.
+inline char hexDigit(unsigned x) {
+  return x < 10 ? '0' + x : 'A' + (x - 10);
+}
+
+// Given a sequence of UTF 16 code units, return true if all code units are
+// ASCII characters
+bool isAllASCII(const char16_t* utf16, size_t length) {
+  for (const char16_t* e = utf16 + length; utf16 != e; ++utf16) {
+    if (*utf16 > 0x7F)
+      return false;
+  }
+  return true;
+}
+
+// Given a sequences of UTF 16 code units, return a string that explicitly
+// expresses the code units
+std::string getUtf16CodeUnitString(const char16_t* utf16, size_t length) {
+  // Every character will need 4 hex digits + the character escape "\u".
+  // Plus 2 character for the opening and closing single quote.
+  std::string s = std::string(6 * length + 2, 0);
+  s.front() = '\'';
+
+  for (size_t i = 0; i != length; ++i) {
+    char16_t ch = utf16[i];
+    size_t start = (6 * i) + 1;
+
+    s[start] = '\\';
+    s[start + 1] = 'u';
+
+    s[start + 2] = hexDigit((ch >> 12) & 0x000f);
+    s[start + 3] = hexDigit((ch >> 8) & 0x000f);
+    s[start + 4] = hexDigit((ch >> 4) & 0x000f);
+    s[start + 5] = hexDigit(ch & 0x000f);
+  }
+  s.back() = '\'';
+  return s;
+}
+
 } // namespace
 
 Buffer::~Buffer() = default;
@@ -248,6 +287,25 @@ Value Runtime::createValueFromJsonUtf8(const uint8_t* json, size_t length) {
   return parseJson.call(*this, String::createFromUtf8(*this, json, length));
 }
 
+String Runtime::createStringFromUtf16(const char16_t* utf16, size_t length) {
+  if (isAllASCII(utf16, length)) {
+    std::string buffer(utf16, utf16 + length);
+    return createStringFromAscii(buffer.data(), length);
+  }
+  auto s = getUtf16CodeUnitString(utf16, length);
+  return global()
+      .getPropertyAsFunction(*this, "eval")
+      .call(*this, s)
+      .getString(*this);
+}
+
+PropNameID Runtime::createPropNameIDFromUtf16(
+    const char16_t* utf16,
+    size_t length) {
+  auto jsString = createStringFromUtf16(utf16, length);
+  return createPropNameIDFromString(jsString);
+}
+
 std::u16string Runtime::utf16(const PropNameID& sym) {
   auto utf8Str = utf8(sym);
   return convertUTF8ToUTF16(utf8Str);

package/ReactCommon/jsi/jsi/jsi.h

@@ -306,6 +306,9 @@ class JSI_EXPORT Runtime {
   virtual PropNameID createPropNameIDFromUtf8(
       const uint8_t* utf8,
       size_t length) = 0;
+  virtual PropNameID createPropNameIDFromUtf16(
+      const char16_t* utf16,
+      size_t length);
   virtual PropNameID createPropNameIDFromString(const String& str) = 0;
   virtual PropNameID createPropNameIDFromSymbol(const Symbol& sym) = 0;
   virtual std::string utf8(const PropNameID&) = 0;
@@ -322,6 +325,7 @@ class JSI_EXPORT Runtime {
 
   virtual String createStringFromAscii(const char* str, size_t length) = 0;
   virtual String createStringFromUtf8(const uint8_t* utf8, size_t length) = 0;
+  virtual String createStringFromUtf16(const char16_t* utf16, size_t length);
   virtual std::string utf8(const String&) = 0;
 
   // \return a \c Value created from a utf8-encoded JSON string. The default
@@ -515,6 +519,21 @@ class JSI_EXPORT PropNameID : public Pointer {
         reinterpret_cast<const uint8_t*>(utf8.data()), utf8.size());
   }
 
+  /// Given a series of UTF-16 encoded code units, create a PropNameId. The
+  /// input may contain unpaired surrogates, which will be interpreted as a code
+  /// point of the same value.
+  static PropNameID
+  forUtf16(Runtime& runtime, const char16_t* utf16, size_t length) {
+    return runtime.createPropNameIDFromUtf16(utf16, length);
+  }
+
+  /// Given a series of UTF-16 encoded code units stored inside std::u16string,
+  /// create a PropNameId.  The input may contain unpaired surrogates, which
+  /// will be interpreted as a code point of the same value.
+  static PropNameID forUtf16(Runtime& runtime, const std::u16string& str) {
+    return runtime.createPropNameIDFromUtf16(str.data(), str.size());
+  }
+
   /// Create a PropNameID from a JS string.
   static PropNameID forString(Runtime& runtime, const jsi::String& str) {
     return runtime.createPropNameIDFromString(str);
@@ -699,6 +718,21 @@ class JSI_EXPORT String : public Pointer {
         reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length());
   }
 
+  /// Given a series of UTF-16 encoded code units, create a JS String. The input
+  /// may contain unpaired surrogates, which will be interpreted as a code point
+  /// of the same value.
+  static String
+  createFromUtf16(Runtime& runtime, const char16_t* utf16, size_t length) {
+    return runtime.createStringFromUtf16(utf16, length);
+  }
+
+  /// Given a series of UTF-16 encoded code units stored inside std::u16string,
+  /// create a JS String. The input may contain unpaired surrogates, which will
+  /// be interpreted as a code point of the same value.
+  static String createFromUtf16(Runtime& runtime, const std::u16string& utf16) {
+    return runtime.createStringFromUtf16(utf16.data(), utf16.length());
+  }
+
   /// \return whether a and b contain the same characters.
   static bool strictEquals(Runtime& runtime, const String& a, const String& b) {
     return runtime.strictEquals(a, b);

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

@@ -1576,7 +1576,7 @@ TEST_P(JSITest, UTF8ExceptionTest) {
   }
 }
 
-TEST_P(JSITest, UTF16Test) {
+TEST_P(JSITest, UTF16ConversionTest) {
   // This Runtime Decorator is used to test the conversion from UTF-8 to UTF-16
   // in the default utf16 method for runtimes that do not provide their own
   // utf16 implementation.
@@ -1601,14 +1601,19 @@ TEST_P(JSITest, UTF16Test) {
   rd.utf8Str = "foobar";
   EXPECT_EQ(str.utf16(rd), u"foobar");
 
-  rd.utf8Str = "你好";
-  EXPECT_EQ(str.utf16(rd), u"你好");
+  // 你 in UTF-8 encoding is 0xe4 0xbd 0xa0 and 好 is 0xe5 0xa5 0xbd
+  // 你 in UTF-16 encoding is 0x4f60 and 好 is 0x597d
+  rd.utf8Str = "\xe4\xbd\xa0\xe5\xa5\xbd";
+  EXPECT_EQ(str.utf16(rd), u"\x4f60\x597d");
 
-  rd.utf8Str = "👍";
-  EXPECT_EQ(str.utf16(rd), u"👍");
+  // 👍 in UTF-8 encoding is 0xf0 0x9f 0x91 0x8d
+  // 👍 in UTF-16 encoding is 0xd83d 0xdc4d
+  rd.utf8Str = "\xf0\x9f\x91\x8d";
+  EXPECT_EQ(str.utf16(rd), u"\xd83d\xdc4d");
 
-  rd.utf8Str = "foobar👍你好";
-  EXPECT_EQ(str.utf16(rd), u"foobar👍你好");
+  // String is foobar👍你好
+  rd.utf8Str = "foobar\xf0\x9f\x91\x8d\xe4\xbd\xa0\xe5\xa5\xbd";
+  EXPECT_EQ(str.utf16(rd), u"foobar\xd83d\xdc4d\x4f60\x597d");
 
   // String ended before second byte of the encoding
   rd.utf8Str = "\xcf";
@@ -1635,6 +1640,50 @@ TEST_P(JSITest, UTF16Test) {
   EXPECT_EQ(str.utf16(rd), u"\uFFFD\u007A");
 }
 
+TEST_P(JSITest, CreateFromUtf16Test) {
+  // This Runtime Decorator is used to test the default createStringFromUtf16
+  // and createPropNameIDFromUtf16 implementation for VMs that do not provide
+  // their own implementation
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    String createStringFromUtf16(const char16_t* utf16, size_t length)
+        override {
+      return Runtime::createStringFromUtf16(utf16, length);
+    }
+
+    PropNameID createPropNameIDFromUtf16(const char16_t* utf16, size_t length)
+        override {
+      return Runtime::createPropNameIDFromUtf16(utf16, length);
+    }
+  };
+
+  RD rd = RD(rt);
+  std::u16string utf16 = u"foobar";
+
+  auto jsString = String::createFromUtf16(rd, utf16);
+  EXPECT_EQ(jsString.utf16(rd), utf16);
+  auto prop = PropNameID::forUtf16(rd, utf16);
+  EXPECT_EQ(prop.utf16(rd), utf16);
+
+  // 👋 in UTF-16 encoding is 0xd83d 0xdc4b
+  utf16 = u"hello!\xd83d\xdc4b";
+  jsString = String::createFromUtf16(rd, utf16.data(), utf16.length());
+  EXPECT_EQ(jsString.utf16(rd), utf16);
+  prop = PropNameID::forUtf16(rd, utf16);
+  EXPECT_EQ(prop.utf16(rd), utf16);
+
+  utf16 = u"\xd83d";
+  jsString = String::createFromUtf16(rd, utf16.data(), utf16.length());
+  /// We need to use charCodeAt instead of UTF16 because the default
+  /// implementation of UTF16 converts to UTF8, then to UTF16, so we will lose
+  /// the lone surrogate value.
+  rd.global().setProperty(rd, "loneSurrogate", jsString);
+  auto cp = eval("loneSurrogate.charCodeAt(0)").getNumber();
+  EXPECT_EQ(cp, 55357); // 0xD83D in decimal
+}
+
 TEST_P(JSITest, GetStringDataTest) {
   // This Runtime Decorator is used to test the default getStringData
   // implementation for VMs that do not provide their own implementation
@@ -1652,7 +1701,8 @@ TEST_P(JSITest, GetStringDataTest) {
   };
 
   RD rd = RD(rt);
-  String str = String::createFromUtf8(rd, "hello👋");
+  // 👋 in UTF8 encoding is 0xf0 0x9f 0x91 0x8b
+  String str = String::createFromUtf8(rd, "hello\xf0\x9f\x91\x8b");
 
   std::u16string buf;
   auto cb = [&buf](bool ascii, const void* data, size_t num) {

package/ReactCommon/jsiexecutor/React-jsiexecutor.podspec

@@ -43,10 +43,10 @@ Pod::Spec.new do |s|
   s.dependency "RCT-Folly", folly_version
   s.dependency "DoubleConversion"
   s.dependency "fast_float", "6.1.4"
-  s.dependency "fmt", "9.1.0"
+  s.dependency "fmt", "11.0.2"
   s.dependency "glog"
   add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
-
+  add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
   if ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == "1"
     s.dependency 'hermes-engine'
   end

package/ReactCommon/jsiexecutor/jsireact/JSINativeModules.cpp

@@ -77,16 +77,16 @@ std::optional<Object> JSINativeModules::createModule(
         ReactMarker::NATIVE_MODULE_SETUP_START, name.c_str());
   }
 
-  if (!m_genNativeModuleJS) {
-    m_genNativeModuleJS =
-        rt.global().getPropertyAsFunction(rt, "__fbGenNativeModule");
-  }
-
   auto result = m_moduleRegistry->getConfig(name);
   if (!result.has_value()) {
     return std::nullopt;
   }
 
+  if (!m_genNativeModuleJS) {
+    m_genNativeModuleJS =
+        rt.global().getPropertyAsFunction(rt, "__fbGenNativeModule");
+  }
+
   Value moduleInfo = m_genNativeModuleJS->call(
       rt,
       valueFromDynamic(rt, result->config),

package/ReactCommon/jsinspector-modern/CMakeLists.txt

@@ -7,7 +7,8 @@ cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
 add_compile_options(
-        $<$<CONFIG:Debug>:-DHERMES_ENABLE_DEBUGGER=1>
+        $<$<CONFIG:Debug>:-DREACT_NATIVE_DEBUGGER_ENABLED=1>
+        $<$<CONFIG:Debug>:-DREACT_NATIVE_DEBUGGER_ENABLED_DEVONLY=1>
         -fexceptions
         -std=c++20)
 

package/ReactCommon/jsinspector-modern/FallbackRuntimeTargetDelegate.cpp

@@ -44,4 +44,18 @@ std::unique_ptr<StackTrace> FallbackRuntimeTargetDelegate::captureStackTrace(
   return std::make_unique<StackTrace>();
 }
 
+void FallbackRuntimeTargetDelegate::enableSamplingProfiler() {
+  // no-op
+};
+
+void FallbackRuntimeTargetDelegate::disableSamplingProfiler() {
+  // no-op
+};
+
+tracing::RuntimeSamplingProfile
+FallbackRuntimeTargetDelegate::collectSamplingProfile() {
+  throw std::logic_error(
+      "Sampling Profiler capabilities are not supported for Runtime fallback");
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/FallbackRuntimeTargetDelegate.h

@@ -40,6 +40,12 @@ class FallbackRuntimeTargetDelegate : public RuntimeTargetDelegate {
       jsi::Runtime& runtime,
       size_t framesToSkip) override;
 
+  void enableSamplingProfiler() override;
+
+  void disableSamplingProfiler() override;
+
+  tracing::RuntimeSamplingProfile collectSamplingProfile() override;
+
  private:
   std::string engineDescription_;
 };

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -144,6 +144,20 @@ void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
 
     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;
+    }
+
+    // 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;
   }
 
   if (!isFinishedHandlingRequest &&
@@ -223,8 +237,11 @@ void HostAgent::sendInfoLogEntry(
 
 void HostAgent::setCurrentInstanceAgent(
     std::shared_ptr<InstanceAgent> instanceAgent) {
+  tracingAgent_.setCurrentInstanceAgent(instanceAgent);
+
   auto previousInstanceAgent = std::move(instanceAgent_);
   instanceAgent_ = std::move(instanceAgent);
+
   if (!sessionState_.isRuntimeDomainEnabled) {
     return;
   }

package/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -238,12 +238,15 @@ namespace {
 
 struct StaticHostTargetMetadata {
   std::optional<bool> isProfilingBuild;
+  std::optional<bool> networkInspectionEnabled;
 };
 
 StaticHostTargetMetadata getStaticHostMetadata() {
   auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
 
-  return {.isProfilingBuild = inspectorFlags.getIsProfilingBuild()};
+  return {
+      .isProfilingBuild = inspectorFlags.getIsProfilingBuild(),
+      .networkInspectionEnabled = inspectorFlags.getNetworkInspectionEnabled()};
 }
 
 } // namespace
@@ -274,6 +277,10 @@ folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata) {
     result["unstable_isProfilingBuild"] =
         staticMetadata.isProfilingBuild.value();
   }
+  if (staticMetadata.networkInspectionEnabled) {
+    result["unstable_networkInspectionEnabled"] =
+        staticMetadata.networkInspectionEnabled.value();
+  }
 
   return result;
 }

package/ReactCommon/jsinspector-modern/InspectorFlags.cpp

@@ -29,6 +29,10 @@ bool InspectorFlags::getIsProfilingBuild() const {
   return loadFlagsAndAssertUnchanged().isProfilingBuild;
 }
 
+bool InspectorFlags::getNetworkInspectionEnabled() const {
+  return loadFlagsAndAssertUnchanged().networkInspectionEnabled;
+}
+
 void InspectorFlags::dangerouslyResetFlags() {
   *this = InspectorFlags{};
 }
@@ -37,33 +41,29 @@ void InspectorFlags::dangerouslyDisableFuseboxForTest() {
   fuseboxDisabledForTest_ = true;
 }
 
-#if defined(REACT_NATIVE_FORCE_ENABLE_FUSEBOX) && \
-    defined(REACT_NATIVE_FORCE_DISABLE_FUSEBOX)
+#if defined(REACT_NATIVE_DEBUGGER_ENABLED) && \
+    defined(REACT_NATIVE_DEBUGGER_FORCE_DISABLE)
 #error \
-    "Cannot define both REACT_NATIVE_FORCE_ENABLE_FUSEBOX and REACT_NATIVE_FORCE_DISABLE_FUSEBOX"
+    "Cannot define both REACT_NATIVE_DEBUGGER_ENABLED and REACT_NATIVE_DEBUGGER_FORCE_DISABLE"
 #endif
 
 const InspectorFlags::Values& InspectorFlags::loadFlagsAndAssertUnchanged()
     const {
   InspectorFlags::Values newValues = {
       .fuseboxEnabled =
-#if defined(REACT_NATIVE_FORCE_ENABLE_FUSEBOX)
-          true,
-#elif defined(REACT_NATIVE_FORCE_DISABLE_FUSEBOX)
-          false,
-#elif defined(HERMES_ENABLE_DEBUGGER)
-          true,
-#elif defined(REACT_NATIVE_ENABLE_FUSEBOX_RELEASE)
+#if defined(REACT_NATIVE_DEBUGGER_ENABLED)
           true,
 #else
           ReactNativeFeatureFlags::fuseboxEnabledRelease(),
 #endif
       .isProfilingBuild =
-#if defined(REACT_NATIVE_ENABLE_FUSEBOX_RELEASE)
+#if defined(REACT_NATIVE_DEBUGGER_MODE_PROD)
           true,
 #else
           false,
 #endif
+      .networkInspectionEnabled =
+          ReactNativeFeatureFlags::fuseboxNetworkInspectionEnabled(),
   };
 
   if (cachedValues_.has_value() && !inconsistentFlagsStateLogged_) {

package/ReactCommon/jsinspector-modern/InspectorFlags.h

@@ -30,6 +30,11 @@ class InspectorFlags {
    */
   bool getIsProfilingBuild() const;
 
+  /**
+   * Flag determining if network inspection is enabled.
+   */
+  bool getNetworkInspectionEnabled() const;
+
   /**
    * Forcibly disable the main `getFuseboxEnabled()` flag. This should ONLY be
    * used by `ReactInstanceIntegrationTest`.
@@ -46,6 +51,7 @@ class InspectorFlags {
   struct Values {
     bool fuseboxEnabled;
     bool isProfilingBuild;
+    bool networkInspectionEnabled;
     bool operator==(const Values&) const = default;
   };
 

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.cpp

@@ -198,7 +198,12 @@ void InspectorPackagerConnection::Impl::didReceiveMessage(
   handleProxyMessage(std::move(parsedJSON));
 }
 
+void InspectorPackagerConnection::Impl::didOpen() {
+  connected_ = true;
+}
+
 void InspectorPackagerConnection::Impl::didClose() {
+  connected_ = false;
   webSocket_.reset();
   closeAllConnections();
   if (!closed_) {
@@ -214,7 +219,7 @@ void InspectorPackagerConnection::Impl::onPageRemoved(int pageId) {
 }
 
 bool InspectorPackagerConnection::Impl::isConnected() const {
-  return webSocket_ != nullptr;
+  return webSocket_ != nullptr && connected_;
 }
 
 void InspectorPackagerConnection::Impl::connect() {
@@ -241,6 +246,10 @@ void InspectorPackagerConnection::Impl::reconnect() {
     suppressConnectionErrors_ = true;
   }
 
+  if (isConnected()) {
+    return;
+  }
+
   reconnectPending_ = true;
 
   delegate_->scheduleCallback(
@@ -248,6 +257,11 @@ void InspectorPackagerConnection::Impl::reconnect() {
         auto strongSelf = weakSelf.lock();
         if (strongSelf && !strongSelf->closed_) {
           strongSelf->reconnectPending_ = false;
+
+          if (strongSelf->isConnected()) {
+            return;
+          }
+
           strongSelf->connect();
 
           if (!strongSelf->isConnected()) {

package/ReactCommon/jsinspector-modern/InspectorPackagerConnectionImpl.h

@@ -87,6 +87,7 @@ class InspectorPackagerConnection::Impl
   virtual void didFailWithError(std::optional<int> posixCode, std::string error)
       override;
   virtual void didReceiveMessage(std::string_view message) override;
+  virtual void didOpen() override;
   virtual void didClose() override;
 
   // IPageStatusListener methods
@@ -99,6 +100,7 @@ class InspectorPackagerConnection::Impl
 
   std::unordered_map<std::string, Session> inspectorSessions_;
   std::unique_ptr<IWebSocket> webSocket_;
+  bool connected_{false};
   bool closed_{false};
   bool suppressConnectionErrors_{false};
 

package/ReactCommon/jsinspector-modern/InstanceAgent.cpp

@@ -152,4 +152,24 @@ void InstanceAgent::maybeSendPendingConsoleMessages() {
   }
 }
 
+void InstanceAgent::startTracing() {
+  if (runtimeAgent_) {
+    runtimeAgent_->registerForTracing();
+    runtimeAgent_->enableSamplingProfiler();
+  }
+}
+
+void InstanceAgent::stopTracing() {
+  if (runtimeAgent_) {
+    runtimeAgent_->disableSamplingProfiler();
+  }
+}
+
+tracing::InstanceTracingProfile InstanceAgent::collectTracingProfile() {
+  tracing::RuntimeSamplingProfile runtimeSamplingProfile =
+      runtimeAgent_->collectSamplingProfile();
+
+  return tracing::InstanceTracingProfile{runtimeSamplingProfile};
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceAgent.h

@@ -12,14 +12,14 @@
 #include "SessionState.h"
 
 #include <jsinspector-modern/InspectorInterfaces.h>
+#include <jsinspector-modern/InstanceTarget.h>
 #include <jsinspector-modern/RuntimeAgent.h>
+#include <jsinspector-modern/tracing/InstanceTracingProfile.h>
 
 #include <functional>
 
 namespace facebook::react::jsinspector_modern {
 
-class InstanceTarget;
-
 /**
  * An Agent that handles requests from the Chrome DevTools Protocol for the
  * given InstanceTarget.
@@ -59,6 +59,23 @@ class InstanceAgent final {
    */
   void sendConsoleMessage(SimpleConsoleMessage message);
 
+  /**
+   * Notify Instance about started Tracing session. Should be initiated by
+   * TracingAgent on Tracing.start CDP method.
+   */
+  void startTracing();
+
+  /**
+   * Notify Instance about stopped Tracing session. Should be initiated by
+   * TracingAgent on Tracing.end CDP method.
+   */
+  void stopTracing();
+
+  /**
+   * Return recorded profile for the previous tracing session.
+   */
+  tracing::InstanceTracingProfile collectTracingProfile();
+
  private:
   void maybeSendExecutionContextCreatedNotification();
   void sendConsoleMessageImmediately(SimpleConsoleMessage message);

package/ReactCommon/jsinspector-modern/NetworkIOAgent.cpp

@@ -6,10 +6,13 @@
  */
 
 #include "NetworkIOAgent.h"
-#include <utility>
+#include "InspectorFlags.h"
+
 #include "Base64.h"
 #include "Utf8.h"
 
+#include <utility>
+
 namespace facebook::react::jsinspector_modern {
 
 static constexpr long DEFAULT_BYTES_PER_READ =
@@ -27,7 +30,7 @@ static constexpr std::array kTextMIMETypePrefixes{
 namespace {
 
 struct InitStreamResult {
-  int httpStatusCode;
+  uint32_t httpStatusCode;
   Headers headers;
   std::shared_ptr<Stream> stream;
 };
@@ -113,7 +116,7 @@ class Stream : public NetworkRequestListener,
     processPending();
   }
 
-  void onHeaders(int httpStatusCode, const Headers& headers) override {
+  void onHeaders(uint32_t httpStatusCode, const Headers& headers) override {
     // Find content-type through case-insensitive search of headers.
     for (const auto& [name, value] : headers) {
       std::string lowerName = name;
@@ -262,6 +265,14 @@ bool NetworkIOAgent::handleRequest(
     handleIoClose(req);
     return true;
   }
+
+  if (InspectorFlags::getInstance().getNetworkInspectionEnabled()) {
+    if (req.method == "Network.enable") {
+      frontendChannel_(cdp::jsonResult(req.id));
+      return true;
+    }
+  }
+
   return false;
 }
 

package/ReactCommon/jsinspector-modern/NetworkIOAgent.h

@@ -43,7 +43,7 @@ struct ReadStreamParams {
 struct NetworkResource {
   bool success{};
   std::optional<std::string> stream;
-  std::optional<int> httpStatusCode;
+  std::optional<uint32_t> httpStatusCode;
   std::optional<std::string> netErrorName;
   std::optional<Headers> headers;
   folly::dynamic toDynamic() const {
@@ -111,7 +111,7 @@ class NetworkRequestListener {
    * \param httpStatusCode The HTTP status code received.
    * \param headers Response headers as an unordered_map.
    */
-  virtual void onHeaders(int httpStatusCode, const Headers& headers) = 0;
+  virtual void onHeaders(uint32_t httpStatusCode, const Headers& headers) = 0;
 
   /**
    * To be called by the delegate on receipt of data chunks.

package/ReactCommon/jsinspector-modern/RuntimeAgent.cpp

@@ -149,4 +149,20 @@ RuntimeAgent::~RuntimeAgent() {
   sessionState_.lastRuntimeAgentExportedState = getExportedState();
 }
 
+void RuntimeAgent::registerForTracing() {
+  targetController_.registerForTracing();
+}
+
+void RuntimeAgent::enableSamplingProfiler() {
+  targetController_.enableSamplingProfiler();
+}
+
+void RuntimeAgent::disableSamplingProfiler() {
+  targetController_.disableSamplingProfiler();
+}
+
+tracing::RuntimeSamplingProfile RuntimeAgent::collectSamplingProfile() {
+  return targetController_.collectSamplingProfile();
+}
+
 } // namespace facebook::react::jsinspector_modern