react-native-windows 0.80.1 → 0.80.6

package/Shared/Hermes/HermesRuntimeTargetDelegate.cpp

@@ -0,0 +1,263 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/*
+ * 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.
+ */
+
+// This file must match the code in React Native folder:
+// ReactCommon/hermes/inspector-modern/chrome/HermesRuntimeTargetDelegate.cpp
+// Unlike the code in React Native sources, this class delegates calls to Hermes C-based API.
+// We use different namespace for this class comparing with the RN code.
+
+#include "HermesRuntimeTargetDelegate.h"
+#include <jsinspector-modern/RuntimeTarget.h>
+#include <utility>
+#include "HermesRuntimeAgentDelegate.h"
+
+using namespace facebook::react::jsinspector_modern;
+
+namespace Microsoft::ReactNative {
+
+namespace {
+
+const uint16_t HERMES_SAMPLING_FREQUENCY_HZ = 10000;
+
+class HermesStackTraceWrapper : public StackTrace {
+ public:
+  explicit HermesStackTraceWrapper(HermesUniqueStackTrace &&hermesStackTrace)
+      : hermesStackTrace_{std::move(hermesStackTrace)} {}
+
+  HermesUniqueStackTrace &operator*() {
+    return hermesStackTrace_;
+  }
+
+  HermesUniqueStackTrace *operator->() {
+    return &hermesStackTrace_;
+  }
+
+ private:
+  HermesUniqueStackTrace hermesStackTrace_;
+};
+
+} // namespace
+
+HermesRuntimeTargetDelegate::HermesRuntimeTargetDelegate(std::shared_ptr<HermesRuntimeHolder> &&hermesRuntimeHolder)
+    : hermesRuntimeHolder_(std::move(hermesRuntimeHolder)),
+      hermesCdpDebugApi_(HermesInspectorApi::createCdpDebugApi(hermesRuntimeHolder_->getHermesRuntime())) {}
+
+HermesRuntimeTargetDelegate::~HermesRuntimeTargetDelegate() = default;
+
+hermes_cdp_debug_api HermesRuntimeTargetDelegate::getCdpDebugApi() {
+  return hermesCdpDebugApi_.get();
+}
+
+std::unique_ptr<RuntimeAgentDelegate> HermesRuntimeTargetDelegate::createAgentDelegate(
+    FrontendChannel frontendChannel,
+    SessionState &sessionState,
+    std::unique_ptr<RuntimeAgentDelegate::ExportedState> previouslyExportedState,
+    const ExecutionContextDescription &executionContextDescription,
+    facebook::react::RuntimeExecutor runtimeExecutor) {
+  return std::unique_ptr<RuntimeAgentDelegate>(new HermesRuntimeAgentDelegate(
+      frontendChannel,
+      sessionState,
+      std::move(previouslyExportedState),
+      executionContextDescription,
+      hermesRuntimeHolder_->getHermesRuntime(),
+      *this,
+      std::move(runtimeExecutor)));
+}
+
+void HermesRuntimeTargetDelegate::addConsoleMessage(facebook::jsi::Runtime &runtime, ConsoleMessage message) {
+  // Convert ConsoleAPIType to hermes_console_api_type
+  hermes_console_api_type type{};
+  switch (message.type) {
+    case ConsoleAPIType::kLog:
+      type = hermes_console_api_type_log;
+      break;
+    case ConsoleAPIType::kDebug:
+      type = hermes_console_api_type_debug;
+      break;
+    case ConsoleAPIType::kInfo:
+      type = hermes_console_api_type_info;
+      break;
+    case ConsoleAPIType::kError:
+      type = hermes_console_api_type_error;
+      break;
+    case ConsoleAPIType::kWarning:
+      type = hermes_console_api_type_warning;
+      break;
+    case ConsoleAPIType::kDir:
+      type = hermes_console_api_type_dir;
+      break;
+    case ConsoleAPIType::kDirXML:
+      type = hermes_console_api_type_dir_xml;
+      break;
+    case ConsoleAPIType::kTable:
+      type = hermes_console_api_type_table;
+      break;
+    case ConsoleAPIType::kTrace:
+      type = hermes_console_api_type_trace;
+      break;
+    case ConsoleAPIType::kStartGroup:
+      type = hermes_console_api_type_start_group;
+      break;
+    case ConsoleAPIType::kStartGroupCollapsed:
+      type = hermes_console_api_type_start_group_collapsed;
+      break;
+    case ConsoleAPIType::kEndGroup:
+      type = hermes_console_api_type_end_group;
+      break;
+    case ConsoleAPIType::kClear:
+      type = hermes_console_api_type_clear;
+      break;
+    case ConsoleAPIType::kAssert:
+      type = hermes_console_api_type_assert;
+      break;
+    case ConsoleAPIType::kTimeEnd:
+      type = hermes_console_api_type_time_end;
+      break;
+    case ConsoleAPIType::kCount:
+      type = hermes_console_api_type_count;
+      break;
+    default:
+      throw std::logic_error{"Unknown console message type"};
+  }
+
+  // Create a jsi::Array from the vector of jsi::Values
+  facebook::jsi::Array argsArray(runtime, message.args.size());
+  for (size_t i = 0; i < message.args.size(); ++i) {
+    argsArray.setValueAtIndex(runtime, i, std::move(message.args[i]));
+  }
+
+  // Store array as a temporary global property
+  // Using a property name that's unlikely to collide with user code
+  const char *propName = "__rnw_cdp_console_args";
+  runtime.global().setProperty(runtime, propName, argsArray);
+
+  // Convert stack trace to HermesUniqueStackTrace if available
+  HermesUniqueStackTrace hermesStackTrace{};
+  if (auto hermesStackTraceWrapper = dynamic_cast<HermesStackTraceWrapper *>(message.stackTrace.get())) {
+    hermesStackTrace = std::move(**hermesStackTraceWrapper);
+  }
+
+  // Call C API with property name instead of serialized args
+  // The property will be cleaned up by the Hermes side
+  HermesInspectorApi::addConsoleMessage(
+      hermesCdpDebugApi_.get(), message.timestamp, type, propName, hermesStackTrace.get());
+}
+
+bool HermesRuntimeTargetDelegate::supportsConsole() const {
+  return true;
+}
+
+std::unique_ptr<StackTrace> HermesRuntimeTargetDelegate::captureStackTrace(
+    facebook::jsi::Runtime & /*runtime*/,
+    size_t /*framesToSkip*/) {
+  return std::make_unique<HermesStackTraceWrapper>(
+      HermesInspectorApi::captureStackTrace(hermesRuntimeHolder_->getHermesRuntime()));
+}
+
+void HermesRuntimeTargetDelegate::enableSamplingProfiler() {
+  HermesInspectorApi::enableSamplingProfiler(hermesRuntimeHolder_->getHermesRuntime());
+}
+
+void HermesRuntimeTargetDelegate::disableSamplingProfiler() {
+  HermesInspectorApi::disableSamplingProfiler(hermesRuntimeHolder_->getHermesRuntime());
+}
+
+namespace {
+
+// Helper class to hold state while reading the sampling profile
+struct SamplingProfileReaderState {
+  std::vector<tracing::RuntimeSamplingProfile::Sample> samples;
+  std::vector<tracing::RuntimeSamplingProfile::SampleCallStackFrame> frames;
+  uint64_t timestamp;
+  uint64_t threadId;
+  bool hasCurrentSample;
+};
+
+static void NAPI_CDECL onInfo(void *cb_data, size_t sample_count) {
+  SamplingProfileReaderState *readerState = reinterpret_cast<SamplingProfileReaderState *>(cb_data);
+  readerState->samples.reserve(sample_count);
+}
+
+// Callback invoked for each sample
+static void NAPI_CDECL onSample(void *cb_data, uint64_t timestamp, uint64_t threadId, size_t frame_count) {
+  SamplingProfileReaderState *readerState = reinterpret_cast<SamplingProfileReaderState *>(cb_data);
+  if (readerState->hasCurrentSample) {
+    // Save the previous sample
+    readerState->samples.emplace_back(readerState->timestamp, readerState->threadId, std::move(readerState->frames));
+  }
+  std::vector<tracing::RuntimeSamplingProfile::SampleCallStackFrame> frames;
+  frames.reserve(frame_count);
+  readerState->frames = std::move(frames);
+  readerState->timestamp = timestamp;
+  readerState->threadId = threadId;
+  readerState->hasCurrentSample = true;
+}
+
+// Callback invoked for each frame within a sample
+static void NAPI_CDECL onFrame(
+    void *cb_data,
+    hermes_call_stack_frame_kind kind,
+    uint32_t scriptId,
+    const char *functionName,
+    size_t functionNameSize,
+    const char *scriptUrl,
+    size_t scriptUrlSize,
+    uint32_t lineNumber,
+    uint32_t columnNumber) {
+  SamplingProfileReaderState *readerState = reinterpret_cast<SamplingProfileReaderState *>(cb_data);
+
+  using Kind = tracing::RuntimeSamplingProfile::SampleCallStackFrame::Kind;
+
+  Kind frameKind;
+  switch (kind) {
+    case hermes_call_stack_frame_kind_js_function:
+      frameKind = Kind::JSFunction;
+      break;
+    case hermes_call_stack_frame_kind_native_function:
+      frameKind = Kind::NativeFunction;
+      break;
+    case hermes_call_stack_frame_kind_host_function:
+      frameKind = Kind::HostFunction;
+      break;
+    case hermes_call_stack_frame_kind_gc:
+      frameKind = Kind::GarbageCollector;
+      break;
+    default:
+      return; // Unknown frame kind, skip
+  }
+
+  std::string funcName(functionName, functionNameSize);
+  std::optional<std::string> url = scriptUrl ? std::optional{std::string(scriptUrl, scriptUrlSize)} : std::nullopt;
+  std::optional<uint32_t> line = lineNumber > 0 ? std::optional{lineNumber} : std::nullopt;
+  std::optional<uint32_t> column = columnNumber > 0 ? std::optional{columnNumber} : std::nullopt;
+
+  readerState->frames.emplace_back(frameKind, scriptId, std::move(funcName), std::move(url), line, column);
+}
+
+} // namespace
+
+tracing::RuntimeSamplingProfile HermesRuntimeTargetDelegate::collectSamplingProfile() {
+  // Create a readerState state to gather samples and frames
+  SamplingProfileReaderState readerState{};
+
+  // Collect the profile from Hermes
+  HermesUniqueSamplingProfile profile = HermesInspectorApi::collectSamplingProfile(
+      hermesRuntimeHolder_->getHermesRuntime(), &readerState, onInfo, onSample, onFrame);
+
+  if (readerState.hasCurrentSample) {
+    // Save the last sample
+    readerState.samples.emplace_back(readerState.timestamp, readerState.threadId, std::move(readerState.frames));
+  }
+
+  // Return the complete profile with samples. Wrap the raw profile since it owns the strings.
+  return tracing::RuntimeSamplingProfile("Hermes", std::move(readerState.samples));
+}
+
+} // namespace Microsoft::ReactNative

package/Shared/Hermes/HermesRuntimeTargetDelegate.h

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/*
+ * 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.
+ */
+
+// This file must match the code in React Native folder:
+// ReactCommon/hermes/inspector-modern/chrome/HermesRuntimeTargetDelegate.h
+// Unlike the code in React Native sources, this class delegates calls to Hermes C-based API.
+// We use different namespace for this class comparing with the RN code.
+
+#pragma once
+
+#include <ReactCommon/RuntimeExecutor.h>
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsinspector-modern/ReactCdp.h>
+
+#include <memory>
+#include "HermesRuntimeHolder.h"
+
+namespace Microsoft::ReactNative {
+
+/**
+ * A RuntimeTargetDelegate that enables debugging a Hermes runtime over CDP.
+ */
+class HermesRuntimeTargetDelegate : public facebook::react::jsinspector_modern::RuntimeTargetDelegate {
+ public:
+  explicit HermesRuntimeTargetDelegate(std::shared_ptr<HermesRuntimeHolder> &&hermesRuntimeHolder);
+
+  ~HermesRuntimeTargetDelegate() override;
+
+  // Our C-API specific helper method to be used internally instead of RN getCDPDebugAPI() private function.
+  hermes_cdp_debug_api getCdpDebugApi();
+
+ public: // RuntimeTargetDelegate implementation
+  std::unique_ptr<facebook::react::jsinspector_modern::RuntimeAgentDelegate> createAgentDelegate(
+      facebook::react::jsinspector_modern::FrontendChannel frontendChannel,
+      facebook::react::jsinspector_modern::SessionState &sessionState,
+      std::unique_ptr<facebook::react::jsinspector_modern::RuntimeAgentDelegate::ExportedState> previouslyExportedState,
+      const facebook::react::jsinspector_modern::ExecutionContextDescription &executionContextDescription,
+      facebook::react::RuntimeExecutor runtimeExecutor) override;
+
+  void addConsoleMessage(facebook::jsi::Runtime &runtime, facebook::react::jsinspector_modern::ConsoleMessage message)
+      override;
+
+  bool supportsConsole() const override;
+
+  std::unique_ptr<facebook::react::jsinspector_modern::StackTrace> captureStackTrace(
+      facebook::jsi::Runtime &runtime,
+      size_t framesToSkip) override;
+
+  /**
+   * Start sampling profiler.
+   */
+  void enableSamplingProfiler() override;
+
+  /**
+   * Stop sampling profiler.
+   */
+  void disableSamplingProfiler() override;
+
+  /**
+   * Return recorded sampling profile for the previous sampling session.
+   */
+  facebook::react::jsinspector_modern::tracing::RuntimeSamplingProfile collectSamplingProfile() override;
+
+ private:
+  std::shared_ptr<HermesRuntimeHolder> hermesRuntimeHolder_;
+  const HermesUniqueCdpDebugApi hermesCdpDebugApi_;
+};
+
+} // namespace Microsoft::ReactNative

package/Shared/HermesRuntimeHolder.cpp

@@ -14,7 +14,9 @@
 #include <jsinspector-modern/InspectorInterfaces.h>
 #include <jsinspector-modern/tracing/InstanceTracingProfile.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <cstdio>
 #include <mutex>
+#include "Hermes/HermesRuntimeTargetDelegate.h"
 #include "SafeLoadLibrary.h"
 
 #define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
@@ -27,6 +29,12 @@ using namespace Microsoft::NodeApiJsi;
 
 namespace Microsoft::ReactNative {
 
+/*static*/ const hermes_inspector_vtable *HermesInspectorApi::vtable = nullptr;
+
+void setHermesInspectorVTable(const hermes_inspector_vtable *vtable) {
+  HermesInspectorApi::vtable = vtable;
+}
+
 React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>>
 HermesRuntimeHolderProperty() noexcept {
   static React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>> propId{
@@ -36,9 +44,6 @@ HermesRuntimeHolderProperty() noexcept {
 
 namespace {
 
-int32_t NAPI_CDECL addInspectorPage(const char *title, const char *vm, void *connectFunc) noexcept;
-void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept;
-
 class HermesFuncResolver : public IFuncResolver {
  public:
   HermesFuncResolver() : libHandle_(LoadLibraryAsPeerFirst(L"hermes.dll")) {}
@@ -55,7 +60,9 @@ HermesApi &initHermesApi() noexcept {
   static HermesFuncResolver funcResolver;
   static HermesApi s_hermesApi(&funcResolver);
   HermesApi::setCurrent(&s_hermesApi);
-  CRASH_ON_ERROR(s_hermesApi.hermes_set_inspector(&addInspectorPage, &removeInspectorPage));
+  const hermes_inspector_vtable *inspectorVTable{};
+  s_hermesApi.hermes_get_inspector_vtable(&inspectorVTable);
+  setHermesInspectorVTable(inspectorVTable);
   return s_hermesApi;
 }
 
@@ -233,65 +240,6 @@ class HermesScriptCache {
   std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore_;
 };
 
-class HermesLocalConnection : public facebook::react::jsinspector_modern::ILocalConnection {
- public:
-  HermesLocalConnection(
-      std::unique_ptr<facebook::react::jsinspector_modern::IRemoteConnection> remoteConnection,
-      void *connectFunc) noexcept {
-    CRASH_ON_ERROR(getHermesApi().hermes_create_local_connection(
-        connectFunc,
-        reinterpret_cast<hermes_remote_connection>(remoteConnection.release()),
-        &OnRemoteConnectionSendMessage,
-        &OnRemoteConnectionDisconnect,
-        &OnRemoteConnectionDelete,
-        nullptr,
-        &localConnection_));
-  }
-
-  ~HermesLocalConnection() override {
-    CRASH_ON_ERROR(getHermesApi().hermes_delete_local_connection(localConnection_));
-  }
-
-  void sendMessage(std::string message) {
-    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_send_message(localConnection_, message.c_str()));
-  }
-
-  void disconnect() {
-    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_disconnect(localConnection_));
-  }
-
- private:
-  static void NAPI_CDECL OnRemoteConnectionSendMessage(hermes_remote_connection remoteConnection, const char *message) {
-    reinterpret_cast<facebook::react::jsinspector_modern::IRemoteConnection *>(remoteConnection)->onMessage(message);
-  }
-
-  static void NAPI_CDECL OnRemoteConnectionDisconnect(hermes_remote_connection remoteConnection) {
-    reinterpret_cast<facebook::react::jsinspector_modern::IRemoteConnection *>(remoteConnection)->onDisconnect();
-  }
-
-  static void NAPI_CDECL OnRemoteConnectionDelete(void *remoteConnection, void * /*deleterData*/) {
-    delete reinterpret_cast<facebook::react::jsinspector_modern::IRemoteConnection *>(remoteConnection);
-  }
-
- private:
-  hermes_local_connection localConnection_{};
-};
-
-int32_t NAPI_CDECL addInspectorPage(const char *title, const char *vm, void *connectFunc) noexcept {
-  return facebook::react::jsinspector_modern::getInspectorInstance().addPage(
-      title,
-      vm,
-      [connectFunc, hermesApi = HermesApi::current()](
-          std::unique_ptr<facebook::react::jsinspector_modern::IRemoteConnection> remoteConnection) {
-        HermesApi::Scope apiScope(hermesApi);
-        return std::make_unique<HermesLocalConnection>(std::move(remoteConnection), connectFunc);
-      });
-}
-
-void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept {
-  facebook::react::jsinspector_modern::getInspectorInstance().removePage(pageId);
-}
-
 } // namespace
 
 //==============================================================================
@@ -307,9 +255,9 @@ HermesRuntimeHolder::HermesRuntimeHolder(
       m_preparedScriptStore(std::move(preparedScriptStore)) {}
 
 HermesRuntimeHolder::~HermesRuntimeHolder() {
-  if (m_runtime) {
-    CRASH_ON_ERROR(getHermesApi().jsr_delete_runtime(m_runtime));
-  }
+  // if (m_runtime) {
+  //   CRASH_ON_ERROR(getHermesApi().jsr_delete_runtime(m_runtime));
+  // }
 }
 
 void HermesRuntimeHolder::initRuntime() noexcept {
@@ -323,9 +271,6 @@ void HermesRuntimeHolder::initRuntime() noexcept {
   CRASH_ON_ERROR(api.jsr_create_config(&config));
   CRASH_ON_ERROR(api.hermes_config_enable_default_crash_handler(config, devSettings->enableDefaultCrashHandler));
   CRASH_ON_ERROR(api.jsr_config_enable_inspector(config, devSettings->useDirectDebugger));
-  CRASH_ON_ERROR(api.jsr_config_set_inspector_runtime_name(config, devSettings->debuggerRuntimeName.c_str()));
-  CRASH_ON_ERROR(api.jsr_config_set_inspector_port(config, devSettings->debuggerPort));
-  CRASH_ON_ERROR(api.jsr_config_set_inspector_break_on_start(config, devSettings->debuggerBreakOnNextLine));
   CRASH_ON_ERROR(api.jsr_config_set_explicit_microtasks(
       config, facebook::react::ReactNativeFeatureFlags::enableBridgelessArchitecture()));
 
@@ -338,6 +283,7 @@ void HermesRuntimeHolder::initRuntime() noexcept {
   jsr_runtime runtime{};
   CRASH_ON_ERROR(api.jsr_create_runtime(config, &runtime));
   CRASH_ON_ERROR(api.jsr_delete_config(config));
+  m_runtime = runtime;
 
   napi_env env{};
   CRASH_ON_ERROR(api.jsr_runtime_get_node_api_env(runtime, &env));
@@ -364,12 +310,13 @@ std::shared_ptr<facebook::jsi::Runtime> HermesRuntimeHolder::getRuntime() noexce
   return m_jsiRuntime;
 }
 
-void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_dump_crash_data(m_runtime, fileDescriptor));
+std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate>
+HermesRuntimeHolder::createRuntimeTargetDelegate() {
+  return std::make_shared<Microsoft::ReactNative::HermesRuntimeTargetDelegate>(shared_from_this());
 }
 
-void HermesRuntimeHolder::teardown() noexcept {
-  // TODO: (@vmoroz) Implement
+void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_dump_crash_data(m_runtime, fileDescriptor));
 }
 
 std::shared_ptr<HermesRuntimeHolder> HermesRuntimeHolder::loadFrom(
@@ -403,6 +350,10 @@ void HermesRuntimeHolder::removeFromProfiling() const noexcept {
   CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_dump_to_file(fileName.c_str()));
 }
 
+hermes_runtime HermesRuntimeHolder::getHermesRuntime() noexcept {
+  return reinterpret_cast<hermes_runtime>(m_runtime);
+}
+
 //==============================================================================
 // HermesJSRuntime implementation
 //==============================================================================
@@ -414,44 +365,11 @@ facebook::jsi::Runtime &HermesJSRuntime::getRuntime() noexcept {
   return *m_holder->getRuntime();
 }
 
-void HermesJSRuntime::addConsoleMessage(
-    facebook::jsi::Runtime &runtime,
-    facebook::react::jsinspector_modern::ConsoleMessage message) {
-  return;
-}
-
-bool HermesJSRuntime::supportsConsole() const {
-  return false;
-}
-
-std::unique_ptr<facebook::react::jsinspector_modern::StackTrace> HermesJSRuntime::captureStackTrace(
-    facebook::jsi::Runtime &runtime,
-    size_t framesToSkip) {
-  return std::make_unique<facebook::react::jsinspector_modern::StackTrace>();
-}
-
-void HermesJSRuntime::enableSamplingProfiler() {
-  return; // [Windows TODO: stubbed implementation #14700]
-}
-
-void HermesJSRuntime::disableSamplingProfiler() {
-  return; // [Windows TODO: stubbed implementation #14700]
-}
-
-facebook::react::jsinspector_modern::tracing::RuntimeSamplingProfile HermesJSRuntime::collectSamplingProfile() {
-  return facebook::react::jsinspector_modern::tracing::RuntimeSamplingProfile(
-      "stubbed_impl", {}); // [Windows TODO: stubbed implementation #14700]
-}
-
-std::unique_ptr<facebook::react::jsinspector_modern::RuntimeAgentDelegate> HermesJSRuntime::createAgentDelegate(
-    facebook::react::jsinspector_modern::FrontendChannel frontendChannel,
-    facebook::react::jsinspector_modern::SessionState &sessionState,
-    std::unique_ptr<facebook::react::jsinspector_modern::RuntimeAgentDelegate::ExportedState> previouslyExportedState,
-    const facebook::react::jsinspector_modern::ExecutionContextDescription &executionContextDescription,
-    facebook::react::RuntimeExecutor runtimeExecutor) {
-  (void)frontendChannel;
-  (void)sessionState;
-  return nullptr;
+facebook::react::jsinspector_modern::RuntimeTargetDelegate &HermesJSRuntime::getRuntimeTargetDelegate() {
+  if (!m_runtimeTargetDelegate) {
+    m_runtimeTargetDelegate = m_holder->createRuntimeTargetDelegate();
+  }
+  return *m_runtimeTargetDelegate;
 }
 
 } // namespace Microsoft::ReactNative