react-native-windows 0.65.2 → 0.65.6

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -350,168 +350,174 @@ void ReactInstanceWin::Initialize() noexcept {
   });
 #endif
 
-  Mso::PostFuture(m_uiQueue, [weakThis = Mso::WeakPtr{this}]() noexcept {
-#ifndef CORE_ABI
+  m_uiQueue->Post([this, weakThis = Mso::WeakPtr{this}]() noexcept {
     // Objects that must be created on the UI thread
     if (auto strongThis = weakThis.GetStrongPtr()) {
+#ifndef CORE_ABI
       strongThis->m_appTheme = std::make_shared<Microsoft::ReactNative::AppTheme>(
           strongThis->GetReactContext(), strongThis->m_uiMessageThread.LoadWithLock());
       Microsoft::ReactNative::I18nManager::InitI18nInfo(
           winrt::Microsoft::ReactNative::ReactPropertyBag(strongThis->Options().Properties));
       strongThis->m_appearanceListener = Mso::Make<Microsoft::ReactNative::AppearanceChangeListener>(
-          strongThis->GetReactContext(), strongThis->m_uiQueue);
-
+          strongThis->GetReactContext(), *(strongThis->m_uiQueue));
       Microsoft::ReactNative::DeviceInfoHolder::InitDeviceInfoHolder(strongThis->GetReactContext());
-    }
 #endif
-  }).Then(Queue(), [this, weakThis = Mso::WeakPtr{this}]() noexcept {
-    if (auto strongThis = weakThis.GetStrongPtr()) {
-      // auto cxxModulesProviders = GetCxxModuleProviders();
-
-      auto devSettings = std::make_shared<facebook::react::DevSettings>();
-      devSettings->useJITCompilation = m_options.EnableJITCompilation;
-      devSettings->sourceBundleHost = SourceBundleHost();
-      devSettings->sourceBundlePort = SourceBundlePort();
-      devSettings->debugBundlePath = DebugBundlePath();
-      devSettings->liveReloadCallback = GetLiveReloadCallback();
-      devSettings->errorCallback = GetErrorCallback();
-      devSettings->loggingCallback = GetLoggingCallback();
-      m_redboxHandler = devSettings->redboxHandler = std::move(GetRedBoxHandler());
-      devSettings->useDirectDebugger = m_useDirectDebugger;
-      devSettings->debuggerBreakOnNextLine = m_debuggerBreakOnNextLine;
-      devSettings->debuggerPort = m_options.DeveloperSettings.DebuggerPort;
-      devSettings->debuggerRuntimeName = m_options.DeveloperSettings.DebuggerRuntimeName;
-      devSettings->useWebDebugger = m_useWebDebugger;
-      devSettings->useFastRefresh = m_isFastReloadEnabled;
-      // devSettings->memoryTracker = GetMemoryTracker();
-      devSettings->bundleRootPath = BundleRootPath();
-
-      devSettings->waitingForDebuggerCallback = GetWaitingForDebuggerCallback();
-      devSettings->debuggerAttachCallback = GetDebuggerAttachCallback();
-#ifndef CORE_ABI
-      devSettings->showDevMenuCallback = [weakThis]() noexcept {
+
+      strongThis->Queue().Post([this, weakThis]() noexcept {
         if (auto strongThis = weakThis.GetStrongPtr()) {
-          strongThis->m_uiQueue.Post([context = strongThis->m_reactContext]() {
-            Microsoft::ReactNative::DevMenuManager::Show(context->Properties());
-          });
-        }
-      };
+          // auto cxxModulesProviders = GetCxxModuleProviders();
+
+          auto devSettings = std::make_shared<facebook::react::DevSettings>();
+          devSettings->useJITCompilation = m_options.EnableJITCompilation;
+          devSettings->sourceBundleHost = SourceBundleHost();
+          devSettings->sourceBundlePort = SourceBundlePort();
+          devSettings->debugBundlePath = DebugBundlePath();
+          devSettings->liveReloadCallback = GetLiveReloadCallback();
+          devSettings->errorCallback = GetErrorCallback();
+          devSettings->loggingCallback = GetLoggingCallback();
+          m_redboxHandler = devSettings->redboxHandler = std::move(GetRedBoxHandler());
+          devSettings->useDirectDebugger = m_useDirectDebugger;
+          devSettings->debuggerBreakOnNextLine = m_debuggerBreakOnNextLine;
+          devSettings->debuggerPort = m_options.DeveloperSettings.DebuggerPort;
+          devSettings->debuggerRuntimeName = m_options.DeveloperSettings.DebuggerRuntimeName;
+          devSettings->useWebDebugger = m_useWebDebugger;
+          devSettings->useFastRefresh = m_isFastReloadEnabled;
+          // devSettings->memoryTracker = GetMemoryTracker();
+          devSettings->bundleRootPath = BundleRootPath();
+
+          devSettings->waitingForDebuggerCallback = GetWaitingForDebuggerCallback();
+          devSettings->debuggerAttachCallback = GetDebuggerAttachCallback();
+
+#ifndef CORE_ABI
+          devSettings->showDevMenuCallback = [weakThis]() noexcept {
+            if (auto strongThis = weakThis.GetStrongPtr()) {
+              strongThis->m_uiQueue->Post([context = strongThis->m_reactContext]() {
+                Microsoft::ReactNative::DevMenuManager::Show(context->Properties());
+              });
+            }
+          };
 #endif
 
-      // Now that ReactNativeWindows is building outside devmain, it is missing
-      // fix given by PR https://github.com/microsoft/react-native-windows/pull/2624 causing
-      // regression. We're turning off console redirection till the fix is available in devmain.
-      // Bug https://office.visualstudio.com/DefaultCollection/OC/_workitems/edit/3441551 is tracking this
-      devSettings->debuggerConsoleRedirection = false; // JSHost::ChangeGate::ChakraCoreDebuggerConsoleRedirection();
+          // Now that ReactNativeWindows is building outside devmain, it is missing
+          // fix given by PR https://github.com/microsoft/react-native-windows/pull/2624 causing
+          // regression. We're turning off console redirection till the fix is available in devmain.
+          // Bug https://office.visualstudio.com/DefaultCollection/OC/_workitems/edit/3441551 is tracking this
+          devSettings->debuggerConsoleRedirection =
+              false; // JSHost::ChangeGate::ChakraCoreDebuggerConsoleRedirection();
 
 #ifdef CORE_ABI
-      std::vector<facebook::react::NativeModuleDescription> cxxModules;
+          std::vector<facebook::react::NativeModuleDescription> cxxModules;
 #else
-      // Acquire default modules and then populate with custom modules.
-      // Note that some of these have custom thread affinity.
-      std::vector<facebook::react::NativeModuleDescription> cxxModules = Microsoft::ReactNative::GetCoreModules(
-          m_batchingUIThread,
-          m_jsMessageThread.Load(),
-          std::move(m_appTheme),
-          std::move(m_appearanceListener),
-          m_reactContext);
+          // Acquire default modules and then populate with custom modules.
+          // Note that some of these have custom thread affinity.
+          std::vector<facebook::react::NativeModuleDescription> cxxModules = Microsoft::ReactNative::GetCoreModules(
+              m_batchingUIThread,
+              m_jsMessageThread.Load(),
+              std::move(m_appTheme),
+              std::move(m_appearanceListener),
+              m_reactContext);
 #endif
 
-      auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
+          auto nmp = std::make_shared<winrt::Microsoft::ReactNative::NativeModulesProvider>();
 
-      LoadModules(nmp, m_options.TurboModuleProvider);
+          LoadModules(nmp, m_options.TurboModuleProvider);
 
-      auto modules = nmp->GetModules(m_reactContext, m_jsMessageThread.Load());
-      cxxModules.insert(
-          cxxModules.end(), std::make_move_iterator(modules.begin()), std::make_move_iterator(modules.end()));
+          auto modules = nmp->GetModules(m_reactContext, m_jsMessageThread.Load());
+          cxxModules.insert(
+              cxxModules.end(), std::make_move_iterator(modules.begin()), std::make_move_iterator(modules.end()));
 
-      if (m_options.ModuleProvider != nullptr) {
-        std::vector<facebook::react::NativeModuleDescription> customCxxModules =
-            m_options.ModuleProvider->GetModules(m_reactContext, m_jsMessageThread.Load());
-        cxxModules.insert(std::end(cxxModules), std::begin(customCxxModules), std::end(customCxxModules));
-      }
+          if (m_options.ModuleProvider != nullptr) {
+            std::vector<facebook::react::NativeModuleDescription> customCxxModules =
+                m_options.ModuleProvider->GetModules(m_reactContext, m_jsMessageThread.Load());
+            cxxModules.insert(std::end(cxxModules), std::begin(customCxxModules), std::end(customCxxModules));
+          }
 
-      std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
-      std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
+          std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
+          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
 
-      switch (m_options.JsiEngine) {
-        case JSIEngine::Hermes:
+          switch (m_options.JsiEngine) {
+            case JSIEngine::Hermes:
 #if defined(USE_HERMES)
-          devSettings->jsiRuntimeHolder =
-              std::make_shared<facebook::react::HermesRuntimeHolder>(devSettings, m_jsMessageThread.Load());
-          devSettings->inlineSourceMap = false;
-          break;
+              devSettings->jsiRuntimeHolder =
+                  std::make_shared<facebook::react::HermesRuntimeHolder>(devSettings, m_jsMessageThread.Load());
+              devSettings->inlineSourceMap = false;
+              break;
 #endif
-        case JSIEngine::V8:
+            case JSIEngine::V8:
 #if defined(USE_V8)
 #ifndef CORE_ABI
-          preparedScriptStore =
-              std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationLocalFolder());
+              preparedScriptStore =
+                  std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationLocalFolder());
 #endif // CORE_ABI
-          devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
-              devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
-          break;
+              devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
+                  devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
+              break;
 #endif // USE_V8
-        case JSIEngine::Chakra:
+            case JSIEngine::Chakra:
 #ifndef CORE_ABI
-          if (m_options.EnableByteCodeCaching || !m_options.ByteCodeFileUri.empty()) {
-            scriptStore = std::make_unique<Microsoft::ReactNative::UwpScriptStore>();
-            preparedScriptStore = std::make_unique<Microsoft::ReactNative::UwpPreparedScriptStore>(
-                winrt::to_hstring(m_options.ByteCodeFileUri));
-          }
+              if (m_options.EnableByteCodeCaching || !m_options.ByteCodeFileUri.empty()) {
+                scriptStore = std::make_unique<Microsoft::ReactNative::UwpScriptStore>();
+                preparedScriptStore = std::make_unique<Microsoft::ReactNative::UwpPreparedScriptStore>(
+                    winrt::to_hstring(m_options.ByteCodeFileUri));
+              }
 #endif
-          devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::JSI::ChakraRuntimeHolder>(
-              devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
-          break;
-      }
+              devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::JSI::ChakraRuntimeHolder>(
+                  devSettings, m_jsMessageThread.Load(), std::move(scriptStore), std::move(preparedScriptStore));
+              break;
+          }
 
-      m_jsiRuntimeHolder = devSettings->jsiRuntimeHolder;
-
-      try {
-        // We need to keep the instance wrapper alive as its destruction shuts down the native queue.
-        m_options.TurboModuleProvider->SetReactContext(
-            winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
-        auto bundleRootPath = devSettings->bundleRootPath;
-        auto instanceWrapper = facebook::react::CreateReactInstance(
-            std::shared_ptr<facebook::react::Instance>(strongThis->m_instance.Load()),
-            std::move(bundleRootPath), // bundleRootPath
-            std::move(cxxModules),
-            m_options.TurboModuleProvider,
-            std::make_unique<BridgeUIBatchInstanceCallback>(weakThis),
-            m_jsMessageThread.Load(),
-            Mso::Copy(m_batchingUIThread),
-            std::move(devSettings));
-
-        m_instanceWrapper.Exchange(std::move(instanceWrapper));
+          m_jsiRuntimeHolder = devSettings->jsiRuntimeHolder;
+
+          try {
+            // We need to keep the instance wrapper alive as its destruction shuts down the native queue.
+            m_options.TurboModuleProvider->SetReactContext(
+                winrt::make<implementation::ReactContext>(Mso::Copy(m_reactContext)));
+            auto bundleRootPath = devSettings->bundleRootPath;
+            auto instanceWrapper = facebook::react::CreateReactInstance(
+                std::shared_ptr<facebook::react::Instance>(strongThis->m_instance.Load()),
+                std::move(bundleRootPath), // bundleRootPath
+                std::move(cxxModules),
+                m_options.TurboModuleProvider,
+                std::make_unique<BridgeUIBatchInstanceCallback>(weakThis),
+                m_jsMessageThread.Load(),
+                Mso::Copy(m_batchingUIThread),
+                std::move(devSettings));
+
+            m_instanceWrapper.Exchange(std::move(instanceWrapper));
 
 #ifdef USE_FABRIC
-        // Eagerly init the FabricUI binding
-        if (m_options.EnableFabric()) {
-          Microsoft::ReactNative::SchedulerSettings::SetRuntimeExecutor(
-              winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()),
-              m_instanceWrapper.Load()->GetInstance()->getRuntimeExecutor(false /*shouldFlush*/));
-          m_options.TurboModuleProvider->getModule("FabricUIManagerBinding", m_instance.Load()->getJSCallInvoker());
-        }
+            // Eagerly init the FabricUI binding
+            if (m_options.EnableFabric()) {
+              Microsoft::ReactNative::SchedulerSettings::SetRuntimeExecutor(
+                  winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties()),
+                  m_instanceWrapper.Load()->GetInstance()->getRuntimeExecutor(false /*shouldFlush*/));
+              m_options.TurboModuleProvider->getModule("FabricUIManagerBinding", m_instance.Load()->getJSCallInvoker());
+            }
 #endif
+            LoadJSBundles();
+
+            if (UseDeveloperSupport() && State() != ReactInstanceState::HasError) {
+              folly::dynamic params = folly::dynamic::array(
+                  STRING(RN_PLATFORM),
+                  DebugBundlePath(),
+                  SourceBundleHost(),
+                  SourceBundlePort(),
+                  m_isFastReloadEnabled);
+              m_instance.Load()->callJSFunction("HMRClient", "setup", std::move(params));
+            }
 
-        LoadJSBundles();
-
-        if (UseDeveloperSupport() && State() != ReactInstanceState::HasError) {
-          folly::dynamic params = folly::dynamic::array(
-              STRING(RN_PLATFORM), DebugBundlePath(), SourceBundleHost(), SourceBundlePort(), m_isFastReloadEnabled);
-          m_instance.Load()->callJSFunction("HMRClient", "setup", std::move(params));
+          } catch (std::exception &e) {
+            OnErrorWithMessage(e.what());
+            OnErrorWithMessage("UwpReactInstance: Failed to create React Instance.");
+          } catch (winrt::hresult_error const &e) {
+            OnErrorWithMessage(Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()));
+            OnErrorWithMessage("UwpReactInstance: Failed to create React Instance.");
+          } catch (...) {
+            OnErrorWithMessage("UwpReactInstance: Failed to create React Instance.");
+          }
         }
-
-      } catch (std::exception &e) {
-        OnErrorWithMessage(e.what());
-        OnErrorWithMessage("UwpReactInstance: Failed to create React Instance.");
-      } catch (winrt::hresult_error const &e) {
-        OnErrorWithMessage(Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()));
-        OnErrorWithMessage("UwpReactInstance: Failed to create React Instance.");
-      } catch (...) {
-        OnErrorWithMessage("UwpReactInstance: Failed to create React Instance.");
-      }
-    }
+      });
+    };
   });
 }
 
@@ -656,10 +662,11 @@ void ReactInstanceWin::InitNativeMessageThread() noexcept {
 
 void ReactInstanceWin::InitUIMessageThread() noexcept {
   // Native queue was already given us in constructor.
-  m_uiQueue = winrt::Microsoft::ReactNative::implementation::ReactDispatcher::GetUIDispatchQueue(m_options.Properties);
+
+  m_uiQueue = winrt::Microsoft::ReactNative::implementation::ReactDispatcher::GetUIDispatchQueue2(m_options.Properties);
   VerifyElseCrashSz(m_uiQueue, "No UI Dispatcher provided");
-  m_uiMessageThread.Exchange(
-      std::make_shared<MessageDispatchQueue>(m_uiQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
+  m_uiMessageThread.Exchange(std::make_shared<MessageDispatchQueue2>(
+      *m_uiQueue, Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError)));
 
   auto batchingUIThread = Microsoft::ReactNative::MakeBatchingQueueThread(m_uiMessageThread.Load());
   m_batchingUIThread = batchingUIThread;
@@ -744,7 +751,7 @@ std::shared_ptr<IRedBoxHandler> ReactInstanceWin::GetRedBoxHandler() noexcept {
 #ifndef CORE_ABI
   } else if (UseDeveloperSupport()) {
     auto localWkReactHost = m_weakReactHost;
-    return CreateDefaultRedBoxHandler(std::move(localWkReactHost), Mso::Copy(m_uiQueue));
+    return CreateDefaultRedBoxHandler(std::move(localWkReactHost), *m_uiQueue);
 #endif
   } else {
     return {};

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "IReactDispatcher.h"
 #include "IReactInstanceInternal.h"
 #include "ReactContext.h"
 #include "ReactNativeHeaders.h"
@@ -178,7 +179,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   std::shared_ptr<Microsoft::ReactNative::AppTheme> m_appTheme;
   Mso::CntPtr<Microsoft::ReactNative::AppearanceChangeListener> m_appearanceListener;
 #endif
-  Mso::DispatchQueue m_uiQueue;
+  Mso::CntPtr<Mso::React::IDispatchQueue2> m_uiQueue;
   std::deque<JSCallEntry> m_jsCallQueue;
 
   std::shared_ptr<facebook::jsi::RuntimeHolderLazyInit> m_jsiRuntimeHolder;

package/Microsoft.ReactNative/RedBox.cpp

@@ -408,8 +408,10 @@ struct RedBox : public std::enable_shared_from_this<RedBox> {
  * This class is implemented such that the methods on IRedBoxHandler are thread safe.
  */
 struct DefaultRedBoxHandler final : public std::enable_shared_from_this<DefaultRedBoxHandler>, IRedBoxHandler {
-  DefaultRedBoxHandler(Mso::WeakPtr<Mso::React::IReactHost> &&weakReactHost, Mso::DispatchQueue &&uiQueue) noexcept
-      : m_weakReactHost{std::move(weakReactHost)}, m_uiQueue{std::move(uiQueue)} {}
+  DefaultRedBoxHandler(
+      Mso::WeakPtr<Mso::React::IReactHost> &&weakReactHost,
+      const Mso::React::IDispatchQueue2 &uiQueue) noexcept
+      : m_weakReactHost{std::move(weakReactHost)}, m_uiQueue{&uiQueue} {}
 
   ~DefaultRedBoxHandler() {
     // Hide any currently showing redBoxes
@@ -418,7 +420,7 @@ struct DefaultRedBoxHandler final : public std::enable_shared_from_this<DefaultR
       std::scoped_lock lock{m_lockRedBox};
       std::swap(m_redBoxes, redBoxes);
     }
-    m_uiQueue.Post([redBoxes = std::move(redBoxes)]() {
+    m_uiQueue->Post([redBoxes = std::move(redBoxes)]() {
       for (const auto &redBox : redBoxes) {
         redBox->Dismiss();
       }
@@ -472,14 +474,14 @@ struct DefaultRedBoxHandler final : public std::enable_shared_from_this<DefaultR
     }
 
     if (redbox) {
-      m_uiQueue.Post([redboxCaptured = std::move(redbox), errorInfo = std::move(info)]() {
+      m_uiQueue->Post([redboxCaptured = std::move(redbox), errorInfo = std::move(info)]() {
         redboxCaptured->UpdateError(std::move(errorInfo));
       });
     }
   }
 
   virtual void dismissRedbox() override {
-    m_uiQueue.Post([wkthis = std::weak_ptr(shared_from_this())]() {
+    m_uiQueue->Post([wkthis = std::weak_ptr(shared_from_this())]() {
       if (auto pthis = wkthis.lock()) {
         std::scoped_lock lock{pthis->m_lockRedBox};
         if (!pthis->m_redBoxes.empty())
@@ -523,11 +525,11 @@ struct DefaultRedBoxHandler final : public std::enable_shared_from_this<DefaultR
       return;
     m_showingRedBox = true;
 
-    m_uiQueue.Post([redboxCaptured = std::move(redbox)]() { redboxCaptured->ShowNewJSError(); });
+    m_uiQueue->Post([redboxCaptured = std::move(redbox)]() { redboxCaptured->ShowNewJSError(); });
   }
 
  private:
-  const Mso::DispatchQueue m_uiQueue;
+  Mso::CntPtr<const Mso::React::IDispatchQueue2> m_uiQueue;
   bool m_showingRedBox{false}; // Access from UI Thread only
   std::mutex m_lockRedBox;
   std::vector<std::shared_ptr<RedBox>> m_redBoxes; // Protected by m_lockRedBox
@@ -575,9 +577,9 @@ std::shared_ptr<IRedBoxHandler> CreateRedBoxHandler(
 
 std::shared_ptr<IRedBoxHandler> CreateDefaultRedBoxHandler(
     Mso::WeakPtr<IReactHost> &&weakReactHost,
-    Mso::DispatchQueue &&uiQueue) noexcept {
+    const Mso::React::IDispatchQueue2 &uiQueue) noexcept {
 #ifndef CORE_ABI
-  return std::make_shared<DefaultRedBoxHandler>(std::move(weakReactHost), std::move(uiQueue));
+  return std::make_shared<DefaultRedBoxHandler>(std::move(weakReactHost), uiQueue);
 #else
   return nullptr;
 #endif

package/Microsoft.ReactNative/RedBox.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 #include <DevSettings.h>
+#include "IReactDispatcher.h"
 #include "IRedBoxHandler.h"
 #include "ReactHost/React.h"
 
@@ -12,5 +13,5 @@ std::shared_ptr<IRedBoxHandler> CreateRedBoxHandler(
 
 std::shared_ptr<IRedBoxHandler> CreateDefaultRedBoxHandler(
     Mso::WeakPtr<IReactHost> &&weakReactHost,
-    Mso::DispatchQueue &&uiQueue) noexcept;
+    const Mso::React::IDispatchQueue2 &uiQueue) noexcept;
 } // namespace Mso::React

package/Microsoft.ReactNative/RedBoxHandler.cpp

@@ -34,7 +34,7 @@ struct DefaultRedBoxHandler : winrt::implements<DefaultRedBoxHandler, IRedBoxHan
     auto hostImpl = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeHost>(host);
     Mso::WeakPtr<Mso::React::IReactHost> wkHost(hostImpl->ReactHost());
     m_redBoxHandler = Mso::React::CreateDefaultRedBoxHandler(
-        std::move(wkHost), ReactDispatcher::GetUIDispatchQueue(host.InstanceSettings().Properties()));
+        std::move(wkHost), *ReactDispatcher::GetUIDispatchQueue2(host.InstanceSettings().Properties()));
   }
 
   void ShowNewError(IRedBoxErrorInfo const &info, RedBoxErrorType type) noexcept {

package/Microsoft.ReactNative/packages.config

@@ -8,5 +8,5 @@
   <package id="Microsoft.Windows.CppWinRT" version="2.0.210312.4" targetFramework="native" />
   <package id="Microsoft.WinUI" version="3.0.0-preview4.210210.4" targetFramework="native" />
   <package id="ReactNative.Hermes.Windows" version="0.8.0-ms.0" targetFramework="native" />
-  <!-- package id="ReactNative.V8Jsi.Windows.UWP" version="0.65.2" targetFramework="native" / -->
+  <!-- package id="ReactNative.V8Jsi.Windows.UWP" version="0.65.5" targetFramework="native" / -->
 </packages>