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

package/Microsoft.ReactNative/ReactHost/ReactHost.cpp

@@ -8,9 +8,16 @@
 
 #include <CppRuntimeOptions.h>
 
+#include <jsinspector-modern/HostCommand.h>
+#include <jsinspector-modern/InspectorFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
 
+#include "Inspector/ReactInspectorThread.h"
+#include "ReactHost/DebuggerNotifications.h"
+
+using namespace facebook::react;
+
 namespace Mso::React {
 
 //=============================================================================================
@@ -282,6 +289,10 @@ bool ReactOptions::EnableDefaultCrashHandler() const noexcept {
   return winrt::unbox_value_or<bool>(properties.Get(EnableDefaultCrashHandlerProperty()), false);
 }
 
+//=============================================================================================
+// ReactNativeWindowsFeatureFlags implementation
+//=============================================================================================
+
 class ReactNativeWindowsFeatureFlags : public facebook::react::ReactNativeFeatureFlagsDefaults {
  public:
   bool enableBridgelessArchitecture() override {
@@ -295,9 +306,81 @@ class ReactNativeWindowsFeatureFlags : public facebook::react::ReactNativeFeatur
   bool enableCppPropsIteratorSetter() override {
     return true;
   }
+
+  bool fuseboxEnabledRelease() override {
+    return true; // Enable Fusebox (modern CDP backend) by default for React Native Windows
+  }
+
+  bool fuseboxNetworkInspectionEnabled() override {
+    return true; // Enable network inspection support in Fusebox
+  }
+};
+
+//=============================================================================================
+// ReactInspectorHostTargetDelegate implementation
+//=============================================================================================
+
+class ReactInspectorHostTargetDelegate : public jsinspector_modern::HostTargetDelegate,
+                                         public std::enable_shared_from_this<ReactInspectorHostTargetDelegate> {
+ public:
+  ReactInspectorHostTargetDelegate(Mso::WeakPtr<ReactHost> &&reactHost) noexcept : m_reactHost(std::move(reactHost)) {}
+
+  jsinspector_modern::HostTargetMetadata getMetadata() override {
+    jsinspector_modern::HostTargetMetadata metadata{};
+    metadata.integrationName = "React Native Windows (Host)";
+    metadata.platform = "windows";
+
+    if (Mso::CntPtr<ReactHost> reactHost = m_reactHost.GetStrongPtr()) {
+      const ReactOptions &options = reactHost->Options();
+      if (!options.Identity.empty()) {
+        std::string identity = options.Identity;
+        // Replace illegal characters with underscore
+        for (char &c : identity) {
+          if (c == '\\' || c == '/' || c == ':' || c == '*' || c == '?' || c == '"' || c == '<' || c == '>' ||
+              c == '|') {
+            c = '_';
+          }
+        }
+        metadata.appDisplayName = identity;
+      }
+    }
+
+    wchar_t computerName[MAX_COMPUTERNAME_LENGTH + 1];
+    DWORD size = MAX_COMPUTERNAME_LENGTH + 1;
+    if (GetComputerNameW(computerName, &size)) {
+      metadata.deviceName = winrt::to_string(computerName);
+    }
+
+    return metadata;
+  }
+
+  void onReload(jsinspector_modern::HostTargetDelegate::PageReloadRequest const &request) override {
+    if (Mso::CntPtr<ReactHost> reactHost = m_reactHost.GetStrongPtr()) {
+      reactHost->ReloadInstance();
+    }
+  }
+
+  void onSetPausedInDebuggerMessage(
+      jsinspector_modern::HostTargetDelegate::OverlaySetPausedInDebuggerMessageRequest const &request) override {
+    if (Mso::CntPtr<ReactHost> reactHost = m_reactHost.GetStrongPtr()) {
+      auto notifications = reactHost->Options().Notifications;
+      if (request.message.has_value()) {
+        ::Microsoft::ReactNative::DebuggerNotifications::OnShowDebuggerPausedOverlay(
+            notifications, request.message.value(), [weakReactHost = m_reactHost]() {
+              if (Mso::CntPtr<ReactHost> strongReactHost = weakReactHost.GetStrongPtr()) {
+                strongReactHost->OnDebuggerResume();
+              }
+            });
+      } else {
+        ::Microsoft::ReactNative::DebuggerNotifications::OnHideDebuggerPausedOverlay(notifications);
+      }
+    }
+  }
+
+ private:
+  Mso::WeakPtr<ReactHost> m_reactHost;
 };
 
-std::once_flag g_FlagInitFeatureFlags;
 //=============================================================================================
 // ReactHost implementation
 //=============================================================================================
@@ -305,9 +388,16 @@ std::once_flag g_FlagInitFeatureFlags;
 ReactHost::ReactHost(Mso::DispatchQueue const &queue) noexcept
     : Super{EnsureSerialQueue(queue)},
       m_options{Queue(), m_mutex},
-      m_notifyWhenClosed{ReactHostRegistry::Register(*this), Queue(), m_mutex} {
-  std::call_once(g_FlagInitFeatureFlags, []() noexcept {
-    facebook::react::ReactNativeFeatureFlags::override(std::make_unique<ReactNativeWindowsFeatureFlags>());
+      m_notifyWhenClosed{ReactHostRegistry::Register(*this), Queue(), m_mutex},
+      m_inspectorHostTargetDelegate{std::make_shared<ReactInspectorHostTargetDelegate>(this)},
+      m_inspectorHostTarget{
+          jsinspector_modern::HostTarget::create(*m_inspectorHostTargetDelegate, [](std::function<void()> &&callback) {
+            ::Microsoft::ReactNative::ReactInspectorThread::Instance().Post(
+                [callback = std::move(callback)]() { callback(); });
+          })} {
+  static std::once_flag initFeatureFlagsOnce;
+  std::call_once(initFeatureFlagsOnce, []() noexcept {
+    ReactNativeFeatureFlags::override(std::make_unique<ReactNativeWindowsFeatureFlags>());
   });
 }
 
@@ -319,15 +409,16 @@ void ReactHost::Finalize() noexcept {
   // Since each AsyncAction has a strong ref count to ReactHost, the AsyncActionQueue must be empty.
   // Thus, we only need to call UnloadInQueue to unload ReactInstance if the ReactHost is not closed yet.
   if (Mso::Promise<void> notifyWhenClosed = m_notifyWhenClosed.Exchange(nullptr)) {
-    UnloadInQueue(0).Then<Mso::Executors::Inline>(
-        [notifyWhenClosed = std::move(notifyWhenClosed)]() noexcept { notifyWhenClosed.TrySetValue(); });
+    UnloadInQueue(UnloadReason::CloseHost, 0)
+        .Then<Mso::Executors::Inline>(
+            [notifyWhenClosed = std::move(notifyWhenClosed)]() noexcept { notifyWhenClosed.TrySetValue(); });
   }
 }
 
 void ReactHost::Close() noexcept {
   InvokeInQueue([this]() noexcept {
     // Put the ReactHost to the closed state, unload ReactInstance, and notify the closing Promise.
-    auto whenClosed = m_actionQueue.Load()->PostAction(MakeUnloadInstanceAction());
+    auto whenClosed = m_actionQueue.Load()->PostAction(MakeUnloadInstanceAction(UnloadReason::CloseHost));
 
     // After we set the m_notifyWhenClosed to null, the ReactHost is considered to be closed.
     Mso::SetPromiseValue(m_notifyWhenClosed.Exchange(nullptr), std::move(whenClosed));
@@ -379,12 +470,14 @@ Mso::Future<void> ReactHost::ReloadInstance() noexcept {
 
 Mso::Future<void> ReactHost::ReloadInstanceWithOptions(ReactOptions &&options) noexcept {
   return PostInQueue([this, options = std::move(options)]() mutable noexcept {
-    return m_actionQueue.Load()->PostActions({MakeUnloadInstanceAction(), MakeLoadInstanceAction(std::move(options))});
+    return m_actionQueue.Load()->PostActions(
+        {MakeUnloadInstanceAction(UnloadReason::Unload), MakeLoadInstanceAction(std::move(options))});
   });
 }
 
 Mso::Future<void> ReactHost::UnloadInstance() noexcept {
-  return PostInQueue([this]() noexcept { return m_actionQueue.Load()->PostAction(MakeUnloadInstanceAction()); });
+  return PostInQueue(
+      [this]() noexcept { return m_actionQueue.Load()->PostAction(MakeUnloadInstanceAction(UnloadReason::Unload)); });
 }
 
 AsyncAction ReactHost::MakeLoadInstanceAction(ReactOptions &&options) noexcept {
@@ -393,11 +486,13 @@ AsyncAction ReactHost::MakeLoadInstanceAction(ReactOptions &&options) noexcept {
   };
 }
 
-AsyncAction ReactHost::MakeUnloadInstanceAction() noexcept {
+AsyncAction ReactHost::MakeUnloadInstanceAction(UnloadReason reason) noexcept {
   Mso::Internal::VerifyIsInQueueElseCrash(Queue());
   size_t unloadActionId = ++m_nextUnloadActionId;
   m_pendingUnloadActionId = unloadActionId;
-  return [spThis = Mso::CntPtr{this}, unloadActionId]() noexcept { return spThis->UnloadInQueue(unloadActionId); };
+  return [spThis = Mso::CntPtr{this}, reason, unloadActionId]() noexcept {
+    return spThis->UnloadInQueue(reason, unloadActionId);
+  };
 }
 
 Mso::CntPtr<IReactViewHost> ReactHost::MakeViewHost(ReactViewOptions &&options) noexcept {
@@ -428,6 +523,18 @@ Mso::Future<void> ReactHost::LoadInQueue(ReactOptions &&options) noexcept {
     return Mso::MakeCanceledFuture();
   }
 
+  // Start or stop inspector page if needed.
+  // Make sure to update the both copies of options.
+  if (IsInspectable()) {
+    AddInspectorPage();
+    options.InspectorHostTarget = m_inspectorHostTarget.get();
+    m_options.Load().InspectorHostTarget = m_inspectorHostTarget.get();
+  } else {
+    RemoveInspectorPage();
+    options.InspectorHostTarget = nullptr;
+    m_options.Load().InspectorHostTarget = nullptr;
+  }
+
   Mso::Promise<void> whenCreated;
   Mso::Promise<void> whenLoaded;
 
@@ -463,7 +570,7 @@ Mso::Future<void> ReactHost::LoadInQueue(ReactOptions &&options) noexcept {
   });
 }
 
-Mso::Future<void> ReactHost::UnloadInQueue(size_t unloadActionId) noexcept {
+Mso::Future<void> ReactHost::UnloadInQueue(UnloadReason reason, size_t unloadActionId) noexcept {
   Mso::Internal::VerifyIsInQueueElseCrash(Queue());
 
   // If the pending unload action Id does not match, then we have newer unload action,
@@ -485,21 +592,25 @@ Mso::Future<void> ReactHost::UnloadInQueue(size_t unloadActionId) noexcept {
 
   // We unload ReactInstance after all view instances are unloaded.
   // It is safe to capture 'this' because the Unload action keeps a strong reference to ReactHost.
-  return Mso::WhenAllCompleted(unloadCompletionList).Then(m_executor, [this](Mso::Maybe<void> && /*value*/) noexcept {
-    Mso::Future<void> onUnloaded;
-    if (auto reactInstance = m_reactInstance.Exchange(nullptr)) {
-      onUnloaded = reactInstance->Destroy();
-    }
-
-    m_isInstanceUnloading.Store(false);
-    m_lastError.Store({});
-
-    if (!onUnloaded) {
-      onUnloaded = Mso::MakeSucceededFuture();
-    }
-
-    return onUnloaded;
-  });
+  return Mso::WhenAllCompleted(unloadCompletionList)
+      .Then(m_executor, [this, reason](Mso::Maybe<void> && /*value*/) noexcept {
+        Mso::Future<void> onUnloaded;
+        if (auto reactInstance = m_reactInstance.Exchange(nullptr)) {
+          onUnloaded = reactInstance->Destroy();
+        }
+
+        m_isInstanceUnloading.Store(false);
+        m_lastError.Store({});
+
+        if (!onUnloaded) {
+          onUnloaded = Mso::MakeSucceededFuture();
+        }
+
+        if (reason == UnloadReason::CloseHost) {
+          RemoveInspectorPage();
+        }
+        return onUnloaded;
+      });
 }
 
 void ReactHost::ForEachViewHost(const Mso::FunctorRef<void(ReactViewHost &)> &action) noexcept {
@@ -528,6 +639,65 @@ void ReactHost::DetachViewHost(ReactViewHost &viewHost) noexcept {
   viewHosts.erase(it);
 }
 
+bool ReactHost::IsInspectable() noexcept {
+  ReactOptions &options = m_options.Load();
+  return options.JsiEngine() == JSIEngine::Hermes && options.UseDirectDebugger();
+}
+
+void ReactHost::AddInspectorPage() noexcept {
+  std::optional<int32_t> &inspectorPageId = m_inspectorPageId.Load();
+  if (inspectorPageId.has_value())
+    return;
+
+  jsinspector_modern::InspectorTargetCapabilities capabilities;
+  capabilities.nativePageReloads = true;
+  capabilities.prefersFuseboxFrontend = true;
+
+  auto metadata = m_inspectorHostTargetDelegate->getMetadata();
+  std::string pageName;
+  if (metadata.appDisplayName.has_value() && !metadata.appDisplayName.value().empty()) {
+    pageName = metadata.appDisplayName.value();
+  } else {
+    pageName = "React Native Windows (Experimental)";
+  }
+  if (metadata.deviceName.has_value() && !metadata.deviceName.value().empty()) {
+    pageName += " (" + metadata.deviceName.value() + ")";
+  }
+
+  inspectorPageId = jsinspector_modern::getInspectorInstance().addPage(
+      pageName,
+      "Hermes",
+      [weakInspectorHostTarget =
+           std::weak_ptr(m_inspectorHostTarget)](std::unique_ptr<jsinspector_modern::IRemoteConnection> remote)
+          -> std::unique_ptr<jsinspector_modern::ILocalConnection> {
+        if (std::shared_ptr<jsinspector_modern::HostTarget> inspectorHostTarget = weakInspectorHostTarget.lock()) {
+          return inspectorHostTarget->connect(std::move(remote));
+        }
+
+        // This can happen if we're about to shut down. Reject the connection.
+        return nullptr;
+      },
+      capabilities);
+}
+
+void ReactHost::RemoveInspectorPage() noexcept {
+  std::optional<int32_t> &inspectorPageId = m_inspectorPageId.Load();
+  if (!inspectorPageId.has_value())
+    return;
+
+  jsinspector_modern::getInspectorInstance().removePage(*inspectorPageId);
+  inspectorPageId.reset();
+}
+
+void ReactHost::OnDebuggerResume() noexcept {
+  ::Microsoft::ReactNative::ReactInspectorThread::Instance().Post(
+      [weakInspectorHostTarget = std::weak_ptr(m_inspectorHostTarget)]() {
+        if (std::shared_ptr<jsinspector_modern::HostTarget> inspectorHostTarget = weakInspectorHostTarget.lock()) {
+          inspectorHostTarget->sendCommand(jsinspector_modern::HostCommand::DebuggerResume);
+        }
+      });
+}
+
 //=============================================================================================
 // ReactViewHost implementation
 //=============================================================================================
@@ -579,8 +749,8 @@ Mso::Future<void> ReactViewHost::AttachViewInstance(IReactViewInstance &viewInst
     m_reactHost->AttachViewHost(*this);
 
     return InitViewInstanceInQueue();
-    //// Schedule the viewInstance load in the action queue since there can be other load actions in the queue that need
-    //// to be consolidated.
+    // Schedule the viewInstance load in the action queue since there can be other load actions in the queue that need
+    // to be consolidated.
     // return m_actionQueue.Load()->PostAction(MakeInitViewInstanceAction());
   });
 }

package/Microsoft.ReactNative/ReactHost/ReactHost.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <jsinspector-modern/HostTarget.h>
 #include <mutex>
 #include <unordered_map>
 #include "AsyncActionQueue.h"
@@ -15,6 +16,7 @@
 
 namespace Mso::React {
 
+class ReactInspectorHostTargetDelegate;
 class ReactViewHost;
 
 //! ReactHost manages lifetime of ReactNative instance.
@@ -52,9 +54,6 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
 
   Mso::CntPtr<AsyncActionQueue> ActionQueue() const noexcept;
 
-  Mso::Future<void> LoadInQueue(ReactOptions &&options) noexcept;
-  Mso::Future<void> UnloadInQueue(size_t unloadActionId) noexcept;
-
   void Close() noexcept;
   bool IsClosed() const noexcept;
 
@@ -64,6 +63,12 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   template <class TCallback>
   Mso::Future<void> PostInQueue(TCallback &&callback) noexcept;
 
+ private:
+  enum class UnloadReason {
+    Unload,
+    CloseHost,
+  };
+
  private:
   friend MakePolicy;
   ReactHost(Mso::DispatchQueue const &queue) noexcept;
@@ -75,9 +80,18 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   void ForEachViewHost(const Mso::FunctorRef<void(ReactViewHost &)> &action) noexcept;
 
   AsyncAction MakeLoadInstanceAction(ReactOptions &&options) noexcept;
-  AsyncAction MakeUnloadInstanceAction() noexcept;
+  AsyncAction MakeUnloadInstanceAction(UnloadReason reason) noexcept;
+
+  Mso::Future<void> LoadInQueue(ReactOptions &&options) noexcept;
+  Mso::Future<void> UnloadInQueue(UnloadReason reason, size_t unloadActionId) noexcept;
+
+  void OnDebuggerResume() noexcept;
+  bool IsInspectable() noexcept;
+  void AddInspectorPage() noexcept;
+  void RemoveInspectorPage() noexcept;
 
  private:
+  friend class ReactInspectorHostTargetDelegate;
   mutable std::mutex m_mutex;
   const Mso::InvokeElsePostExecutor m_executor{Queue()};
   const Mso::ActiveReadableField<Mso::CntPtr<AsyncActionQueue>> m_actionQueue{
@@ -92,6 +106,10 @@ class ReactHost final : public Mso::ActiveObject<IReactHost> {
   size_t m_pendingUnloadActionId{0};
   size_t m_nextUnloadActionId{0};
   const Mso::ActiveField<bool> m_isInstanceUnloading{false, Queue()};
+
+  const std::shared_ptr<facebook::react::jsinspector_modern::HostTargetDelegate> m_inspectorHostTargetDelegate;
+  const std::shared_ptr<facebook::react::jsinspector_modern::HostTarget> m_inspectorHostTarget;
+  const Mso::ActiveField<std::optional<int32_t>> m_inspectorPageId{Queue()};
 };
 
 //! Implements a cross-platform host for a React view

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -66,6 +66,7 @@
 #include <react/runtime/PlatformTimerRegistry.h>
 #include <react/runtime/TimerManager.h>
 #include <react/threading/MessageQueueThreadImpl.h>
+#include "Inspector/ReactInspectorThread.h"
 #endif
 
 #if !defined(CORE_ABI) && !defined(USE_FABRIC)
@@ -391,7 +392,7 @@ void ReactInstanceWin::LoadModules(
       L"NativeAnimatedModule",
       winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::NativeAnimatedModule>());
 
-#elif defined(CORE_ABI) && defined(USE_FABRIC)
+#else
   if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
     registerTurboModule(
         L"ImageLoader",
@@ -410,43 +411,41 @@ void ReactInstanceWin::LoadModules(
         false);
   }
 
-  if (devSettings->useTurboModulesOnly) {
-    ::Microsoft::ReactNative::ExceptionsManager::SetRedBoxHander(
-        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), m_redboxHandler);
-    registerTurboModule(
-        L"ExceptionsManager",
-        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ExceptionsManager>());
+  ::Microsoft::ReactNative::ExceptionsManager::SetRedBoxHander(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), m_redboxHandler);
+  registerTurboModule(
+      L"ExceptionsManager",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::ExceptionsManager>());
 
-    registerTurboModule(
-        L"StatusBarManager",
-        winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::StatusBarManager>());
+  registerTurboModule(
+      L"StatusBarManager",
+      winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::StatusBarManager>());
 
-    registerTurboModule(
-        L"PlatformConstants",
-        winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::PlatformConstants>());
-    uint32_t hermesBytecodeVersion = 0;
+  registerTurboModule(
+      L"PlatformConstants",
+      winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::PlatformConstants>());
+  uint32_t hermesBytecodeVersion = 0;
 #if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
-    hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
+  hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
 #endif
 
-    std::string bundleUrl = (devSettings->useWebDebugger || devSettings->liveReloadCallback)
-        ? facebook::react::DevServerHelper::get_BundleUrl(
-              devSettings->sourceBundleHost,
-              devSettings->sourceBundlePort,
-              devSettings->debugBundlePath,
-              devSettings->platformName,
-              devSettings->bundleAppId,
-              devSettings->devBundle,
-              devSettings->useFastRefresh,
-              devSettings->inlineSourceMap,
-              hermesBytecodeVersion)
-        : devSettings->bundleRootPath;
-    ::Microsoft::ReactNative::SourceCode::SetScriptUrl(
-        winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), bundleUrl);
+  std::string bundleUrl = (devSettings->useWebDebugger || devSettings->liveReloadCallback)
+      ? facebook::react::DevServerHelper::get_BundleUrl(
+            devSettings->sourceBundleHost,
+            devSettings->sourceBundlePort,
+            devSettings->debugBundlePath,
+            devSettings->platformName,
+            devSettings->bundleAppId,
+            devSettings->devBundle,
+            devSettings->useFastRefresh,
+            devSettings->inlineSourceMap,
+            hermesBytecodeVersion)
+      : devSettings->bundleRootPath;
+  ::Microsoft::ReactNative::SourceCode::SetScriptUrl(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()), bundleUrl);
 
-    registerTurboModule(
-        L"SourceCode", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::SourceCode>());
-  }
+  registerTurboModule(
+      L"SourceCode", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::SourceCode>());
 
   registerTurboModule(
       L"DevSettings", winrt::Microsoft::ReactNative::MakeTurboModuleProvider<::Microsoft::ReactNative::DevSettings>());
@@ -462,13 +461,10 @@ void ReactInstanceWin::LoadModules(
   registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Timing>());
 #else
 
-#if defined(USE_FABRIC)
   if (Microsoft::ReactNative::IsFabricEnabled(m_reactContext->Properties())) {
     registerTurboModule(
         L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::Microsoft::ReactNative::Timing>());
-  } else
-#endif
-  {
+  } else {
     registerTurboModule(L"Timing", winrt::Microsoft::ReactNative::MakeModuleProvider<::facebook::react::Timing>());
   }
 #endif
@@ -476,14 +472,12 @@ void ReactInstanceWin::LoadModules(
   registerTurboModule(
       ::Microsoft::React::GetWebSocketTurboModuleName(), ::Microsoft::React::GetWebSocketModuleProvider());
 
-  if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
-    registerTurboModule(::Microsoft::React::GetHttpTurboModuleName(), ::Microsoft::React::GetHttpModuleProvider());
+  registerTurboModule(::Microsoft::React::GetHttpTurboModuleName(), ::Microsoft::React::GetHttpModuleProvider());
 
-    registerTurboModule(::Microsoft::React::GetBlobTurboModuleName(), ::Microsoft::React::GetBlobModuleProvider());
+  registerTurboModule(::Microsoft::React::GetBlobTurboModuleName(), ::Microsoft::React::GetBlobModuleProvider());
 
-    registerTurboModule(
-        ::Microsoft::React::GetFileReaderTurboModuleName(), ::Microsoft::React::GetFileReaderModuleProvider());
-  }
+  registerTurboModule(
+      ::Microsoft::React::GetFileReaderTurboModuleName(), ::Microsoft::React::GetFileReaderModuleProvider());
 }
 
 //! Initialize() is called from the native queue.
@@ -553,6 +547,8 @@ std::shared_ptr<facebook::react::DevSettings> ReactInstanceWin::CreateDevSetting
 
   devSettings->useRuntimeScheduler = useRuntimeScheduler;
 
+  devSettings->inspectorHostTarget = m_options.InspectorHostTarget;
+
   return devSettings;
 }
 
@@ -634,7 +630,6 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
       strongThis->Queue().Post([this, weakThis]() noexcept {
         if (auto strongThis = weakThis.GetStrongPtr()) {
           auto devSettings = strongThis->CreateDevSettings();
-          devSettings->useTurboModulesOnly = true;
 
           try {
             if (devSettings->useFastRefresh || devSettings->liveReloadCallback) {
@@ -664,16 +659,21 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
               };
 
               if (devSettings->useDirectDebugger) {
-                ::Microsoft::ReactNative::GetSharedDevManager()->EnsureHermesInspector(
-                    devSettings->sourceBundleHost, devSettings->sourceBundlePort);
+                ::Microsoft::ReactNative::GetSharedDevManager()->EnsureInspectorPackagerConnection(
+                    devSettings->sourceBundleHost, devSettings->sourceBundlePort, devSettings->bundleAppId);
               }
 
               m_jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
                   devSettings, jsMessageThread, CreatePreparedScriptStore());
               auto jsRuntime = std::make_unique<Microsoft::ReactNative::HermesJSRuntime>(m_jsiRuntimeHolder);
               jsRuntime->getRuntime();
-              m_bridgelessReactInstance = std::make_unique<facebook::react::ReactInstance>(
-                  std::move(jsRuntime), jsMessageThread, timerManager, jsErrorHandlingFunc);
+
+              m_bridgelessReactInstance = std::make_shared<facebook::react::ReactInstance>(
+                  std::move(jsRuntime),
+                  jsMessageThread,
+                  timerManager,
+                  jsErrorHandlingFunc,
+                  m_options.InspectorHostTarget);
 
               auto bufferedRuntimeExecutor = m_bridgelessReactInstance->getBufferedRuntimeExecutor();
               timerManager->setRuntimeExecutor(bufferedRuntimeExecutor);
@@ -695,6 +695,7 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
                 winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
 
             facebook::react::ReactInstance::JSRuntimeFlags options;
+
             m_bridgelessReactInstance->initializeRuntime(
                 options,
                 [=, onCreated = m_options.OnInstanceCreated, reactContext = m_reactContext](
@@ -748,7 +749,6 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
 
             LoadJSBundlesBridgeless(devSettings);
             SetupHMRClient();
-
           } catch (std::exception &e) {
             OnErrorWithMessage(e.what());
             OnErrorWithMessage("ReactInstanceWin: Failed to create React Instance.");
@@ -810,9 +810,7 @@ void ReactInstanceWin::InitializeWithBridge() noexcept {
             return propValue.value_or(defaultValue);
           };
 
-          devSettings->omitNetworkingCxxModules = getBoolProperty(nullptr, L"OmitNetworkingCxxModules", false);
           devSettings->useWebSocketTurboModule = getBoolProperty(nullptr, L"UseWebSocketTurboModule", false);
-          devSettings->useTurboModulesOnly = getBoolProperty(L"DevSettings", L"UseTurboModulesOnly", false);
 
           std::vector<facebook::react::NativeModuleDescription> cxxModules;
           auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
@@ -1092,6 +1090,17 @@ Mso::Future<void> ReactInstanceWin::Destroy() noexcept {
   if (m_bridgelessReactInstance) {
     if (auto jsMessageThread = m_jsMessageThread.Exchange(nullptr)) {
       jsMessageThread->runOnQueueSync([&]() noexcept {
+        // Unregister from inspector BEFORE shutting down JS thread
+        if (m_bridgelessReactInstance && m_options.InspectorHostTarget) {
+          Mso::React::MessageDispatchQueue messageDispatchQueue{
+              ::Microsoft::ReactNative::ReactInspectorThread::Instance(), nullptr};
+          messageDispatchQueue.runOnQueueSync(
+              [weakBridgelessReactInstance = std::weak_ptr(m_bridgelessReactInstance)]() {
+                if (auto bridgelessReactInstance = weakBridgelessReactInstance.lock()) {
+                  bridgelessReactInstance->unregisterFromInspector();
+                }
+              });
+        }
         {
           // Release the JSI runtime
           std::scoped_lock lock{m_mutex};
@@ -1514,8 +1523,15 @@ void ReactInstanceWin::DetachRootView(facebook::react::IReactRootView *rootView,
     CallJsFunction("AppRegistry", "unmountApplicationComponentAtRootTag", std::move(params));
   }
 
-  // Give the JS thread time to finish executing
-  m_jsMessageThread.Load()->runOnQueueSync([]() {});
+  // QUIRK: Legacy sync behavior can be re-enabled via EnableSyncDetachRootView option
+  // The sync call was removed to prevent deadlocks with Hermes GC operations
+  bool useSyncCall = winrt::Microsoft::ReactNative::implementation::QuirkSettings::GetUseRunOnQueueSync(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()));
+  if (useSyncCall) {
+    // Legacy behavior: wait for JS thread to finish executing (can cause deadlocks)
+    m_jsMessageThread.Load()->runOnQueueSync([]() {});
+  }
+  // Default behavior: no synchronization call to prevent deadlocks
 }
 
 Mso::CntPtr<IReactInstanceInternal> MakeReactInstance(

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -205,7 +205,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
 
 #ifdef USE_FABRIC
   // Bridgeless
-  std::unique_ptr<facebook::react::ReactInstance> m_bridgelessReactInstance;
+  std::shared_ptr<facebook::react::ReactInstance> m_bridgelessReactInstance;
 #endif
 
   std::atomic<ReactInstanceState> m_state{ReactInstanceState::Loading};