react-native-tvos 0.74.3-0 → 0.75.2-0

package/ReactCommon/jsinspector-modern/HostTarget.h

@@ -0,0 +1,256 @@
+/*
+ * 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 "ExecutionContextManager.h"
+#include "HostCommand.h"
+#include "InspectorInterfaces.h"
+#include "InstanceTarget.h"
+#include "ScopedExecutor.h"
+#include "WeakList.h"
+
+#include <optional>
+#include <string>
+
+#ifndef JSINSPECTOR_EXPORT
+#ifdef _MSC_VER
+#ifdef CREATE_SHARED_LIBRARY
+#define JSINSPECTOR_EXPORT __declspec(dllexport)
+#else
+#define JSINSPECTOR_EXPORT
+#endif // CREATE_SHARED_LIBRARY
+#else // _MSC_VER
+#define JSINSPECTOR_EXPORT __attribute__((visibility("default")))
+#endif // _MSC_VER
+#endif // !defined(JSINSPECTOR_EXPORT)
+
+namespace facebook::react::jsinspector_modern {
+
+class HostTargetSession;
+class HostAgent;
+class HostCommandSender;
+class HostTarget;
+
+struct HostTargetMetadata {
+  std::optional<std::string> integrationName;
+};
+
+/**
+ * Receives events from a HostTarget. This is a shared interface that each
+ * React Native platform needs to implement in order to integrate with the
+ * debugging stack.
+ */
+class HostTargetDelegate {
+ public:
+  HostTargetDelegate() = default;
+  HostTargetDelegate(const HostTargetDelegate&) = delete;
+  HostTargetDelegate(HostTargetDelegate&&) = default;
+  HostTargetDelegate& operator=(const HostTargetDelegate&) = delete;
+  HostTargetDelegate& operator=(HostTargetDelegate&&) = default;
+
+  // TODO(moti): This is 1:1 the shape of the corresponding CDP message -
+  // consider reusing typed/generated CDP interfaces when we have those.
+  struct PageReloadRequest {
+    // It isn't clear what the ignoreCache parameter of @cdp Page.reload should
+    // mean in React Native. We parse it, but don't do anything with it yet.
+    std::optional<bool> ignoreCache;
+
+    // TODO: Implement scriptToEvaluateOnLoad parameter of @cdp Page.reload.
+    std::optional<std::string> scriptToEvaluateOnLoad;
+
+    /**
+     * Equality operator, useful for unit tests
+     */
+    inline bool operator==(const PageReloadRequest& rhs) const {
+      return ignoreCache == rhs.ignoreCache &&
+          scriptToEvaluateOnLoad == rhs.scriptToEvaluateOnLoad;
+    }
+  };
+
+  struct OverlaySetPausedInDebuggerMessageRequest {
+    /**
+     * The message to display in the overlay. If nullopt, hide the overlay.
+     */
+    std::optional<std::string> message;
+
+    /**
+     * Equality operator, useful for unit tests
+     */
+    inline bool operator==(
+        const OverlaySetPausedInDebuggerMessageRequest& rhs) const {
+      return message == rhs.message;
+    }
+  };
+
+  virtual ~HostTargetDelegate();
+
+  /**
+   * Returns a metadata object describing the host.
+   */
+  virtual HostTargetMetadata getMetadata() = 0;
+
+  /**
+   * Called when the debugger requests a reload of the page. This is called on
+   * the thread on which messages are dispatched to the session (that is, where
+   * ILocalConnection::sendMessage was called).
+   */
+  virtual void onReload(const PageReloadRequest& request) = 0;
+
+  /**
+   * Called when the debugger requests that the "paused in debugger" overlay be
+   * shown or hidden. If the message is nullopt, hide the overlay, otherwise
+   * show it with the given message. This is called on the inspector thread.
+   *
+   * If this method is called with a non-null message, it's guaranteed to
+   * eventually be called again with a null message. In all other respects,
+   * the timing and payload of these messages are fully controlled by the
+   * client.
+   */
+  virtual void onSetPausedInDebuggerMessage(
+      const OverlaySetPausedInDebuggerMessageRequest& request) = 0;
+};
+
+/**
+ * The limited interface that HostTarget exposes to its associated
+ * sessions/agents.
+ */
+class HostTargetController final {
+ public:
+  explicit HostTargetController(HostTarget& target);
+
+  HostTargetDelegate& getDelegate();
+
+  bool hasInstance() const;
+
+  /**
+   * Increments the target's pause overlay counter. The counter represents the
+   * exact number of Agents that have (concurrently) requested the pause
+   * overlay to be shown. It's the caller's responsibility to only call this
+   * when the pause overlay's requested state transitions from hidden to
+   * visible.
+   */
+  void incrementPauseOverlayCounter();
+
+  /**
+   * Decrements the target's pause overlay counter. The counter represents the
+   * exact number of Agents that have (concurrently) requested the pause
+   * overlay to be shown. It's the caller's responsibility to only call this
+   * when the pause overlay's requested state transitions from hidden to
+   * visible.
+   * \returns false if the counter has reached 0, otherwise true.
+   */
+  bool decrementPauseOverlayCounter();
+
+ private:
+  HostTarget& target_;
+  size_t pauseOverlayCounter_{0};
+};
+
+/**
+ * The top-level Target in a React Native app. This is equivalent to the
+ * "Host" in React Native's architecture - the entity that manages the
+ * lifecycle of a React Instance.
+ */
+class JSINSPECTOR_EXPORT HostTarget
+    : public EnableExecutorFromThis<HostTarget> {
+ public:
+  /**
+   * Constructs a new HostTarget.
+   * \param delegate The HostTargetDelegate that will
+   * receive events from this HostTarget. The caller is responsible for ensuring
+   * that the HostTargetDelegate outlives this object.
+   * \param executor An executor that may be used to call methods on this
+   * HostTarget while it exists. \c create additionally guarantees that the
+   * executor will not be called after the HostTarget is destroyed.
+   * \note Copies of the provided executor may be destroyed on arbitrary
+   * threads, including after the HostTarget is destroyed. Callers must ensure
+   * 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;
+  ~HostTarget();
+
+  /**
+   * Creates a new Session connected to this HostTarget, wrapped in an
+   * interface which is compatible with \c IInspector::addPage.
+   * The caller is responsible for destroying the connection before HostTarget
+   * is destroyed, on the same thread where HostTarget's constructor and
+   * destructor execute.
+   */
+  std::unique_ptr<ILocalConnection> connect(
+      std::unique_ptr<IRemoteConnection> connectionToFrontend);
+
+  /**
+   * Registers an instance with this HostTarget.
+   * \param delegate The InstanceTargetDelegate that will receive events from
+   * this InstanceTarget. The caller is responsible for ensuring that the
+   * InstanceTargetDelegate outlives this object.
+   * \return An InstanceTarget reference representing the newly created
+   * instance. This reference is only valid until unregisterInstance is called
+   * (or the HostTarget is destroyed). \pre There isn't currently an instance
+   * registered with this HostTarget.
+   */
+  InstanceTarget& registerInstance(InstanceTargetDelegate& delegate);
+
+  /**
+   * Unregisters an instance from this HostTarget.
+   * \param instance The InstanceTarget reference previously returned by
+   * registerInstance.
+   */
+  void unregisterInstance(InstanceTarget& instance);
+
+  /**
+   * Sends an imperative command to the HostTarget. May be called from any
+   * thread.
+   */
+  void sendCommand(HostCommand command);
+
+ private:
+  /**
+   * Constructs a new HostTarget.
+   * The caller must call setExecutor immediately afterwards.
+   * \param delegate The HostTargetDelegate that will
+   * receive events from this HostTarget. The caller is responsible for ensuring
+   * that the HostTargetDelegate outlives this object.
+   */
+  HostTarget(HostTargetDelegate& delegate);
+
+  HostTargetDelegate& delegate_;
+  WeakList<HostTargetSession> sessions_;
+  HostTargetController controller_{*this};
+  // executionContextManager_ is a shared_ptr to guarantee its validity while
+  // the InstanceTarget is alive (just in case the InstanceTarget ends up
+  // briefly outliving the HostTarget, which it generally shouldn't).
+  std::shared_ptr<ExecutionContextManager> executionContextManager_;
+  std::shared_ptr<InstanceTarget> currentInstance_{nullptr};
+  std::unique_ptr<HostCommandSender> commandSender_;
+
+  inline HostTargetDelegate& getDelegate() {
+    return delegate_;
+  }
+
+  inline bool hasInstance() const {
+    return currentInstance_ != nullptr;
+  }
+
+  // Necessary to allow HostAgent to access HostTarget's internals in a
+  // controlled way (i.e. only HostTargetController gets friend access, while
+  // HostAgent itself doesn't).
+  friend class HostTargetController;
+};
+
+folly::dynamic hostMetadataToDynamic(const HostTargetMetadata& metadata);
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorFlags.cpp

@@ -17,42 +17,40 @@ InspectorFlags& InspectorFlags::getInstance() {
   return instance;
 }
 
-InspectorFlags::InspectorFlags()
-    : enableModernCDPRegistry_(
-          ReactNativeFeatureFlags::inspectorEnableModernCDPRegistry()),
-      enableCxxInspectorPackagerConnection_(
-          ReactNativeFeatureFlags::
-              inspectorEnableCxxInspectorPackagerConnection()) {}
-
-bool InspectorFlags::getEnableModernCDPRegistry() const {
-  assertFlagsMatchUpstream();
-  return enableModernCDPRegistry_;
+bool InspectorFlags::getFuseboxEnabled() const {
+  return loadFlagsAndAssertUnchanged().fuseboxEnabledDebug;
 }
 
-bool InspectorFlags::getEnableCxxInspectorPackagerConnection() const {
-  assertFlagsMatchUpstream();
-  return enableCxxInspectorPackagerConnection_ ||
-      // If we are using the modern CDP registry, then we must also use the C++
-      // InspectorPackagerConnection implementation.
-      enableModernCDPRegistry_;
+void InspectorFlags::dangerouslyResetFlags() {
+  *this = InspectorFlags{};
 }
 
-void InspectorFlags::assertFlagsMatchUpstream() const {
-  if (inconsistentFlagsStateLogged_) {
-    return;
+const InspectorFlags::Values& InspectorFlags::loadFlagsAndAssertUnchanged()
+    const {
+  InspectorFlags::Values newValues = {
+      .fuseboxEnabledDebug =
+#ifdef REACT_NATIVE_FORCE_ENABLE_FUSEBOX
+          true,
+#elif defined(HERMES_ENABLE_DEBUGGER)
+          ReactNativeFeatureFlags::fuseboxEnabledDebug(),
+#else
+          ReactNativeFeatureFlags::fuseboxEnabledRelease(),
+#endif
+  };
+
+  if (cachedValues_.has_value() && !inconsistentFlagsStateLogged_) {
+    if (cachedValues_ != newValues) {
+      LOG(ERROR)
+          << "[InspectorFlags] Error: One or more ReactNativeFeatureFlags values "
+          << "have changed during the global app lifetime. This may lead to "
+          << "inconsistent inspector behaviour. Please quit and restart the app.";
+      inconsistentFlagsStateLogged_ = true;
+    }
   }
 
-  if (enableModernCDPRegistry_ !=
-          ReactNativeFeatureFlags::inspectorEnableModernCDPRegistry() ||
-      enableCxxInspectorPackagerConnection_ !=
-          ReactNativeFeatureFlags::
-              inspectorEnableCxxInspectorPackagerConnection()) {
-    LOG(ERROR)
-        << "[InspectorFlags] Error: One or more ReactNativeFeatureFlags values "
-        << "have changed during the global app lifetime. This may lead to "
-        << "inconsistent inspector behaviour. Please quit and restart the app.";
-    inconsistentFlagsStateLogged_ = true;
-  }
+  cachedValues_ = newValues;
+
+  return cachedValues_.value();
 }
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorFlags.h

@@ -22,25 +22,29 @@ class InspectorFlags {
   /**
    * Flag determining if the modern CDP backend should be enabled.
    */
-  bool getEnableModernCDPRegistry() const;
+  bool getFuseboxEnabled() const;
 
   /**
-   * Flag determining if the C++ implementation of InspectorPackagerConnection
-   * should be used instead of the per-platform one.
+   * Reset flags to their upstream values. The caller must ensure any resources
+   * that have read previous flag values have been cleaned up.
    */
-  bool getEnableCxxInspectorPackagerConnection() const;
+  void dangerouslyResetFlags();
 
  private:
-  InspectorFlags();
+  struct Values {
+    bool fuseboxEnabledDebug;
+    bool operator==(const Values&) const = default;
+  };
+
+  InspectorFlags() = default;
   InspectorFlags(const InspectorFlags&) = delete;
-  InspectorFlags& operator=(const InspectorFlags&) = delete;
+  InspectorFlags& operator=(const InspectorFlags&) = default;
   ~InspectorFlags() = default;
 
-  const bool enableModernCDPRegistry_;
-  const bool enableCxxInspectorPackagerConnection_;
+  mutable std::optional<Values> cachedValues_;
+  mutable bool inconsistentFlagsStateLogged_{false};
 
-  mutable bool inconsistentFlagsStateLogged_;
-  void assertFlagsMatchUpstream() const;
+  const Values& loadFlagsAndAssertUnchanged() const;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorInterfaces.cpp

@@ -28,7 +28,8 @@ const folly::dynamic targetCapabilitiesToDynamic(
     const InspectorTargetCapabilities& capabilities) {
   return folly::dynamic::object(
       "nativePageReloads", capabilities.nativePageReloads)(
-      "nativeSourceCodeFetching", capabilities.nativeSourceCodeFetching);
+      "nativeSourceCodeFetching", capabilities.nativeSourceCodeFetching)(
+      "prefersFuseboxFrontend", capabilities.prefersFuseboxFrontend);
 }
 
 namespace {

package/ReactCommon/jsinspector-modern/InspectorInterfaces.h

@@ -34,8 +34,9 @@ class IDestructible {
 };
 
 struct InspectorTargetCapabilities {
-  const bool nativePageReloads = false;
-  const bool nativeSourceCodeFetching = false;
+  bool nativePageReloads = false;
+  bool nativeSourceCodeFetching = false;
+  bool prefersFuseboxFrontend = false;
 };
 
 const folly::dynamic targetCapabilitiesToDynamic(

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.cpp

@@ -161,7 +161,6 @@ folly::dynamic InspectorPackagerConnection::Impl::pages() {
     pageDescription["id"] = std::to_string(page.id);
     pageDescription["title"] = page.title + " [C++ connection]";
     pageDescription["app"] = app_;
-    pageDescription["vm"] = page.vm;
     pageDescription["capabilities"] =
         targetCapabilitiesToDynamic(page.capabilities);
 

package/ReactCommon/jsinspector-modern/InspectorUtilities.h

@@ -49,4 +49,12 @@ class RAIIRemoteConnection {
   std::unique_ptr<IRemoteConnection> remote_;
 };
 
+/**
+ * An \c IRemoteConnection that does nothing.
+ */
+class NullRemoteConnection : public IRemoteConnection {
+  inline void onMessage(std::string /*message*/) override {}
+  inline void onDisconnect() override {}
+};
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceAgent.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <jsinspector-modern/InstanceAgent.h>
+#include "CdpJson.h"
 #include "RuntimeTarget.h"
 
 namespace facebook::react::jsinspector_modern {
@@ -23,6 +24,7 @@ InstanceAgent::InstanceAgent(
 bool InstanceAgent::handleRequest(const cdp::PreparsedRequest& req) {
   if (req.method == "Runtime.enable") {
     maybeSendExecutionContextCreatedNotification();
+    maybeSendPendingConsoleMessages();
     // Fall through
   }
   if (runtimeAgent_ && runtimeAgent_->handleRequest(req)) {
@@ -49,11 +51,11 @@ void InstanceAgent::setCurrentRuntime(RuntimeTarget* runtimeTarget) {
     if (previousContext.uniqueId.has_value()) {
       params["executionContextUniqueId"] = *previousContext.uniqueId;
     }
-    folly::dynamic contextDestroyed = folly::dynamic::object(
-        "method", "Runtime.executionContextDestroyed")("params", params);
-    frontendChannel_(folly::toJson(contextDestroyed));
+    frontendChannel_(
+        cdp::jsonNotification("Runtime.executionContextDestroyed", params));
   }
   maybeSendExecutionContextCreatedNotification();
+  maybeSendPendingConsoleMessages();
 }
 
 void InstanceAgent::maybeSendExecutionContextCreatedNotification() {
@@ -66,9 +68,87 @@ void InstanceAgent::maybeSendExecutionContextCreatedNotification() {
     if (newContext.uniqueId.has_value()) {
       params["uniqueId"] = *newContext.uniqueId;
     }
-    folly::dynamic contextCreated = folly::dynamic::object(
-        "method", "Runtime.executionContextCreated")("params", params);
-    frontendChannel_(folly::toJson(contextCreated));
+    frontendChannel_(
+        cdp::jsonNotification("Runtime.executionContextCreated", params));
+  }
+}
+
+void InstanceAgent::sendConsoleMessage(SimpleConsoleMessage message) {
+  if (runtimeAgent_ && sessionState_.isRuntimeDomainEnabled) {
+    sendConsoleMessageImmediately(std::move(message));
+  } else {
+    sessionState_.pendingSimpleConsoleMessages.emplace_back(std::move(message));
+  }
+}
+
+static std::string consoleMessageTypeName(ConsoleAPIType type) {
+  switch (type) {
+    case ConsoleAPIType::kLog:
+      return "log";
+    case ConsoleAPIType::kDebug:
+      return "debug";
+    case ConsoleAPIType::kInfo:
+      return "info";
+    case ConsoleAPIType::kError:
+      return "error";
+    case ConsoleAPIType::kWarning:
+      return "warning";
+    case ConsoleAPIType::kDir:
+      return "dir";
+    case ConsoleAPIType::kDirXML:
+      return "dirxml";
+    case ConsoleAPIType::kTable:
+      return "table";
+    case ConsoleAPIType::kTrace:
+      return "trace";
+    case ConsoleAPIType::kStartGroup:
+      return "startGroup";
+    case ConsoleAPIType::kStartGroupCollapsed:
+      return "startGroupCollapsed";
+    case ConsoleAPIType::kEndGroup:
+      return "endGroup";
+    case ConsoleAPIType::kClear:
+      return "clear";
+    case ConsoleAPIType::kAssert:
+      return "assert";
+    case ConsoleAPIType::kTimeEnd:
+      return "timeEnd";
+    case ConsoleAPIType::kCount:
+      return "count";
+    default:
+      assert(false && "unknown console API type");
+      return "error";
+  }
+}
+
+void InstanceAgent::sendConsoleMessageImmediately(
+    SimpleConsoleMessage message) {
+  assert(runtimeAgent_ != nullptr);
+  folly::dynamic argsParam = folly::dynamic::array();
+  for (auto& arg : message.args) {
+    argsParam.push_back(folly::dynamic::object("type", "string")("value", arg));
+  }
+  frontendChannel_(cdp::jsonNotification(
+      "Runtime.consoleAPICalled",
+      folly::dynamic::object("type", consoleMessageTypeName(message.type))(
+          "timestamp", message.timestamp)("args", std::move(argsParam))(
+          "executionContextId",
+          runtimeAgent_->getExecutionContextDescription().id)(
+          // We use the @cdp Runtime.consoleAPICalled `context` parameter to
+          // mark synthetic messages generated by the backend, i.e. not
+          // originating in a real `console.*` API call.
+          "context",
+          runtimeAgent_->getExecutionContextDescription().name +
+              "#InstanceAgent")));
+}
+
+void InstanceAgent::maybeSendPendingConsoleMessages() {
+  if (runtimeAgent_ != nullptr) {
+    auto messages = std::move(sessionState_.pendingSimpleConsoleMessages);
+    sessionState_.pendingSimpleConsoleMessages.clear();
+    for (auto& message : messages) {
+      sendConsoleMessageImmediately(std::move(message));
+    }
   }
 }
 

package/ReactCommon/jsinspector-modern/InstanceAgent.h

@@ -7,11 +7,11 @@
 
 #pragma once
 
+#include "CdpJson.h"
 #include "RuntimeTarget.h"
 #include "SessionState.h"
 
 #include <jsinspector-modern/InspectorInterfaces.h>
-#include <jsinspector-modern/Parsing.h>
 #include <jsinspector-modern/RuntimeAgent.h>
 
 #include <functional>
@@ -47,15 +47,22 @@ class InstanceAgent final {
   bool handleRequest(const cdp::PreparsedRequest& req);
 
   /**
-   * Replace the current RuntimeAgent pageAgent_ with a new one
+   * Replace the current RuntimeAgent hostAgent_ with a new one
    * connected to the new RuntimeTarget.
    * \param runtime The new runtime target. May be nullptr to indicate
    * there's no current debuggable runtime.
    */
   void setCurrentRuntime(RuntimeTarget* runtime);
 
+  /**
+   * Send a console message to the frontend, or buffer it to be sent later.
+   */
+  void sendConsoleMessage(SimpleConsoleMessage message);
+
  private:
   void maybeSendExecutionContextCreatedNotification();
+  void sendConsoleMessageImmediately(SimpleConsoleMessage message);
+  void maybeSendPendingConsoleMessages();
 
   FrontendChannel frontendChannel_;
   InstanceTarget& target_;

package/ReactCommon/jsinspector-modern/InstanceTarget.cpp

@@ -47,7 +47,7 @@ InstanceTarget::~InstanceTarget() {
   // they hold an InstanceTarget& that we must guarantee is valid.
   assert(
       agents_.empty() &&
-      "InstanceAgent objects must be destroyed before their InstanceTarget. Did you call PageTarget::unregisterInstance()?");
+      "InstanceAgent objects must be destroyed before their InstanceTarget. Did you call HostTarget::unregisterInstance()?");
 }
 
 RuntimeTarget& InstanceTarget::registerRuntime(

package/ReactCommon/jsinspector-modern/InstanceTarget.h

@@ -70,9 +70,22 @@ class InstanceTarget : public EnableExecutorFromThis<InstanceTarget> {
       FrontendChannel channel,
       SessionState& sessionState);
 
+  /**
+   * Registers a JS runtime with this InstanceTarget. \returns a reference to
+   * the created RuntimeTarget, which is owned by the \c InstanceTarget. All the
+   * requirements of \c RuntimeTarget::create must be met.
+   */
   RuntimeTarget& registerRuntime(
       RuntimeTargetDelegate& delegate,
       RuntimeExecutor executor);
+
+  /**
+   * Unregisters a JS runtime from this InstanceTarget. This destroys the \c
+   * RuntimeTarget, and it is no longer valid to use. Note that the \c
+   * RuntimeTargetDelegate& initially provided to \c registerRuntime may
+   * continue to be used as long as JavaScript execution continues in the
+   * runtime.
+   */
   void unregisterRuntime(RuntimeTarget& runtime);
 
  private:

package/ReactCommon/jsinspector-modern/React-jsinspector.podspec

@@ -33,12 +33,12 @@ Pod::Spec.new do |s|
   s.author                 = "Meta Platforms, Inc. and its affiliates"
   s.platforms              = min_supported_versions
   s.source                 = source
-  s.source_files           = "*.{cpp,h}"
+  s.source_files           = "*.{cpp,h,def}"
   s.header_dir             = 'jsinspector-modern'
   s.compiler_flags         = folly_compiler_flags
   s.pod_target_xcconfig    = {
                                "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/..\" \"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/fmt/include\"",
-                               "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+                               "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "DEFINES_MODULE" => "YES"
   }.merge!(use_frameworks ? {
     "PUBLIC_HEADERS_FOLDER_PATH" => "#{module_name}.framework/Headers/#{header_dir}"

package/ReactCommon/jsinspector-modern/ReactCdp.h

@@ -8,9 +8,9 @@
 #pragma once
 
 #include <jsinspector-modern/ExecutionContext.h>
-#include <jsinspector-modern/FallbackRuntimeAgentDelegate.h>
+#include <jsinspector-modern/FallbackRuntimeTargetDelegate.h>
+#include <jsinspector-modern/HostTarget.h>
 #include <jsinspector-modern/InstanceTarget.h>
-#include <jsinspector-modern/PageTarget.h>
 #include <jsinspector-modern/RuntimeTarget.h>
 #include <jsinspector-modern/ScopedExecutor.h>
 #include <jsinspector-modern/SessionState.h>