react-native-windows 0.80.1 → 0.80.5

package/Shared/HermesRuntimeHolder.h

@@ -8,16 +8,219 @@
 #include <ReactPropertyBag.h>
 #include <cxxreact/MessageQueueThread.h>
 #include <hermes/hermes_api.h>
-#include <jsitooling/react/runtime/JSRuntimeFactory.h>
+#include <react/runtime/JSRuntimeFactory.h>
 
 namespace Microsoft::ReactNative {
 
-class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
+template <typename TLambda, typename TFunctor>
+class FunctorAdapter {
+  static_assert(sizeof(TLambda) == -1, "Unsupported signature");
+};
+
+template <typename TLambda, typename TResult, typename... TArgs>
+class FunctorAdapter<TLambda, TResult(NAPI_CDECL)(void *, TArgs...)> {
+ public:
+  static TResult NAPI_CDECL Invoke(void *data, TArgs... args) {
+    return reinterpret_cast<TLambda *>(data)->operator()(args...);
+  }
+};
+
+template <typename TFunctor, typename TLambda>
+inline TFunctor AsFunctor(TLambda &&lambda) {
+  using TLambdaType = std::remove_reference_t<TLambda>;
+  using TAdapter =
+      FunctorAdapter<TLambdaType, std::remove_pointer_t<decltype(std::remove_reference_t<TFunctor>::invoke)>>;
+  return TFunctor{
+      static_cast<void *>(new TLambdaType(std::forward<TLambdaType>(lambda))), &TAdapter::Invoke, [](void *data) {
+        delete static_cast<TLambdaType *>(data);
+      }};
+}
+
+template <typename TFunctor, typename TInvoke>
+class FunctorWrapperBase {
+  static_assert(sizeof(TInvoke) == -1, "Unsupported signature");
+};
+
+template <typename TFunctor, typename TResult, typename... TArgs>
+class FunctorWrapperBase<TFunctor, TResult(NAPI_CDECL *)(void *, TArgs...)> {
+ public:
+  FunctorWrapperBase(TFunctor functor) : functor_(functor) {}
+
+  ~FunctorWrapperBase() {
+    if (functor_.release != nullptr) {
+      functor_.release(functor_.data);
+    }
+  }
+
+  TResult operator()(TArgs... args) {
+    return functor_.invoke(functor_.data, args...);
+  }
+
+ private:
+  TFunctor functor_;
+};
+
+template <typename TFunctor>
+class FunctorWrapper : public FunctorWrapperBase<TFunctor, decltype(std::declval<TFunctor>().invoke)> {
+ public:
+  using FunctorWrapperBase<TFunctor, decltype(std::declval<TFunctor>().invoke)>::FunctorWrapperBase;
+};
+
+class HermesCdpDebugApiDeleter {
+ public:
+  void operator()(hermes_cdp_debug_api cdp_debug_api);
+};
+
+class HermesCdpAgentDeleter {
+ public:
+  void operator()(hermes_cdp_agent cdp_agent);
+};
+
+class HermesCdpStateDeleter {
+ public:
+  void operator()(hermes_cdp_state cdp_state);
+};
+
+class HermesStackTraceDeleter {
+ public:
+  void operator()(hermes_stack_trace stack_trace);
+};
+
+class HermesSamplingProfileDeleter {
+ public:
+  void operator()(hermes_sampling_profile sampling_profile);
+};
+
+using HermesUniqueCdpDebugApi = std::unique_ptr<hermes_cdp_debug_api_s, HermesCdpDebugApiDeleter>;
+using HermesUniqueCdpAgent = std::unique_ptr<hermes_cdp_agent_s, HermesCdpAgentDeleter>;
+using HermesUniqueCdpState = std::unique_ptr<hermes_cdp_state_s, HermesCdpStateDeleter>;
+using HermesUniqueStackTrace = std::unique_ptr<hermes_stack_trace_s, HermesStackTraceDeleter>;
+using HermesUniqueSamplingProfile = std::unique_ptr<hermes_sampling_profile_s, HermesSamplingProfileDeleter>;
+
+class HermesInspectorApi {
+ public:
+  HermesInspectorApi() = delete;
+
+  static void checkStatus(hermes_status status) {
+    if (status != hermes_status_ok) {
+      throw std::runtime_error("Hermes API call failed");
+    }
+  }
+
+  static HermesUniqueCdpDebugApi createCdpDebugApi(hermes_runtime runtime) {
+    hermes_cdp_debug_api cdp_debug_api{};
+    checkStatus(vtable->create_cdp_debug_api(runtime, &cdp_debug_api));
+    return HermesUniqueCdpDebugApi{cdp_debug_api};
+  }
+
+  static void addConsoleMessage(
+      hermes_cdp_debug_api cdpDebugApi,
+      double timestamp,
+      hermes_console_api_type type,
+      const char *argsPropertyName,
+      hermes_stack_trace stackTrace) {
+    checkStatus(vtable->add_console_message(cdpDebugApi, timestamp, type, argsPropertyName, stackTrace));
+  }
+
+  static HermesUniqueCdpAgent createCdpAgent(
+      hermes_cdp_debug_api cdpDebugApi,
+      int32_t execitionContextId,
+      hermes_enqueue_runtime_task_functor enqueueRuntimeTaskCallback,
+      hermes_enqueue_frontend_message_functor enqueueFrontendMessageCallback,
+      hermes_cdp_state cdp_state) {
+    hermes_cdp_agent cdp_agent{};
+    checkStatus(vtable->create_cdp_agent(
+        cdpDebugApi,
+        execitionContextId,
+        enqueueRuntimeTaskCallback,
+        enqueueFrontendMessageCallback,
+        cdp_state,
+        &cdp_agent));
+    return HermesUniqueCdpAgent{cdp_agent};
+  }
+
+  static HermesUniqueCdpState getCdpState(hermes_cdp_agent cdp_agent) {
+    hermes_cdp_state cdp_state{};
+    checkStatus(vtable->cdp_agent_get_state(cdp_agent, &cdp_state));
+    return HermesUniqueCdpState{cdp_state};
+  }
+
+  static void handleCommand(hermes_cdp_agent cdpAgent, const char *jsonUtf8, size_t jsonSize) {
+    checkStatus(vtable->cdp_agent_handle_command(cdpAgent, jsonUtf8, jsonSize));
+  }
+
+  static void enableRuntimeDomain(hermes_cdp_agent cdpAgent) {
+    checkStatus(vtable->cdp_agent_enable_runtime_domain(cdpAgent));
+  }
+
+  static void enableDebuggerDomain(hermes_cdp_agent cdpAgent) {
+    checkStatus(vtable->cdp_agent_enable_debugger_domain(cdpAgent));
+  }
+
+  static HermesUniqueStackTrace captureStackTrace(hermes_runtime runtime) {
+    hermes_stack_trace stack_trace{};
+    checkStatus(vtable->capture_stack_trace(runtime, &stack_trace));
+    return HermesUniqueStackTrace{stack_trace};
+  }
+
+  static void enableSamplingProfiler(hermes_runtime runtime) {
+    checkStatus(vtable->enable_sampling_profiler(runtime));
+  }
+
+  static void disableSamplingProfiler(hermes_runtime runtime) {
+    checkStatus(vtable->disable_sampling_profiler(runtime));
+  }
+
+  static HermesUniqueSamplingProfile collectSamplingProfile(
+      hermes_runtime runtime,
+      void *cb_data,
+      hermes_on_sampling_profile_info_callback on_info_callback,
+      hermes_on_sampling_profile_sample_callback on_sample_callback,
+      hermes_on_sampling_profile_frame_callback on_frame_callback) {
+    hermes_sampling_profile profile{};
+    checkStatus(vtable->collect_sampling_profile(
+        runtime, cb_data, on_info_callback, on_sample_callback, on_frame_callback, &profile));
+    return HermesUniqueSamplingProfile{profile};
+  }
+
+ private:
+  friend HermesCdpDebugApiDeleter;
+  friend HermesCdpAgentDeleter;
+  friend HermesCdpStateDeleter;
+  friend HermesStackTraceDeleter;
+  friend HermesSamplingProfileDeleter;
+
+  friend void setHermesInspectorVTable(const hermes_inspector_vtable *vtable);
+
+  static const hermes_inspector_vtable *vtable;
+};
+
+inline void HermesCdpDebugApiDeleter::operator()(hermes_cdp_debug_api cdp_debug_api) {
+  HermesInspectorApi::vtable->release_cdp_debug_api(cdp_debug_api);
+}
+
+inline void HermesCdpAgentDeleter::operator()(hermes_cdp_agent cdp_agent) {
+  HermesInspectorApi::vtable->release_cdp_agent(cdp_agent);
+}
+
+inline void HermesCdpStateDeleter::operator()(hermes_cdp_state cdp_state) {
+  HermesInspectorApi::vtable->release_cdp_state(cdp_state);
+}
+
+inline void HermesStackTraceDeleter::operator()(hermes_stack_trace stack_trace) {
+  HermesInspectorApi::vtable->release_stack_trace(stack_trace);
+}
+
+inline void HermesSamplingProfileDeleter::operator()(hermes_sampling_profile sampling_profile) {
+  HermesInspectorApi::vtable->release_sampling_profile(sampling_profile);
+}
+
+class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit,
+                            public std::enable_shared_from_this<HermesRuntimeHolder> {
  public: // RuntimeHolderLazyInit implementation.
   std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
   facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
   void crashHandler(int fileDescriptor) noexcept override;
-  void teardown() noexcept override;
 
  public:
   HermesRuntimeHolder(
@@ -26,6 +229,8 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
       std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore) noexcept;
   ~HermesRuntimeHolder();
 
+  std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> createRuntimeTargetDelegate() override;
+
   static std::shared_ptr<HermesRuntimeHolder> loadFrom(
       winrt::Microsoft::ReactNative::ReactPropertyBag const &propertyBag) noexcept;
 
@@ -40,6 +245,8 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
   static void disableSamplingProfiler() noexcept;
   static void dumpSampledTraceToFile(const std::string &fileName) noexcept;
 
+  hermes_runtime getHermesRuntime() noexcept;
+
  private:
   void initRuntime() noexcept;
 
@@ -53,42 +260,17 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
   std::shared_ptr<facebook::jsi::PreparedScriptStore> m_preparedScriptStore;
 };
 
-class HermesJSRuntime : public facebook::react::JSRuntime {
+class HermesJSRuntime final : public facebook::react::JSRuntime {
  public:
   HermesJSRuntime(std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> hermesRuntimeHolder);
 
   facebook::jsi::Runtime &getRuntime() noexcept 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 = 0) 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;
-
-  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;
+
+  facebook::react::jsinspector_modern::RuntimeTargetDelegate &getRuntimeTargetDelegate() override;
 
  private:
   std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> m_holder;
+  std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> m_runtimeTargetDelegate;
 };
 
 } // namespace Microsoft::ReactNative

package/Shared/IDevSupportManager.h

@@ -23,9 +23,12 @@ struct IDevSupportManager {
       const uint16_t sourceBundlePort,
       std::function<void()> onChangeCallback) = 0;
   virtual void StopPollingLiveReload() = 0;
+  virtual void OpenDevTools(const std::string &bundleAppId) = 0;
 
-  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
-  virtual void UpdateBundleStatus(bool isLastDownloadSuccess, int64_t updateTimestamp) noexcept = 0;
+  virtual void EnsureInspectorPackagerConnection(
+      const std::string &packagerHost,
+      const uint16_t packagerPort,
+      const std::string &bundleAppId) noexcept = 0;
 };
 
 std::shared_ptr<IDevSupportManager> CreateDevSupportManager();

package/Shared/Inspector/ReactInspectorPackagerConnectionDelegate.cpp

@@ -0,0 +1,108 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "ReactInspectorPackagerConnectionDelegate.h"
+
+#include <Networking/WinRTWebSocketResource.h>
+#include <dispatchQueue/dispatchQueue.h>
+#include <winrt/Microsoft.ReactNative.h>
+#include "ReactInspectorThread.h"
+
+namespace Microsoft::ReactNative {
+
+namespace {
+
+class ReactInspectorWebSocket : public facebook::react::jsinspector_modern::IWebSocket {
+ public:
+  ReactInspectorWebSocket(
+      std::string const &url,
+      std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate> delegate);
+  void send(std::string_view message) override;
+  ~ReactInspectorWebSocket() override;
+
+ private:
+  std::shared_ptr<Microsoft::React::Networking::WinRTWebSocketResource> m_packagerWebSocketConnection;
+  std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate> m_weakDelegate;
+  std::atomic<bool> m_didConnect{false};
+};
+
+ReactInspectorWebSocket::ReactInspectorWebSocket(
+    std::string const &url,
+    std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate> delegate)
+    : m_weakDelegate{delegate} {
+  std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> certExceptions;
+
+  m_packagerWebSocketConnection =
+      std::make_shared<Microsoft::React::Networking::WinRTWebSocketResource>(std::move(certExceptions));
+
+  m_packagerWebSocketConnection->SetOnConnect([this, delegate]() {
+    ReactInspectorThread::Instance().InvokeElsePost([this, delegate]() {
+      m_didConnect = true;
+      if (const auto strongDelegate = delegate.lock()) {
+        strongDelegate->didOpen();
+      }
+    });
+  });
+  m_packagerWebSocketConnection->SetOnMessage([delegate](auto &&, const std::string &message, bool isBinary) {
+    ReactInspectorThread::Instance().InvokeElsePost([delegate, message]() {
+      if (const auto strongDelegate = delegate.lock()) {
+        strongDelegate->didReceiveMessage(message);
+      }
+    });
+  });
+  m_packagerWebSocketConnection->SetOnError(
+      [delegate](const Microsoft::React::Networking::IWebSocketResource::Error &error) {
+        ReactInspectorThread::Instance().InvokeElsePost([delegate, error]() {
+          if (const auto strongDelegate = delegate.lock()) {
+            strongDelegate->didFailWithError(std::nullopt, error.Message);
+          }
+        });
+      });
+  m_packagerWebSocketConnection->SetOnClose([this, delegate](auto &&...) {
+    ReactInspectorThread::Instance().InvokeElsePost([this, delegate]() {
+      // Only call didClose() if we successfully connected first
+      // This prevents didClose() from being called during failed connection attempts
+      if (m_didConnect) {
+        if (const auto strongDelegate = delegate.lock()) {
+          strongDelegate->didClose();
+        }
+      }
+    });
+  });
+
+  Microsoft::React::Networking::IWebSocketResource::Protocols protocols;
+  Microsoft::React::Networking::IWebSocketResource::Options options;
+  m_packagerWebSocketConnection->Connect(std::string{url}, protocols, options);
+}
+
+void ReactInspectorWebSocket::send(std::string_view message) {
+  m_packagerWebSocketConnection->Send(std::string{message});
+}
+
+ReactInspectorWebSocket::~ReactInspectorWebSocket() {
+  // Don't close WebSocket during shutdown - the OS will clean it up
+  // Attempting to close async during DLL unload causes thread pool failures
+  // The connection will be terminated when the process exits anyway
+}
+
+} // namespace
+
+std::unique_ptr<facebook::react::jsinspector_modern::IWebSocket>
+ReactInspectorPackagerConnectionDelegate::connectWebSocket(
+    const std::string &url,
+    std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate> delegate) {
+  return std::make_unique<ReactInspectorWebSocket>(url, delegate);
+}
+
+winrt::fire_and_forget RunWithDelayAsync(std::function<void(void)> callback, std::chrono::milliseconds delayMs) {
+  co_await winrt::resume_after(delayMs);
+  ReactInspectorThread::Instance().InvokeElsePost([callback]() { callback(); });
+}
+
+void ReactInspectorPackagerConnectionDelegate::scheduleCallback(
+    std::function<void(void)> callback,
+    std::chrono::milliseconds delayMs) {
+  RunWithDelayAsync(callback, delayMs);
+}
+
+} // namespace Microsoft::ReactNative

package/Shared/Inspector/ReactInspectorPackagerConnectionDelegate.h

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+#include <jsinspector-modern/InspectorPackagerConnection.h>
+
+namespace Microsoft::ReactNative {
+
+class ReactInspectorPackagerConnectionDelegate final
+    : public facebook::react::jsinspector_modern::InspectorPackagerConnectionDelegate {
+ public: // InspectorPackagerConnectionDelegate implementation
+  std::unique_ptr<facebook::react::jsinspector_modern::IWebSocket> connectWebSocket(
+      const std::string &url,
+      std::weak_ptr<facebook::react::jsinspector_modern::IWebSocketDelegate> delegate) override;
+
+  void scheduleCallback(std::function<void(void)> callback, std::chrono::milliseconds delayMs) override;
+};
+
+} // namespace Microsoft::ReactNative

package/Shared/Inspector/ReactInspectorThread.h

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <dispatchQueue/dispatchQueue.h>
+
+namespace Microsoft::ReactNative {
+
+class ReactInspectorThread {
+ public:
+  static Mso::DispatchQueue &Instance() {
+    static Mso::DispatchQueue queue = Mso::DispatchQueue::MakeSerialQueue();
+    return queue;
+  }
+};
+
+} // namespace Microsoft::ReactNative

package/Shared/JSI/RuntimeHolder.h

@@ -4,6 +4,7 @@
 #include <memory>
 
 #include <DevSettings.h>
+#include <jsinspector-modern/RuntimeTarget.h>
 
 namespace Microsoft::JSI {
 
@@ -18,11 +19,13 @@ struct RuntimeHolderLazyInit {
   virtual std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept = 0;
   virtual facebook::react::JSIEngineOverride getRuntimeType() noexcept = 0;
 
-  virtual void teardown() noexcept {};
-
   // You can call this when a crash happens to attempt recording additional data
   // The fileDescriptor supplied is a raw file stream an implementation might write JSON to.
   virtual void crashHandler(int fileDescriptor) noexcept {};
+
+  virtual std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> createRuntimeTargetDelegate() {
+    return nullptr;
+  }
 };
 
 } // namespace Microsoft::JSI

package/Shared/OInstance.cpp

@@ -45,7 +45,9 @@
 #include <Shlwapi.h>
 #include <WebSocketJSExecutorFactory.h>
 #include <safeint.h>
+#include "Inspector/ReactInspectorThread.h"
 #include "PackagerConnection.h"
+#include "Threading/MessageDispatchQueue.h"
 
 #if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
 #include <hermes/BytecodeVersion.h>
@@ -117,7 +119,6 @@ void LoadRemoteUrlScript(
       hermesBytecodeVersion);
 
   if (!success) {
-    devManager->UpdateBundleStatus(false, -1);
     devSettings->errorCallback(jsBundleString);
     return;
   }
@@ -125,7 +126,6 @@ void LoadRemoteUrlScript(
   int64_t currentTimeInMilliSeconds =
       std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
           .count();
-  devManager->UpdateBundleStatus(true, currentTimeInMilliSeconds);
 
   auto bundleUrl = facebook::react::DevServerHelper::get_BundleUrl(
       devSettings->sourceBundleHost,
@@ -210,11 +210,33 @@ std::unique_ptr<const facebook::react::JSBigString> JsBigStringFromPath(
 
 } // namespace Microsoft::ReactNative
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 namespace {
 
+// OJSIExecutor is needed to override getRuntimeTargetDelegate to support the modern JSI inspector.
+class OJSIExecutor : public JSIExecutor {
+ public:
+  OJSIExecutor(
+      std::shared_ptr<jsi::Runtime> runtime,
+      std::shared_ptr<ExecutorDelegate> delegate,
+      const JSIScopedTimeoutInvoker &timeoutInvoker,
+      RuntimeInstaller runtimeInstaller,
+      std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> &&targetDelegate) noexcept
+      : JSIExecutor(std::move(runtime), std::move(delegate), timeoutInvoker, std::move(runtimeInstaller)),
+        targetDelegate_(std::move(targetDelegate)) {}
+  jsinspector_modern::RuntimeTargetDelegate &getRuntimeTargetDelegate() override {
+    if (!targetDelegate_) {
+      // Use the fallback implementation from JSIExecutor.
+      return JSIExecutor::getRuntimeTargetDelegate();
+    }
+    return *targetDelegate_;
+  }
+
+ private:
+  std::shared_ptr<facebook::react::jsinspector_modern::RuntimeTargetDelegate> targetDelegate_;
+};
+
 class OJSIExecutorFactory : public JSExecutorFactory {
  public:
   std::unique_ptr<JSExecutor> createJSExecutor(
@@ -231,7 +253,7 @@ class OJSIExecutorFactory : public JSExecutorFactory {
     }
     bindNativeLogger(*runtimeHolder_->getRuntime(), logger);
 
-    return std::make_unique<JSIExecutor>(
+    return std::make_unique<OJSIExecutor>(
         runtimeHolder_->getRuntime(),
         std::move(delegate),
         JSIExecutor::defaultTimeoutInvoker,
@@ -239,7 +261,8 @@ class OJSIExecutorFactory : public JSExecutorFactory {
 #ifdef ENABLE_JS_SYSTRACE_TO_ETW
           facebook::react::tracing::initializeJSHooks(runtime, isProfiling);
 #endif
-        });
+        },
+        runtimeHolder_->createRuntimeTargetDelegate());
   }
 
   OJSIExecutorFactory(
@@ -328,20 +351,6 @@ void InstanceImpl::SetInError() noexcept {
   m_isInError = true;
 }
 
-namespace {
-bool shouldStartHermesInspector(DevSettings &devSettings) {
-  bool isHermes =
-      ((devSettings.jsiEngineOverride == JSIEngineOverride::Hermes) ||
-       (devSettings.jsiEngineOverride == JSIEngineOverride::Default && devSettings.jsiRuntimeHolder &&
-        devSettings.jsiRuntimeHolder->getRuntimeType() == facebook::react::JSIEngineOverride::Hermes));
-
-  if (isHermes && devSettings.useDirectDebugger && !devSettings.useWebDebugger)
-    return true;
-  else
-    return false;
-}
-} // namespace
-
 InstanceImpl::InstanceImpl(
     std::shared_ptr<Instance> &&instance,
     std::string &&jsBundleBasePath,
@@ -372,8 +381,9 @@ InstanceImpl::InstanceImpl(
   facebook::react::tracing::initializeETW();
 #endif
 
-  if (shouldStartHermesInspector(*m_devSettings)) {
-    m_devManager->EnsureHermesInspector(m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort);
+  if (m_devSettings->useDirectDebugger) {
+    m_devManager->EnsureInspectorPackagerConnection(
+        m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort, m_devSettings->bundleAppId);
   }
 
   // Default (common) NativeModules
@@ -483,7 +493,8 @@ InstanceImpl::InstanceImpl(
     }
   }
 
-  m_innerInstance->initializeBridge(std::move(callback), jsef, m_jsThread, m_moduleRegistry);
+  m_innerInstance->initializeBridge(
+      std::move(callback), jsef, m_jsThread, m_moduleRegistry, m_devSettings->inspectorHostTarget);
 
   // For RuntimeScheduler to work properly, we need to install TurboModuleManager with RuntimeSchedulerCallbackInvoker.
   // To be able to do that, we need to be able to call m_innerInstance->getRuntimeExecutor(), which we can only do after
@@ -586,9 +597,16 @@ void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool s
 }
 
 InstanceImpl::~InstanceImpl() {
-  if (shouldStartHermesInspector(*m_devSettings) && m_devSettings->jsiRuntimeHolder) {
-    m_devSettings->jsiRuntimeHolder->teardown();
+  if (m_devSettings->inspectorHostTarget) {
+    Mso::React::MessageDispatchQueue messageDispatchQueue{
+        ::Microsoft::ReactNative::ReactInspectorThread::Instance(), nullptr};
+    messageDispatchQueue.runOnQueueSync([weakInnerInstance = std::weak_ptr(m_innerInstance)]() {
+      if (std::shared_ptr<facebook::react::Instance> innerInstance = weakInnerInstance.lock()) {
+        innerInstance->unregisterFromInspector();
+      }
+    });
   }
+
   m_nativeQueue->quitSynchronous();
 }
 
@@ -722,5 +740,4 @@ void InstanceImpl::invokeCallback(const int64_t callbackId, folly::dynamic &&par
   m_innerInstance->callJSCallback(callbackId, std::move(params));
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react