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

package/Shared/Modules/WebSocketModule.cpp

@@ -15,10 +15,6 @@
 // fmt
 #include <fmt/format.h>
 
-// React Native
-#include <cxxreact/Instance.h>
-#include <cxxreact/JsArgumentHelpers.h>
-
 // Windows API
 #include <winrt/Windows.Security.Cryptography.h>
 
@@ -26,10 +22,6 @@
 #include <iomanip>
 
 namespace msrn = winrt::Microsoft::ReactNative;
-
-using namespace facebook::xplat;
-
-using facebook::react::Instance;
 using folly::dynamic;
 
 using std::shared_ptr;
@@ -47,284 +39,17 @@ using winrt::Windows::Security::Cryptography::CryptographicBuffer;
 
 namespace {
 using Microsoft::React::IWebSocketModuleProxy;
-using Microsoft::React::WebSocketModule;
 using Microsoft::React::Modules::SendEvent;
 using Microsoft::React::Networking::IWebSocketResource;
 
-constexpr char s_moduleName[] = "WebSocketModule";
 constexpr wchar_t s_moduleNameW[] = L"WebSocketModule";
 
 msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::WebSocketTurboModule>();
 
-const ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>>
-WebSocketModuleSharedStatePropertyId() noexcept {
-  static const ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>> prop{
-      L"WebSocketModule.SharedState"};
-  return prop;
-}
-
-static shared_ptr<IWebSocketResource>
-GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedState> weakState) {
-  auto state = weakState.lock();
-  if (!state) {
-    return nullptr;
-  }
-
-  auto itr = state->ResourceMap.find(id);
-  if (itr == state->ResourceMap.end()) {
-    if (!state->Module) {
-      return nullptr;
-    }
-    auto weakInstance = state->Module->getInstance();
-
-    shared_ptr<IWebSocketResource> ws;
-    try {
-      ws = state->ResourceFactory(std::move(url));
-    } catch (const winrt::hresult_error &e) {
-      std::stringstream ss;
-      ss << "[" << std::hex << std::showbase << std::setw(8) << static_cast<uint32_t>(e.code()) << "] "
-         << winrt::to_string(e.message());
-
-      SendEvent(weakInstance, "webSocketFailed", dynamic::object("id", id)("message", std::move(ss.str())));
-
-      return nullptr;
-    } catch (const std::exception &e) {
-      SendEvent(weakInstance, "webSocketFailed", dynamic::object("id", id)("message", e.what()));
-
-      return nullptr;
-    } catch (...) {
-      SendEvent(
-          weakInstance,
-          "webSocketFailed",
-          dynamic::object("id", id)("message", "Unidentified error creating IWebSocketResource"));
-
-      return nullptr;
-    }
-
-    ws->SetOnError([id, weakInstance](const IWebSocketResource::Error &err) {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto errorObj = dynamic::object("id", id)("message", err.Message);
-      SendEvent(weakInstance, "websocketFailed", std::move(errorObj));
-    });
-    ws->SetOnConnect([id, weakInstance]() {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id);
-      SendEvent(weakInstance, "websocketOpen", std::move(args));
-    });
-    ws->SetOnMessage(
-        [id, weakInstance, propBag = ReactPropertyBag{state->InspectableProps.try_as<IReactPropertyBag>()}](
-            size_t length, const string &message, bool isBinary) {
-          auto strongInstance = weakInstance.lock();
-          if (!strongInstance)
-            return;
-
-          auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
-          shared_ptr<Microsoft::React::IWebSocketModuleContentHandler> contentHandler;
-          if (auto prop = propBag.Get(Microsoft::React::BlobModuleContentHandlerPropertyId()))
-            contentHandler = prop.Value().lock();
-
-          if (contentHandler) {
-            if (isBinary) {
-              auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
-              winrt::com_array<uint8_t> arr;
-              CryptographicBuffer::CopyToByteArray(buffer, arr);
-              auto data = vector<uint8_t>(arr.begin(), arr.end());
-
-              contentHandler->ProcessMessage(std::move(data), args);
-            } else {
-              contentHandler->ProcessMessage(string{message}, args);
-            }
-          } else {
-            args["data"] = message;
-          }
-
-          SendEvent(weakInstance, "websocketMessage", Microsoft::React::Modules::ToDynamic(std::move(args)));
-        });
-    ws->SetOnClose([id, weakInstance](IWebSocketResource::CloseCode code, const string &reason) {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id)("code", static_cast<uint16_t>(code))("reason", reason);
-      SendEvent(weakInstance, "websocketClosed", std::move(args));
-    });
-
-    state->ResourceMap.emplace(id, ws);
-    return ws;
-  }
-
-  return itr->second;
-}
-
 } // anonymous namespace
 
 namespace Microsoft::React {
 
-#pragma region WebSocketModule
-
-WebSocketModule::WebSocketModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties)
-    : m_sharedState{std::make_shared<SharedState>()},
-      m_proxy{std::make_shared<WebSocketModuleProxy>(inspectableProperties)} {
-  m_sharedState->ResourceFactory = [](string &&url) { return IWebSocketResource::Make(); };
-  m_sharedState->Module = this;
-  m_sharedState->InspectableProps = inspectableProperties;
-
-  auto propBag = ReactPropertyBag{m_sharedState->InspectableProps.try_as<IReactPropertyBag>()};
-
-  auto proxy = weak_ptr<IWebSocketModuleProxy>{m_proxy};
-  propBag.Set(WebSocketModuleProxyPropertyId(), std::move(proxy));
-
-  auto state = weak_ptr<SharedState>{m_sharedState};
-  propBag.Set(WebSocketModuleSharedStatePropertyId(), std::move(state));
-}
-
-WebSocketModule::~WebSocketModule() noexcept /*override*/ {
-  m_sharedState->Module = nullptr;
-}
-
-void WebSocketModule::SetResourceFactory(
-    std::function<shared_ptr<IWebSocketResource>(const string &)> &&resourceFactory) {
-  m_sharedState->ResourceFactory = std::move(resourceFactory);
-}
-
-string WebSocketModule::getName() {
-  return s_moduleName;
-}
-
-std::map<string, dynamic> WebSocketModule::getConstants() {
-  return {};
-}
-
-// clang-format off
-vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMethods()
-{
-  return
-  {
-    {
-      "connect",
-      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& url, dynamic protocols, dynamic options, int64_t id
-      {
-        IWebSocketResource::Protocols protocols;
-        dynamic protocolsDynamic = jsArgAsDynamic(args, 1);
-        if (!protocolsDynamic.empty())
-        {
-          for (const auto& protocol : protocolsDynamic)
-          {
-            protocols.push_back(protocol.getString());
-          }
-        }
-
-        IWebSocketResource::Options options;
-        dynamic optionsDynamic = jsArgAsDynamic(args, 2);
-        if (!optionsDynamic.empty() && optionsDynamic.count("headers") != 0)
-        {
-          const auto& headersDynamic = optionsDynamic["headers"];
-          for (const auto& header : headersDynamic.items())
-          {
-            options.emplace(winrt::to_hstring(header.first.getString()), header.second.getString());
-          }
-        }
-
-        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 3), jsArgAsString(args, 0), weakState);
-        if (auto sharedWs = weakWs.lock())
-        {
-          sharedWs->Connect(jsArgAsString(args, 0), protocols, options);
-        }
-      }
-    },
-    {
-      "close",
-      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // [int64_t code, string reason,] int64_t id
-      {
-        // See react-native\Libraries\WebSocket\WebSocket.js:_close
-        if (args.size() == 3) // WebSocketModule.close(statusCode, closeReason, this._socketId);
-        {
-          weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 2), {}, weakState);
-          if (auto sharedWs = weakWs.lock())
-          {
-            sharedWs->Close(static_cast<IWebSocketResource::CloseCode>(jsArgAsInt(args, 0)), jsArgAsString(args, 1));
-          }
-        }
-        else if (args.size() == 1) // WebSocketModule.close(this._socketId);
-        {
-          weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 0), {}, weakState);
-          if (auto sharedWs = weakWs.lock())
-          {
-            sharedWs->Close(IWebSocketResource::CloseCode::Normal, {});
-          }
-        }
-        else
-        {
-          auto state = weakState.lock();
-          if (state && state->Module) {
-            auto errorObj = dynamic::object("id", -1)("message", "Incorrect number of parameters");
-            SendEvent(state->Module->getInstance(), "websocketFailed", std::move(errorObj));
-          }
-        }
-      }
-    },
-    {
-      "send",
-      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& message, int64_t id
-      {
-        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 1), {}, weakState);
-        if (auto sharedWs = weakWs.lock())
-        {
-          sharedWs->Send(jsArgAsString(args, 0));
-        }
-      }
-    },
-    {
-      "sendBinary",
-      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& base64String, int64_t id
-      {
-        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 1), {}, weakState);
-        if (auto sharedWs = weakWs.lock())
-        {
-          sharedWs->SendBinary(jsArgAsString(args, 0));
-        }
-      }
-    },
-    {
-      "ping",
-      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // int64_t id
-      {
-        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 0), {}, weakState);
-        if (auto sharedWs = weakWs.lock())
-        {
-          sharedWs->Ping();
-        }
-      }
-    }
-  };
-} // getMethods
-// clang-format on
-
-#pragma endregion WebSocketModule
-
-#pragma region WebSocketModuleProxy
-
-WebSocketModuleProxy::WebSocketModuleProxy(IInspectable const &inspectableProperties) noexcept
-    : m_inspectableProps{inspectableProperties} {}
-
-void WebSocketModuleProxy::SendBinary(string &&base64String, int64_t id) noexcept /*override*/ {
-  auto propBag = ReactPropertyBag{m_inspectableProps.try_as<IReactPropertyBag>()};
-  auto state = propBag.Get(WebSocketModuleSharedStatePropertyId()).Value();
-
-  weak_ptr weakWs = GetOrCreateWebSocket(id, {}, std::move(state));
-  if (auto sharedWs = weakWs.lock()) {
-    sharedWs->SendBinary(std::move(base64String));
-  }
-}
-
-#pragma endregion WebSocketModuleProxy
-
 #pragma region WebSocketTurboModule
 
 shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id, string &&url) noexcept {
@@ -513,18 +238,6 @@ void WebSocketTurboModuleProxy::SendBinary(string &&base64String, int64_t id) no
 
 #pragma region WebSocketTurboModule
 
-/*extern*/ const char *GetWebSocketModuleName() noexcept {
-  return s_moduleName;
-}
-
-/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule(
-    IInspectable const &inspectableProperties) noexcept {
-  if (auto properties = inspectableProperties.try_as<IReactPropertyBag>())
-    return std::make_unique<WebSocketModule>(properties);
-
-  return nullptr;
-}
-
 /*extern*/ const wchar_t *GetWebSocketTurboModuleName() noexcept {
   return s_moduleNameW;
 }

package/Shared/Modules/WebSocketModule.h

@@ -6,100 +6,7 @@
 #include <Modules/IWebSocketModuleProxy.h>
 #include <Networking/IWebSocketResource.h>
 
-// React Native
-#include <cxxreact/CxxModule.h>
-
 // Windows API
 #include <winrt/Windows.Foundation.h>
 
-namespace Microsoft::React {
-
-class WebSocketModuleProxy final : public IWebSocketModuleProxy {
-  // Property bag high level reference.
-  winrt::Windows::Foundation::IInspectable m_inspectableProps;
-
- public:
-  WebSocketModuleProxy(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
-
-#pragma region IWebSocketModuleProxy
-
-  void SendBinary(std::string &&base64String, int64_t id) noexcept override;
-
-#pragma endregion
-};
-
-///
-/// Realizes <c>NativeModules</c> projection.
-/// <remarks>See react-native/Libraries/WebSocket/WebSocket.js</remarks>
-///
-class WebSocketModule : public facebook::xplat::module::CxxModule {
- public:
-  enum MethodId { Connect = 0, Close = 1, Send = 2, SendBinary = 3, Ping = 4, SIZE = 5 };
-
-  WebSocketModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties);
-
-  ~WebSocketModule() noexcept override;
-
-  struct SharedState {
-    /// <summary>
-    /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
-    /// As defined in WebSocket.js.
-    /// </summary>
-    std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> ResourceMap{};
-
-    /// <summary>
-    /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
-    /// </summary>
-    std::function<std::shared_ptr<Networking::IWebSocketResource>(std::string &&)> ResourceFactory;
-
-    /// <summary>
-    /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
-    /// </summary>
-    CxxModule *Module{nullptr};
-
-    // Property bag high level reference.
-    winrt::Windows::Foundation::IInspectable InspectableProps;
-  };
-
-#pragma region CxxModule overrides
-
-  /// <summary>
-  /// <see cref="facebook::xplat::module::CxxModule::getName" />
-  /// </summary>
-  std::string getName() override;
-
-  /// <summary>
-  /// <see cref="facebook::xplat::module::CxxModule::getConstants" />
-  /// </summary>
-  std::map<std::string, folly::dynamic> getConstants() override;
-
-  /// <summary>
-  /// <see cref="facebook::xplat::module::CxxModule::getMethods" />
-  /// </summary>
-  /// <remarks>See See react-native/Libraries/WebSocket/WebSocket.js</remarks>
-  std::vector<Method> getMethods() override;
-
-#pragma endregion CxxModule overrides
-
-  void SetResourceFactory(
-      std::function<std::shared_ptr<Networking::IWebSocketResource>(const std::string &)> &&resourceFactory);
-
- private:
-  /// <summary>
-  /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
-  /// As defined in WebSocket.js.
-  /// </summary>
-  std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> m_webSockets;
-
-  /// <summary>
-  /// Keeps members that can be accessed threads other than this module's owner accessible.
-  /// </summary>
-  std::shared_ptr<SharedState> m_sharedState;
-
-  /// <summary>
-  /// Exposes a subset of the module's methods.
-  /// </summary>
-  std::shared_ptr<IWebSocketModuleProxy> m_proxy;
-};
-
-} // namespace Microsoft::React
+namespace Microsoft::React {} // namespace Microsoft::React

package/Shared/OInstance.cpp

@@ -25,11 +25,6 @@
 #include <cxxreact/MessageQueueThread.h>
 #include <cxxreact/ModuleRegistry.h>
 
-#include <Modules/ExceptionsManagerModule.h>
-#include <Modules/PlatformConstantsModule.h>
-#include <Modules/SourceCodeModule.h>
-#include <Modules/StatusBarManagerModule.h>
-
 #if (defined(_MSC_VER) && (defined(WINRT)))
 #include <Utils/LocalBundleReader.h>
 #endif
@@ -45,7 +40,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 +114,6 @@ void LoadRemoteUrlScript(
       hermesBytecodeVersion);
 
   if (!success) {
-    devManager->UpdateBundleStatus(false, -1);
     devSettings->errorCallback(jsBundleString);
     return;
   }
@@ -125,7 +121,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 +205,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 +248,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 +256,8 @@ class OJSIExecutorFactory : public JSExecutorFactory {
 #ifdef ENABLE_JS_SYSTRACE_TO_ETW
           facebook::react::tracing::initializeJSHooks(runtime, isProfiling);
 #endif
-        });
+        },
+        runtimeHolder_->createRuntimeTargetDelegate());
   }
 
   OJSIExecutorFactory(
@@ -328,20 +346,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,12 +376,12 @@ 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
-  auto modules = GetDefaultNativeModules(nativeQueue);
+  std::vector<std::unique_ptr<NativeModule>> modules;
 
   // Add app provided modules.
   for (auto &cxxModule : cxxModules) {
@@ -483,7 +487,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,115 +591,17 @@ void InstanceImpl::loadBundleInternal(std::string &&jsBundleRelativePath, bool s
 }
 
 InstanceImpl::~InstanceImpl() {
-  if (shouldStartHermesInspector(*m_devSettings) && m_devSettings->jsiRuntimeHolder) {
-    m_devSettings->jsiRuntimeHolder->teardown();
-  }
-  m_nativeQueue->quitSynchronous();
-}
-
-std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules(
-    std::shared_ptr<MessageQueueThread> nativeQueue) {
-  std::vector<std::unique_ptr<NativeModule>> modules;
-  if (m_devSettings->useTurboModulesOnly) {
-    return modules;
-  }
-
-  auto transitionalProps{ReactPropertyBagHelper::CreatePropertyBag()};
-
-  // These modules are instantiated separately in MSRN (Universal Windows).
-  // When there are module name collisions, the last one registered is used.
-  // If this code is enabled, we will have unused module instances.
-  // Also, MSRN has a different property bag mechanism incompatible with this method's transitionalProps variable.
-#if (defined(_MSC_VER) && !defined(WINRT))
-
-  // OC:8368383 - Memory leak under investigation.
-  if (!m_devSettings->useWebSocketTurboModule) {
-    modules.push_back(std::make_unique<CxxNativeModule>(
-        m_innerInstance,
-        Microsoft::React::GetWebSocketModuleName(),
-        [transitionalProps]() { return Microsoft::React::CreateWebSocketModule(transitionalProps); },
-        nativeQueue));
-  }
-
-  // Applications using the Windows ABI feature should load the networking TurboModule variants instead.
-  if (!m_devSettings->omitNetworkingCxxModules) {
-    // Use in case the host app provides its a non-Blob-compatible HTTP module.
-    if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
-      modules.push_back(std::make_unique<CxxNativeModule>(
-          m_innerInstance,
-          Microsoft::React::GetHttpModuleName(),
-          [transitionalProps]() { return Microsoft::React::CreateHttpModule(transitionalProps); },
-          nativeQueue));
-
-      modules.push_back(std::make_unique<CxxNativeModule>(
-          m_innerInstance,
-          Microsoft::React::GetBlobModuleName(),
-          [transitionalProps]() { return Microsoft::React::CreateBlobModule(transitionalProps); },
-          nativeQueue));
-
-      modules.push_back(std::make_unique<CxxNativeModule>(
-          m_innerInstance,
-          Microsoft::React::GetFileReaderModuleName(),
-          [transitionalProps]() { return Microsoft::React::CreateFileReaderModule(transitionalProps); },
-          nativeQueue));
-    }
+  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();
+      }
+    });
   }
 
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      "Timing",
-      [nativeQueue]() -> std::unique_ptr<xplat::module::CxxModule> { return react::CreateTimingModule(nativeQueue); },
-      nativeQueue));
-#endif
-
-  uint32_t hermesBytecodeVersion = 0;
-#if defined(USE_HERMES) && defined(ENABLE_DEVSERVER_HBCBUNDLES)
-  hermesBytecodeVersion = ::hermes::hbc::BYTECODE_VERSION;
-#endif
-
-  // TODO - Encapsulate this in a helpers, and make sure callers add it to their
-  // list
-  std::string bundleUrl = (m_devSettings->useWebDebugger || m_devSettings->liveReloadCallback)
-      ? DevServerHelper::get_BundleUrl(
-            m_devSettings->sourceBundleHost,
-            m_devSettings->sourceBundlePort,
-            m_devSettings->debugBundlePath,
-            m_devSettings->platformName,
-            m_devSettings->bundleAppId,
-            m_devSettings->devBundle,
-            m_devSettings->useFastRefresh,
-            m_devSettings->inlineSourceMap,
-            hermesBytecodeVersion)
-      : m_devSettings->bundleRootPath;
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      facebook::react::SourceCodeModule::Name,
-      [bundleUrl]() -> std::unique_ptr<xplat::module::CxxModule> {
-        return std::make_unique<SourceCodeModule>(bundleUrl);
-      },
-      nativeQueue));
-
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      "ExceptionsManager",
-      [redboxHandler = m_devSettings->redboxHandler]() mutable {
-        return std::make_unique<ExceptionsManagerModule>(redboxHandler);
-      },
-      nativeQueue));
-
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      PlatformConstantsModule::Name,
-      []() { return std::make_unique<PlatformConstantsModule>(); },
-      nativeQueue));
-
-  modules.push_back(std::make_unique<CxxNativeModule>(
-      m_innerInstance,
-      StatusBarManagerModule::Name,
-      []() { return std::make_unique<StatusBarManagerModule>(); },
-      nativeQueue));
-
-  return modules;
+  m_nativeQueue->quitSynchronous();
 }
 
 void InstanceImpl::RegisterForReloadIfNecessary() noexcept {
@@ -722,5 +629,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