react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactCommon/jserrorhandler/JsErrorHandler.h

@@ -32,12 +32,23 @@ class JsErrorHandler {
   explicit JsErrorHandler(OnJsError onJsError);
   ~JsErrorHandler();
 
-  void handleFatalError(const jsi::JSError& error);
+  void handleFatalError(jsi::Runtime& runtime, jsi::JSError& error);
   bool hasHandledFatalError();
+  void setRuntimeReady();
+  bool isRuntimeReady();
+  void notifyOfFatalError();
 
  private:
+  /**
+   * This callback:
+   * 1. Shouldn't retain the ReactInstance. So that we don't get retain cycles.
+   * 2. Should be implemented by something that can outlive the react instance
+   *    (both before init and after teardown). So that errors during init and
+   *    teardown get reported properly.
+   **/
   OnJsError _onJsError;
   bool _hasHandledFatalError;
+  bool _isRuntimeReady{};
 };
 
 } // namespace facebook::react

package/ReactCommon/jserrorhandler/React-jserrorhandler.podspec

@@ -47,6 +47,12 @@ Pod::Spec.new do |s|
 
   s.dependency folly_dep_name, folly_version
   s.dependency "React-jsi"
+  s.dependency "React-cxxreact"
+  s.dependency "glog"
   add_dependency(s, "React-debug")
+  
+  if ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == "1"
+    s.dependency 'hermes-engine'
+  end
 
 end

package/ReactCommon/jsi/jsi/decorator.h

@@ -412,12 +412,16 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
     plain().instrumentation().stopHeapSampling(os);
   }
 
-  void createSnapshotToFile(const std::string& path) override {
-    plain().instrumentation().createSnapshotToFile(path);
+  void createSnapshotToFile(
+      const std::string& path,
+      const HeapSnapshotOptions& options) override {
+    plain().instrumentation().createSnapshotToFile(path, options);
   }
 
-  void createSnapshotToStream(std::ostream& os) override {
-    plain().instrumentation().createSnapshotToStream(os);
+  void createSnapshotToStream(
+      std::ostream& os,
+      const HeapSnapshotOptions& options) override {
+    plain().instrumentation().createSnapshotToStream(os, options);
   }
 
   std::string flushAndDisableBridgeTrafficTrace() override {
@@ -582,6 +586,10 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::cloneSymbol(pv);
   };
+  Runtime::PointerValue* cloneBigInt(const Runtime::PointerValue* pv) override {
+    Around around{with_};
+    return RD::cloneBigInt(pv);
+  };
   Runtime::PointerValue* cloneString(const Runtime::PointerValue* pv) override {
     Around around{with_};
     return RD::cloneString(pv);
@@ -610,6 +618,10 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::createPropNameIDFromString(str);
   };
+  PropNameID createPropNameIDFromSymbol(const Symbol& sym) override {
+    Around around{with_};
+    return RD::createPropNameIDFromSymbol(sym);
+  };
   std::string utf8(const PropNameID& id) override {
     Around around{with_};
     return RD::utf8(id);
@@ -624,6 +636,31 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     return RD::symbolToString(sym);
   };
 
+  BigInt createBigIntFromInt64(int64_t i) override {
+    Around around{with_};
+    return RD::createBigIntFromInt64(i);
+  };
+  BigInt createBigIntFromUint64(uint64_t i) override {
+    Around around{with_};
+    return RD::createBigIntFromUint64(i);
+  };
+  bool bigintIsInt64(const BigInt& bi) override {
+    Around around{with_};
+    return RD::bigintIsInt64(bi);
+  };
+  bool bigintIsUint64(const BigInt& bi) override {
+    Around around{with_};
+    return RD::bigintIsUint64(bi);
+  };
+  uint64_t truncate(const BigInt& bi) override {
+    Around around{with_};
+    return RD::truncate(bi);
+  };
+  String bigintToString(const BigInt& bi, int i) override {
+    Around around{with_};
+    return RD::bigintToString(bi, i);
+  };
+
   String createStringFromAscii(const char* str, size_t length) override {
     Around around{with_};
     return RD::createStringFromAscii(str, length);
@@ -637,6 +674,11 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     return RD::utf8(s);
   }
 
+  Value createValueFromJsonUtf8(const uint8_t* json, size_t length) override {
+    Around around{with_};
+    return RD::createValueFromJsonUtf8(json, length);
+  };
+
   Object createObject() override {
     Around around{with_};
     return RD::createObject();
@@ -797,6 +839,11 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::strictEquals(a, b);
   };
+  bool strictEquals(const BigInt& a, const BigInt& b) const override {
+    Around around{with_};
+    return RD::strictEquals(a, b);
+  };
+
   bool strictEquals(const String& a, const String& b) const override {
     Around around{with_};
     return RD::strictEquals(a, b);
@@ -811,6 +858,12 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     return RD::instanceOf(o, f);
   };
 
+  void setExternalMemoryPressure(const jsi::Object& obj, size_t amount)
+      override {
+    Around around{with_};
+    RD::setExternalMemoryPressure(obj, amount);
+  };
+
  private:
   // Wrap an RAII type around With& to guarantee after always happens.
   struct Around {

package/ReactCommon/jsi/jsi/instrumentation.h

@@ -25,6 +25,12 @@ namespace jsi {
 /// it modify the values of any jsi values in the heap (although GCs are fine).
 class JSI_EXPORT Instrumentation {
  public:
+  /// Additional options controlling what to include when capturing a heap
+  /// snapshot.
+  struct HeapSnapshotOptions {
+    bool captureNumericValue{false};
+  };
+
   virtual ~Instrumentation() = default;
 
   /// Returns GC statistics as a JSON-encoded string, with an object containing
@@ -91,13 +97,19 @@ class JSI_EXPORT Instrumentation {
 
   /// Captures the heap to a file
   ///
-  /// \param path to save the heap capture
-  virtual void createSnapshotToFile(const std::string& path) = 0;
+  /// \param path to save the heap capture.
+  /// \param options additional options for what to capture.
+  virtual void createSnapshotToFile(
+      const std::string& path,
+      const HeapSnapshotOptions& options = {false}) = 0;
 
   /// Captures the heap to an output stream
   ///
   /// \param os output stream to write to.
-  virtual void createSnapshotToStream(std::ostream& os) = 0;
+  /// \param options additional options for what to capture.
+  virtual void createSnapshotToStream(
+      std::ostream& os,
+      const HeapSnapshotOptions& options = {false}) = 0;
 
   /// If the runtime has been created to trace to a temp file, flush
   /// any unwritten parts of the trace of bridge traffic to the file,

package/ReactCommon/jsi/jsi/jsi.cpp

@@ -109,12 +109,16 @@ Instrumentation& Runtime::instrumentation() {
     void startHeapSampling(size_t) override {}
     void stopHeapSampling(std::ostream&) override {}
 
-    void createSnapshotToFile(const std::string&) override {
+    void createSnapshotToFile(
+        const std::string& /*path*/,
+        const HeapSnapshotOptions& /*options*/) override {
       throw JSINativeException(
           "Default instrumentation cannot create a heap snapshot");
     }
 
-    void createSnapshotToStream(std::ostream&) override {
+    void createSnapshotToStream(
+        std::ostream& /*os*/,
+        const HeapSnapshotOptions& /*options*/) override {
       throw JSINativeException(
           "Default instrumentation cannot create a heap snapshot");
     }

package/ReactCommon/jsiexecutor/CMakeLists.txt

@@ -13,7 +13,7 @@ add_compile_options(
         -O3)
 
 add_library(jsireact
-        STATIC
+        OBJECT
         jsireact/JSIExecutor.cpp
         jsireact/JSINativeModules.cpp)
 

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -139,8 +139,11 @@ void JSIExecutor::initializeRuntime() {
   if (runtimeInstaller_) {
     runtimeInstaller_(*runtime_);
   }
-
-  bool hasLogger(ReactMarker::logTaggedMarkerImpl);
+  bool hasLogger = false;
+  {
+    std::shared_lock lock(ReactMarker::logTaggedMarkerImplMutex);
+    hasLogger = ReactMarker::logTaggedMarkerImpl != nullptr;
+  }
   if (hasLogger) {
     ReactMarker::logMarker(ReactMarker::CREATE_REACT_CONTEXT_STOP);
   }
@@ -150,8 +153,11 @@ void JSIExecutor::loadBundle(
     std::unique_ptr<const JSBigString> script,
     std::string sourceURL) {
   SystraceSection s("JSIExecutor::loadBundle");
-
-  bool hasLogger(ReactMarker::logTaggedMarkerImpl);
+  bool hasLogger = false;
+  {
+    std::shared_lock lock(ReactMarker::logTaggedMarkerImplMutex);
+    hasLogger = ReactMarker::logTaggedMarkerImpl != nullptr;
+  }
   std::string scriptName = simpleBasename(sourceURL);
   if (hasLogger) {
     ReactMarker::logTaggedMarker(

package/ReactCommon/jsiexecutor/jsireact/JSINativeModules.cpp

@@ -67,7 +67,11 @@ void JSINativeModules::reset() {
 std::optional<Object> JSINativeModules::createModule(
     Runtime& rt,
     const std::string& name) {
-  bool hasLogger(ReactMarker::logTaggedMarkerImpl);
+  bool hasLogger = false;
+  {
+    std::shared_lock lock(ReactMarker::logTaggedMarkerImplMutex);
+    hasLogger = ReactMarker::logTaggedMarkerImpl != nullptr;
+  }
   if (hasLogger) {
     ReactMarker::logTaggedMarker(
         ReactMarker::NATIVE_MODULE_SETUP_START, name.c_str());

package/ReactCommon/jsinspector-modern/Base64.h

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <string>
+#include <string_view>
+
+namespace facebook::react::jsinspector_modern {
+
+namespace {
+// Vendored from Folly
+// https://github.com/facebook/folly/blob/v2024.07.08.00/folly/detail/base64_detail/Base64Scalar.h
+constexpr char kBase64Charset[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+constexpr char kBase64URLCharset[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+template <bool isURL>
+struct Base64ScalarImpl {
+  static constexpr const char* kCharset =
+      isURL ? kBase64URLCharset : kBase64Charset;
+
+  // 0, 1 or 2 bytes
+  static constexpr char* encodeTail(const char* f, const char* l, char* o) {
+    if (f == l) {
+      return o;
+    }
+
+    std::uint8_t aaab = f[0];
+    std::uint8_t aaa = aaab >> 2;
+    *o++ = kCharset[aaa];
+
+    // duplicating some tail handling to try to do less jumps
+    if (l - f == 1) {
+      std::uint8_t b00 = aaab << 4 & 0x3f;
+      *o++ = kCharset[b00];
+      if constexpr (!isURL) {
+        *o++ = '=';
+        *o++ = '=';
+      }
+      return o;
+    }
+
+    // l - f == 2
+    std::uint8_t bbcc = f[1];
+    std::uint8_t bbb = ((aaab << 4) | (bbcc >> 4)) & 0x3f;
+    std::uint8_t cc0 = (bbcc << 2) & 0x3f;
+    *o++ = kCharset[bbb];
+    *o++ = kCharset[cc0];
+    if constexpr (!isURL) {
+      *o++ = '=';
+    }
+    return o;
+  }
+
+  static constexpr char* encode(const char* f, const char* l, char* o) {
+    while ((l - f) >= 3) {
+      std::uint8_t aaab = f[0];
+      std::uint8_t bbcc = f[1];
+      std::uint8_t cddd = f[2];
+
+      std::uint8_t aaa = aaab >> 2;
+      std::uint8_t bbb = ((aaab << 4) | (bbcc >> 4)) & 0x3f;
+      std::uint8_t ccc = ((bbcc << 2) | (cddd >> 6)) & 0x3f;
+      std::uint8_t ddd = cddd & 0x3f;
+
+      o[0] = kCharset[aaa];
+      o[1] = kCharset[bbb];
+      o[2] = kCharset[ccc];
+      o[3] = kCharset[ddd];
+
+      f += 3;
+      o += 4;
+    }
+
+    return encodeTail(f, l, o);
+  }
+};
+
+// https://github.com/facebook/folly/blob/v2024.07.08.00/folly/detail/base64_detail/Base64Common.h#L24
+constexpr std::size_t base64EncodedSize(std::size_t inSize) {
+  return ((inSize + 2) / 3) * 4;
+}
+} // namespace
+
+inline std::string base64Encode(const std::string_view s) {
+  std::string res(base64EncodedSize(s.size()), '\0');
+  Base64ScalarImpl<false>::encode(s.data(), s.data() + s.size(), res.data());
+  return res;
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/CMakeLists.txt

@@ -7,14 +7,18 @@ cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
 add_compile_options(
+        $<$<CONFIG:Debug>:-DHERMES_ENABLE_DEBUGGER=1>
         -fexceptions
         -std=c++20)
 
+include(${REACT_ANDROID_DIR}/src/main/jni/first-party/jni-lib-merge/SoMerging-utils.cmake)
+
 file(GLOB jsinspector_SRC CONFIGURE_DEPENDS *.cpp)
 # jsinspector contains singletons that hold app-global state (InspectorFlags, InspectorImpl).
 # Placing it in a shared library makes the singletons safe to use from arbitrary shared libraries
 # (even ones that don't depend on one another).
-add_library(jsinspector SHARED ${jsinspector_SRC})
+add_library(jsinspector OBJECT ${jsinspector_SRC})
+target_merge_so(jsinspector)
 
 target_include_directories(jsinspector PUBLIC ${REACT_COMMON_DIR})
 
@@ -23,4 +27,5 @@ target_link_libraries(jsinspector
         glog
         react_featureflags
         runtimeexecutor
+        reactperflogger
 )

package/ReactCommon/jsinspector-modern/CdpJson.h

@@ -85,7 +85,7 @@ using ParseError = folly::json::parse_error;
 /**
  * Returns a JSON-formatted string representing an error.
  *
- * {"id": <id>, "error": { "code": <code>, "message": <message> }}
+ * {"id": <id>, "error": { "code": <cdp error code>, "message": <message> }}
  *
  * \param id Request ID. Mandatory, null only if the request omitted it or
  *           could not be parsed.

package/ReactCommon/jsinspector-modern/ExecutionContext.cpp

@@ -11,8 +11,11 @@ namespace facebook::react::jsinspector_modern {
 
 namespace {
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-const-variable"
 template <class>
 inline constexpr bool always_false_v = false;
+#pragma clang diagnostic pop
 
 } // namespace
 
@@ -34,10 +37,6 @@ bool ExecutionContextSelector::matches(
         }
       },
       value_);
-
-  // Prevent the compiler from thinking always_false_v is unused when the
-  // visitor is (correctly) exhaustive.
-  (void)always_false_v<void>;
 }
 
 ExecutionContextSelector ExecutionContextSelector::byId(int32_t id) {

package/ReactCommon/jsinspector-modern/FallbackRuntimeAgentDelegate.h

@@ -51,11 +51,11 @@ class FallbackRuntimeAgentDelegate : public RuntimeAgentDelegate {
   void sendFallbackRuntimeWarning();
 
   /**
-   * Send a simple Log.entryAdded notification with the given
-   * \param text. You must ensure that the frontend has enabled Log
-   * notifications (using Log.enable) prior to calling this function. In Chrome
-   * DevTools, the message will appear in the Console tab along with regular
-   * console messages.
+   * Send a simple Log.entryAdded notification with the given text.
+   * You must ensure that the frontend has enabled Log notifications (using
+   * Log.enable) prior to calling this function. In Chrome DevTools, the message
+   * will appear in the Console tab along with regular console messages.
+   * \param text The text to send.
    */
   void sendWarningLogEntry(std::string_view text);
 

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -15,6 +15,8 @@
 
 #include <chrono>
 
+#include <reactperflogger/fusebox/FuseboxTracer.h>
+
 using namespace std::chrono;
 using namespace std::literals::string_view_literals;
 
@@ -28,11 +30,13 @@ HostAgent::HostAgent(
     FrontendChannel frontendChannel,
     HostTargetController& targetController,
     HostTargetMetadata hostMetadata,
-    SessionState& sessionState)
+    SessionState& sessionState,
+    VoidExecutor executor)
     : frontendChannel_(frontendChannel),
       targetController_(targetController),
       hostMetadata_(std::move(hostMetadata)),
-      sessionState_(sessionState) {}
+      sessionState_(sessionState),
+      networkIOAgent_(NetworkIOAgent(frontendChannel, executor)) {}
 
 void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
   bool shouldSendOKResponse = false;
@@ -146,27 +150,49 @@ void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
     shouldSendOKResponse = true;
     isFinishedHandlingRequest = true;
   } else if (req.method == "Tracing.start") {
-    // @cdp Tracing.start is implemented as a stub only.
-    frontendChannel_(cdp::jsonNotification(
-        // @cdp Tracing.bufferUsage is implemented as a stub only.
-        "Tracing.bufferUsage",
-        folly::dynamic::object("percentFull", 0)("eventCount", 0)("value", 0)));
-    shouldSendOKResponse = true;
+    // @cdp Tracing.start support is experimental.
+    if (FuseboxTracer::getFuseboxTracer().startTracing()) {
+      shouldSendOKResponse = true;
+    } else {
+      frontendChannel_(cdp::jsonError(
+          req.id,
+          cdp::ErrorCode::InternalError,
+          "Tracing session already started"));
+      return;
+    }
     isFinishedHandlingRequest = true;
   } else if (req.method == "Tracing.end") {
-    // @cdp Tracing.end is implemented as a stub only.
-    frontendChannel_(cdp::jsonNotification(
-        // @cdp Tracing.dataCollected is implemented as a stub only.
-        "Tracing.dataCollected",
-        folly::dynamic::object("value", folly::dynamic::array())));
+    // @cdp Tracing.end support is experimental.
+    bool firstChunk = true;
+    auto id = req.id;
+    bool wasStopped = FuseboxTracer::getFuseboxTracer().stopTracing(
+        [this, firstChunk, id](const folly::dynamic& eventsChunk) {
+          if (firstChunk) {
+            frontendChannel_(cdp::jsonResult(id));
+          }
+          frontendChannel_(cdp::jsonNotification(
+              "Tracing.dataCollected",
+              folly::dynamic::object("value", eventsChunk)));
+        });
+    if (!wasStopped) {
+      frontendChannel_(cdp::jsonError(
+          req.id,
+          cdp::ErrorCode::InternalError,
+          "Tracing session not started"));
+      return;
+    }
     frontendChannel_(cdp::jsonNotification(
-        // @cdp Tracing.tracingComplete is implemented as a stub only.
         "Tracing.tracingComplete",
         folly::dynamic::object("dataLossOccurred", false)));
     shouldSendOKResponse = true;
     isFinishedHandlingRequest = true;
   }
 
+  if (!isFinishedHandlingRequest &&
+      networkIOAgent_.handleRequest(req, targetController_.getDelegate())) {
+    return;
+  }
+
   if (!isFinishedHandlingRequest && instanceAgent_ &&
       instanceAgent_->handleRequest(req)) {
     return;
@@ -177,10 +203,7 @@ void HostAgent::handleRequest(const cdp::PreparsedRequest& req) {
     return;
   }
 
-  frontendChannel_(cdp::jsonError(
-      req.id,
-      cdp::ErrorCode::MethodNotFound,
-      req.method + " not implemented yet"));
+  throw NotImplementedException(req.method);
 }
 
 HostAgent::~HostAgent() {
@@ -198,9 +221,9 @@ HostAgent::~HostAgent() {
 }
 
 void HostAgent::sendFuseboxNotice() {
-  static constexpr auto kFuseboxNotice = ANSI_COLOR_BG_YELLOW
-      "Welcome to " ANSI_WEIGHT_BOLD "React Native DevTools" ANSI_WEIGHT_RESET
-      " (experimental)"sv;
+  static constexpr auto kFuseboxNotice =
+      ANSI_COLOR_BG_YELLOW "Welcome to " ANSI_WEIGHT_BOLD
+                           "React Native DevTools" ANSI_WEIGHT_RESET ""sv;
 
   sendInfoLogEntry(kFuseboxNotice);
 }
@@ -210,7 +233,7 @@ void HostAgent::sendNonFuseboxNotice() {
       ANSI_COLOR_BG_YELLOW ANSI_WEIGHT_BOLD
       "NOTE: " ANSI_WEIGHT_RESET
       "You are using an unsupported debugging client. "
-      "Use the Dev Menu in your app (or type `j` in the Metro terminal) to open the latest, supported React Native debugger."sv;
+      "Use the Dev Menu in your app (or type `j` in the Metro terminal) to open React Native DevTools."sv;
 
   std::vector<std::string> args;
   args.emplace_back(kNonFuseboxNotice);

package/ReactCommon/jsinspector-modern/HostAgent.h

@@ -7,7 +7,9 @@
 
 #pragma once
 
+#include "CdpJson.h"
 #include "HostTarget.h"
+#include "NetworkIOAgent.h"
 #include "SessionState.h"
 
 #include <jsinspector-modern/InspectorInterfaces.h>
@@ -39,12 +41,14 @@ class HostAgent final {
    * HostTargetDelegate and underlying HostTarget both outlive the agent.
    * \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.
    */
   HostAgent(
       FrontendChannel frontendChannel,
       HostTargetController& targetController,
       HostTargetMetadata hostMetadata,
-      SessionState& sessionState);
+      SessionState& sessionState,
+      VoidExecutor executor);
 
   HostAgent(const HostAgent&) = delete;
   HostAgent(HostAgent&&) = delete;
@@ -104,6 +108,8 @@ class HostAgent final {
    * during handleRequest and other method calls on the same thread.
    */
   SessionState& sessionState_;
+
+  NetworkIOAgent networkIOAgent_;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -29,7 +29,8 @@ class HostTargetSession {
   explicit HostTargetSession(
       std::unique_ptr<IRemoteConnection> remote,
       HostTargetController& targetController,
-      HostTargetMetadata hostMetadata)
+      HostTargetMetadata hostMetadata,
+      VoidExecutor executor)
       : remote_(std::make_shared<RAIIRemoteConnection>(std::move(remote))),
         frontendChannel_(
             [remoteWeak = std::weak_ptr(remote_)](std::string_view message) {
@@ -41,7 +42,8 @@ class HostTargetSession {
             frontendChannel_,
             targetController,
             std::move(hostMetadata),
-            state_) {}
+            state_,
+            executor) {}
 
   /**
    * Called by CallbackLocalConnection to send a message to this Session's
@@ -62,15 +64,22 @@ class HostTargetSession {
       return;
     }
 
-    // Catch exceptions that may arise from accessing dynamic params during
-    // request handling.
     try {
       hostAgent_.handleRequest(request);
-    } catch (const cdp::TypeError& e) {
+    }
+    // Catch exceptions that may arise from accessing dynamic params during
+    // request handling.
+    catch (const cdp::TypeError& e) {
       frontendChannel_(
           cdp::jsonError(request.id, cdp::ErrorCode::InvalidRequest, e.what()));
       return;
     }
+    // Catch exceptions for unrecognised or partially implemented CDP methods.
+    catch (const NotImplementedException& e) {
+      frontendChannel_(
+          cdp::jsonError(request.id, cdp::ErrorCode::MethodNotFound, e.what()));
+      return;
+    }
   }
 
   /**
@@ -148,7 +157,10 @@ HostTarget::HostTarget(HostTargetDelegate& delegate)
 std::unique_ptr<ILocalConnection> HostTarget::connect(
     std::unique_ptr<IRemoteConnection> connectionToFrontend) {
   auto session = std::make_shared<HostTargetSession>(
-      std::move(connectionToFrontend), controller_, delegate_.getMetadata());
+      std::move(connectionToFrontend),
+      controller_,
+      delegate_.getMetadata(),
+      makeVoidExecutor(executorFromThis()));
   session->setCurrentInstance(currentInstance_.get());
   sessions_.insert(std::weak_ptr(session));
   return std::make_unique<CallbackLocalConnection>(
@@ -223,7 +235,24 @@ bool HostTargetController::decrementPauseOverlayCounter() {
 folly::dynamic hostMetadataToDynamic(const HostTargetMetadata& metadata) {
   folly::dynamic result = folly::dynamic::object;
 
-  result["integrationName"] = metadata.integrationName.value_or(nullptr);
+  if (metadata.appDisplayName) {
+    result["appDisplayName"] = metadata.appDisplayName.value();
+  }
+  if (metadata.appIdentifier) {
+    result["appIdentifier"] = metadata.appIdentifier.value();
+  }
+  if (metadata.deviceName) {
+    result["deviceName"] = metadata.deviceName.value();
+  }
+  if (metadata.integrationName) {
+    result["integrationName"] = metadata.integrationName.value();
+  }
+  if (metadata.platform) {
+    result["platform"] = metadata.platform.value();
+  }
+  if (metadata.reactNativeVersion) {
+    result["reactNativeVersion"] = metadata.reactNativeVersion.value();
+  }
 
   return result;
 }