react-native-windows 0.80.1 → 0.81.0-preview.1

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

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