react-native-windows 0.69.4 → 0.69.7

package/Microsoft.ReactNative/IReactNotificationService.cpp

@@ -8,77 +8,183 @@
 namespace winrt::Microsoft::ReactNative::implementation {
 
 //=============================================================================
-// ReactNotificationSubscription implementation
+// IReactNotificationSubscription implementation
 //=============================================================================
 
-ReactNotificationSubscription::ReactNotificationSubscription(
-    IReactNotificationSubscription const &parentSubscription,
-    weak_ref<ReactNotificationService> &&notificationService,
-    IReactPropertyName const &notificationName,
-    IReactDispatcher const &dispatcher) noexcept
-    : m_parentSubscription{parentSubscription},
-      m_notificationService{std::move(notificationService)},
-      m_notificationName{notificationName},
-      m_dispatcher{dispatcher} {}
-
-ReactNotificationSubscription::ReactNotificationSubscription(
-    weak_ref<ReactNotificationService> &&notificationService,
-    IReactPropertyName const &notificationName,
-    IReactDispatcher const &dispatcher,
-    ReactNotificationHandler const &handler) noexcept
-    : m_notificationService{std::move(notificationService)},
-      m_notificationName{notificationName},
-      m_dispatcher{dispatcher},
-      m_handler{handler} {}
-
-ReactNotificationSubscription::~ReactNotificationSubscription() noexcept {
-  Unsubscribe();
-}
+// Common interface to share functionality between ReactNotificationSubscription and ReactNotificationSubscriptionView
+MSO_GUID(IReactNotificationSubscriptionPrivate, "09437980-3508-4690-930c-7c310e205e6b")
+struct IReactNotificationSubscriptionPrivate : ::IUnknown {
+  virtual void SetParent(IReactNotificationSubscription const &parentSubscription) noexcept = 0;
+  virtual void CallHandler(
+      Windows::Foundation::IInspectable const &sender,
+      Windows::Foundation::IInspectable const &data) noexcept = 0;
+};
+
+// The Notification subscription class.
+// Instances of this class are stored in the "child" notification services.
+struct ReactNotificationSubscription
+    : implements<ReactNotificationSubscription, IReactNotificationSubscription, IReactNotificationSubscriptionPrivate> {
+  ReactNotificationSubscription(
+      Mso::RefCountedPtr<std::mutex> const &mutex,
+      weak_ref<ReactNotificationService> &&notificationService,
+      IReactPropertyName const &notificationName,
+      IReactDispatcher const &dispatcher,
+      ReactNotificationHandler const &handler) noexcept
+      : m_mutex{mutex},
+        m_notificationService{std::move(notificationService)},
+        m_notificationName{notificationName},
+        m_dispatcher{dispatcher},
+        m_handler{handler} {}
+
+  ~ReactNotificationSubscription() noexcept {
+    Unsubscribe();
+  }
 
-IReactNotificationService ReactNotificationSubscription::NotificationService() const noexcept {
-  return m_notificationService.get().as<IReactNotificationService>();
-}
+ public: // IReactNotificationSubscription implementation
+  IReactNotificationService NotificationService() const noexcept {
+    return m_notificationService.get().as<IReactNotificationService>();
+  }
 
-IReactPropertyName ReactNotificationSubscription::NotificationName() const noexcept {
-  return m_notificationName;
-}
+  IReactPropertyName NotificationName() const noexcept {
+    return m_notificationName;
+  }
 
-IReactDispatcher ReactNotificationSubscription::Dispatcher() const noexcept {
-  return m_dispatcher;
-}
+  IReactDispatcher Dispatcher() const noexcept {
+    return m_dispatcher;
+  }
 
-bool ReactNotificationSubscription::IsSubscribed() const noexcept {
-  return m_isSubscribed;
-}
+  bool IsSubscribed() const noexcept {
+    return GetHandler() != nullptr;
+  }
 
-void ReactNotificationSubscription::Unsubscribe() noexcept {
-  if (m_parentSubscription) {
-    m_parentSubscription.Unsubscribe();
+  void Unsubscribe() noexcept {
+    if (m_parentSubscription) {
+      m_parentSubscription.Unsubscribe();
+    }
+
+    bool isSubscribed{false};
+    {
+      std::scoped_lock lock{*m_mutex};
+      if (m_handler) {
+        isSubscribed = true;
+        // Remove handler to free any objects captured by it.
+        m_handler = nullptr;
+      }
+    }
+
+    if (isSubscribed) {
+      if (auto notificationService = m_notificationService.get()) {
+        notificationService->Unsubscribe(*this);
+      }
+    }
+  }
+
+ public: // IReactNotificationSubscriptionPrivate implementation
+  void SetParent(IReactNotificationSubscription const &parentSubscription) noexcept override {
+    m_parentSubscription = parentSubscription;
   }
 
-  if (m_isSubscribed.exchange(false)) {
-    if (auto notificationService = m_notificationService.get()) {
-      notificationService->Unsubscribe(*this);
+  void CallHandler(IInspectable const &sender, IInspectable const &data) noexcept override {
+    auto args = make<ReactNotificationArgs>(*this, data);
+    if (auto handler = GetHandler()) {
+      if (m_dispatcher) {
+        m_dispatcher.Post([thisPtr = get_strong(), sender, args]() noexcept {
+          if (auto handler = thisPtr->GetHandler()) {
+            handler(sender, args);
+          }
+        });
+      } else {
+        handler(sender, args);
+      }
     }
   }
-}
 
-void ReactNotificationSubscription::CallHandler(
-    IInspectable const &sender,
-    IReactNotificationArgs const &args) noexcept {
-  VerifyElseCrashSz(!m_parentSubscription, "CallHandler must not be called on the child subscription.");
-  if (IsSubscribed()) {
-    if (m_dispatcher) {
-      m_dispatcher.Post([thisPtr = get_strong(), sender, args]() noexcept {
-        if (thisPtr->IsSubscribed()) {
-          thisPtr->m_handler(sender, args);
-        }
-      });
+ private:
+  ReactNotificationHandler GetHandler() const noexcept {
+    std::scoped_lock lock{*m_mutex};
+    return m_handler;
+  }
+
+ private:
+  Mso::RefCountedPtr<std::mutex> m_mutex;
+  IReactNotificationSubscription m_parentSubscription{nullptr};
+  const weak_ref<ReactNotificationService> m_notificationService{nullptr};
+  const IReactPropertyName m_notificationName{nullptr};
+  const IReactDispatcher m_dispatcher{nullptr};
+  ReactNotificationHandler m_handler{nullptr};
+};
+
+// The notification subscription view to wrap up child notification service.
+// Instances of this class are stored in the parent notification services.
+struct ReactNotificationSubscriptionView : implements<
+                                               ReactNotificationSubscriptionView,
+                                               IReactNotificationSubscription,
+                                               IReactNotificationSubscriptionPrivate> {
+  ReactNotificationSubscriptionView(
+      weak_ref<ReactNotificationService> &&notificationService,
+      IReactNotificationSubscription const &childSubscription) noexcept
+      : m_notificationService{std::move(notificationService)}, m_childSubscription{weak_ref(childSubscription)} {
+    childSubscription.as<IReactNotificationSubscriptionPrivate>()->SetParent(*this);
+  }
+
+  ~ReactNotificationSubscriptionView() noexcept {
+    Unsubscribe();
+  }
+
+ public: // IReactNotificationSubscription implementation
+  IReactNotificationService NotificationService() const noexcept {
+    return m_notificationService.get().as<IReactNotificationService>();
+  }
+
+  IReactPropertyName NotificationName() const noexcept {
+    if (auto childSubscription = m_childSubscription.get()) {
+      return childSubscription.NotificationName();
     } else {
-      m_handler(sender, args);
+      return IReactPropertyName{nullptr};
     }
   }
-}
+
+  IReactDispatcher Dispatcher() const noexcept {
+    if (auto childSubscription = m_childSubscription.get()) {
+      return childSubscription.Dispatcher();
+    } else {
+      return IReactDispatcher{nullptr};
+    }
+  }
+
+  bool IsSubscribed() const noexcept {
+    return m_isSubscribed;
+  }
+
+  void Unsubscribe() noexcept {
+    if (m_parentSubscription) {
+      m_parentSubscription.Unsubscribe();
+    }
+
+    if (m_isSubscribed.exchange(false)) {
+      if (auto notificationService = m_notificationService.get()) {
+        notificationService->Unsubscribe(*this);
+      }
+    }
+  }
+
+ public: // IReactNotificationSubscriptionPrivate implementation
+  void SetParent(IReactNotificationSubscription const &parentSubscription) noexcept override {
+    m_parentSubscription = parentSubscription;
+  }
+
+  void CallHandler(IInspectable const &sender, IInspectable const &data) noexcept override {
+    if (auto childSubscription = m_childSubscription.get()) {
+      childSubscription.as<IReactNotificationSubscriptionPrivate>()->CallHandler(sender, data);
+    }
+  }
+
+ private:
+  IReactNotificationSubscription m_parentSubscription{nullptr};
+  const weak_ref<IReactNotificationSubscription> m_childSubscription{nullptr};
+  const weak_ref<ReactNotificationService> m_notificationService{nullptr};
+  std::atomic_bool m_isSubscribed{true};
+};
 
 //=============================================================================
 // ReactNotificationService implementation
@@ -99,7 +205,7 @@ void ReactNotificationService::ModifySubscriptions(
   // Get the current snapshot under the lock
   SubscriptionSnapshotPtr currentSnapshotPtr;
   {
-    std::scoped_lock lock{m_mutex};
+    std::scoped_lock lock{*m_mutex};
     auto it = m_subscriptions.find(notificationName);
     if (it != m_subscriptions.end()) {
       currentSnapshotPtr = it->second;
@@ -113,7 +219,7 @@ void ReactNotificationService::ModifySubscriptions(
 
     // Try to set the new snapshot under the lock
     SubscriptionSnapshotPtr snapshotPtr;
-    std::scoped_lock lock{m_mutex};
+    std::scoped_lock lock{*m_mutex};
     auto it = m_subscriptions.find(notificationName);
     if (it != m_subscriptions.end()) {
       snapshotPtr = it->second;
@@ -146,20 +252,42 @@ IReactNotificationSubscription ReactNotificationService::Subscribe(
     IReactPropertyName const &notificationName,
     IReactDispatcher const &dispatcher,
     ReactNotificationHandler const &handler) noexcept {
-  // Make sure that parent notification service also subscribes to this notification.
-  auto parentSubscription = m_parentNotificationService
-      ? m_parentNotificationService.Subscribe(notificationName, dispatcher, handler)
-      : IReactNotificationSubscription{nullptr};
-  auto subscription = parentSubscription
-      ? make<ReactNotificationSubscription>(parentSubscription, get_weak(), notificationName, dispatcher)
-      : make<ReactNotificationSubscription>(get_weak(), notificationName, dispatcher, handler);
+  VerifyElseCrashSz(notificationName, "notificationName must be not null");
+  VerifyElseCrashSz(handler, "handler must be not null");
+
+  IReactNotificationSubscription subscription =
+      make<ReactNotificationSubscription>(m_mutex, get_weak(), notificationName, dispatcher, handler);
+  AddSubscription(notificationName, subscription);
+  AddSubscriptionToParent(notificationName, subscription);
+  return subscription;
+}
+
+void ReactNotificationService::AddSubscription(
+    IReactPropertyName const &notificationName,
+    IReactNotificationSubscription const &subscription) noexcept {
   ModifySubscriptions(
       notificationName, [&subscription](std::vector<IReactNotificationSubscription> const &snapshot) noexcept {
         auto newSnapshot = std::vector<IReactNotificationSubscription>(snapshot);
         newSnapshot.push_back(subscription);
         return newSnapshot;
       });
-  return subscription;
+}
+
+void ReactNotificationService::AddSubscriptionToParent(
+    IReactPropertyName const &notificationName,
+    IReactNotificationSubscription const &subscription) noexcept {
+  if (m_parentNotificationService) {
+    get_self<ReactNotificationService>(m_parentNotificationService)
+        ->AddSubscriptionFromChild(notificationName, subscription);
+  }
+}
+
+void ReactNotificationService::AddSubscriptionFromChild(
+    IReactPropertyName const &notificationName,
+    IReactNotificationSubscription const &childSubscription) noexcept {
+  auto subscription = make<ReactNotificationSubscriptionView>(get_weak(), childSubscription);
+  AddSubscription(notificationName, subscription);
+  AddSubscriptionToParent(notificationName, subscription);
 }
 
 void ReactNotificationService::Unsubscribe(IReactNotificationSubscription const &subscription) noexcept {
@@ -180,7 +308,7 @@ void ReactNotificationService::UnsubscribeAll() noexcept {
   // The subscription will call the parent Unsubscribe on its own.
   decltype(m_subscriptions) subscriptions;
   {
-    std::scoped_lock lock{m_mutex};
+    std::scoped_lock lock{*m_mutex};
     subscriptions = std::move(m_subscriptions);
   }
 
@@ -203,7 +331,7 @@ void ReactNotificationService::SendNotification(
     SubscriptionSnapshotPtr currentSnapshotPtr;
 
     {
-      std::scoped_lock lock{m_mutex};
+      std::scoped_lock lock{*m_mutex};
       auto it = m_subscriptions.find(notificationName);
       if (it != m_subscriptions.end()) {
         currentSnapshotPtr = it->second;
@@ -213,8 +341,7 @@ void ReactNotificationService::SendNotification(
     // Call notification handlers outside of lock.
     if (currentSnapshotPtr) {
       for (auto &subscription : *currentSnapshotPtr) {
-        auto args = make<ReactNotificationArgs>(subscription, data);
-        get_self<ReactNotificationSubscription>(subscription)->CallHandler(sender, args);
+        subscription.as<IReactNotificationSubscriptionPrivate>()->CallHandler(sender, data);
       }
     }
   }

package/Microsoft.ReactNative/IReactNotificationService.h

@@ -91,9 +91,19 @@ struct ReactNotificationService : implements<ReactNotificationService, IReactNot
       IReactPropertyName const &notificationName,
       Mso::FunctorRef<SubscriptionSnapshot(SubscriptionSnapshot const &)> const &modifySnapshot);
 
+  void AddSubscription(
+      IReactPropertyName const &notificationName,
+      IReactNotificationSubscription const &subscription) noexcept;
+  void AddSubscriptionToParent(
+      IReactPropertyName const &notificationName,
+      IReactNotificationSubscription const &subscription) noexcept;
+  void AddSubscriptionFromChild(
+      IReactPropertyName const &notificationName,
+      IReactNotificationSubscription const &childSubscription) noexcept;
+
  private:
   const IReactNotificationService m_parentNotificationService;
-  std::mutex m_mutex;
+  Mso::RefCountedPtr<std::mutex> m_mutex{Mso::Make_RefCounted<std::mutex>()};
   std::unordered_map<IReactPropertyName, SubscriptionSnapshotPtr> m_subscriptions;
 };
 
@@ -103,35 +113,6 @@ struct ReactNotificationServiceHelper {
   static IReactNotificationService CreateNotificationService() noexcept;
 };
 
-struct ReactNotificationSubscription : implements<ReactNotificationSubscription, IReactNotificationSubscription> {
-  ReactNotificationSubscription(
-      IReactNotificationSubscription const &parentSubscription,
-      weak_ref<ReactNotificationService> &&notificationService,
-      IReactPropertyName const &notificationName,
-      IReactDispatcher const &dispatcher) noexcept;
-  ReactNotificationSubscription(
-      weak_ref<ReactNotificationService> &&notificationService,
-      IReactPropertyName const &notificationName,
-      IReactDispatcher const &dispatcher,
-      ReactNotificationHandler const &handler) noexcept;
-  ~ReactNotificationSubscription() noexcept;
-
-  IReactNotificationService NotificationService() const noexcept;
-  IReactPropertyName NotificationName() const noexcept;
-  IReactDispatcher Dispatcher() const noexcept;
-  bool IsSubscribed() const noexcept;
-  void Unsubscribe() noexcept;
-  void CallHandler(IInspectable const &sender, IReactNotificationArgs const &args) noexcept;
-
- private:
-  const IReactNotificationSubscription m_parentSubscription{nullptr};
-  const weak_ref<ReactNotificationService> m_notificationService;
-  const IReactPropertyName m_notificationName;
-  const IReactDispatcher m_dispatcher;
-  const ReactNotificationHandler m_handler;
-  std::atomic_bool m_isSubscribed{true};
-};
-
 } // namespace winrt::Microsoft::ReactNative::implementation
 
 namespace winrt::Microsoft::ReactNative::factory_implementation {

package/Microsoft.ReactNative/JSDispatcherWriter.cpp

@@ -8,35 +8,57 @@
 
 namespace winrt::Microsoft::ReactNative {
 
+// Special IJSValueWriter that does nothing.
+// We use it instead of JsiWriter when JSI runtime is not available anymore.
+struct JSNoopWriter : winrt::implements<JSNoopWriter, IJSValueWriter> {
+ public: // IJSValueWriter
+  void WriteNull() noexcept;
+  void WriteBoolean(bool value) noexcept;
+  void WriteInt64(int64_t value) noexcept;
+  void WriteDouble(double value) noexcept;
+  void WriteString(const winrt::hstring &value) noexcept;
+  void WriteObjectBegin() noexcept;
+  void WritePropertyName(const winrt::hstring &name) noexcept;
+  void WriteObjectEnd() noexcept;
+  void WriteArrayBegin() noexcept;
+  void WriteArrayEnd() noexcept;
+};
+
 //===========================================================================
 // JSDispatcherWriter implementation
 //===========================================================================
 
 JSDispatcherWriter::JSDispatcherWriter(
     IReactDispatcher const &jsDispatcher,
-    facebook::jsi::Runtime &jsiRuntime) noexcept
-    : m_jsDispatcher(jsDispatcher), m_jsiRuntime(jsiRuntime) {}
+    std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept
+    : m_jsDispatcher(jsDispatcher), m_jsiRuntimeHolder(std::move(jsiRuntimeHolder)) {}
 
 void JSDispatcherWriter::WithResultArgs(
     Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
         handler) noexcept {
   if (m_jsDispatcher.HasThreadAccess()) {
     VerifyElseCrash(!m_dynamicWriter);
-    const facebook::jsi::Value *args{nullptr};
-    size_t argCount{0};
-    m_jsiWriter->AccessResultAsArgs(args, argCount);
-    handler(m_jsiRuntime, args, argCount);
+    if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
+      const facebook::jsi::Value *args{nullptr};
+      size_t argCount{0};
+      m_jsiWriter->AccessResultAsArgs(args, argCount);
+      handler(jsiRuntimeHolder->Runtime(), args, argCount);
+      m_jsiWriter = nullptr;
+    }
   } else {
     VerifyElseCrash(!m_jsiWriter);
     folly::dynamic dynValue = m_dynamicWriter->TakeValue();
-    m_jsDispatcher.Post([handler, dynValue, &runtime = m_jsiRuntime]() {
-      VerifyElseCrash(dynValue.isArray());
-      std::vector<facebook::jsi::Value> args;
-      args.reserve(dynValue.size());
-      for (auto const &item : dynValue) {
-        args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
+    VerifyElseCrash(dynValue.isArray());
+    m_jsDispatcher.Post([handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder]() {
+      if (auto jsiRuntimeHolder = weakJsiRuntimeHolder.lock()) {
+        std::vector<facebook::jsi::Value> args;
+        args.reserve(dynValue.size());
+        auto &runtime = jsiRuntimeHolder->Runtime();
+        for (auto const &item : dynValue) {
+          args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
+        }
+        handler(runtime, args.data(), args.size());
       }
-      handler(runtime, args.data(), args.size());
     });
   }
 }
@@ -82,20 +104,36 @@ void JSDispatcherWriter::WriteArrayEnd() noexcept {
 }
 
 IJSValueWriter JSDispatcherWriter::GetWriter() noexcept {
-  if (m_jsDispatcher.HasThreadAccess()) {
-    VerifyElseCrash(!m_dynamicWriter);
-    if (!m_jsiWriter) {
-      m_jsiWriter = winrt::make_self<JsiWriter>(m_jsiRuntime);
-      m_writer = m_jsiWriter.as<IJSValueWriter>();
-    }
-  } else {
-    VerifyElseCrash(!m_jsiWriter);
-    if (!m_dynamicWriter) {
+  if (!m_writer) {
+    if (m_jsDispatcher.HasThreadAccess()) {
+      if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
+        m_jsiWriter = winrt::make_self<JsiWriter>(jsiRuntimeHolder->Runtime());
+        m_writer = m_jsiWriter.as<IJSValueWriter>();
+      } else {
+        m_writer = winrt::make<JSNoopWriter>();
+      }
+    } else {
       m_dynamicWriter = winrt::make_self<DynamicWriter>();
       m_writer = m_dynamicWriter.as<IJSValueWriter>();
     }
   }
+  Debug(VerifyElseCrash(m_dynamicWriter != nullptr || m_jsDispatcher.HasThreadAccess()));
   return m_writer;
 }
 
+//===========================================================================
+// JSNoopWriter implementation
+//===========================================================================
+
+void JSNoopWriter::WriteNull() noexcept {}
+void JSNoopWriter::WriteBoolean(bool /*value*/) noexcept {}
+void JSNoopWriter::WriteInt64(int64_t /*value*/) noexcept {}
+void JSNoopWriter::WriteDouble(double /*value*/) noexcept {}
+void JSNoopWriter::WriteString(const winrt::hstring & /*value*/) noexcept {}
+void JSNoopWriter::WriteObjectBegin() noexcept {}
+void JSNoopWriter::WritePropertyName(const winrt::hstring & /*name*/) noexcept {}
+void JSNoopWriter::WriteObjectEnd() noexcept {}
+void JSNoopWriter::WriteArrayBegin() noexcept {}
+void JSNoopWriter::WriteArrayEnd() noexcept {}
+
 } // namespace winrt::Microsoft::ReactNative

package/Microsoft.ReactNative/JSDispatcherWriter.h

@@ -2,10 +2,10 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include <JSI/LongLivedJsiValue.h>
 #include <functional/functor.h>
 #include "DynamicWriter.h"
 #include "JsiWriter.h"
-#include "folly/dynamic.h"
 #include "winrt/Microsoft.ReactNative.h"
 
 namespace winrt::Microsoft::ReactNative {
@@ -14,7 +14,9 @@ namespace winrt::Microsoft::ReactNative {
 // In case if writing is done outside of JSDispatcher, it uses DynamicWriter to create
 // folly::dynamic which then is written to JsiWriter in JSDispatcher.
 struct JSDispatcherWriter : winrt::implements<JSDispatcherWriter, IJSValueWriter> {
-  JSDispatcherWriter(IReactDispatcher const &jsDispatcher, facebook::jsi::Runtime &jsiRuntime) noexcept;
+  JSDispatcherWriter(
+      IReactDispatcher const &jsDispatcher,
+      std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept;
   void WithResultArgs(Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
                           handler) noexcept;
 
@@ -35,7 +37,7 @@ struct JSDispatcherWriter : winrt::implements<JSDispatcherWriter, IJSValueWriter
 
  private:
   IReactDispatcher m_jsDispatcher;
-  facebook::jsi::Runtime &m_jsiRuntime;
+  std::weak_ptr<LongLivedJsiRuntime> m_jsiRuntimeHolder;
   winrt::com_ptr<DynamicWriter> m_dynamicWriter;
   winrt::com_ptr<JsiWriter> m_jsiWriter;
   IJSValueWriter m_writer;

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -132,7 +132,8 @@ struct BridgeUIBatchInstanceCallback final : public facebook::react::InstanceCal
   virtual ~BridgeUIBatchInstanceCallback() = default;
   void onBatchComplete() override {
     if (auto instance = m_wkInstance.GetStrongPtr()) {
-      if (instance->IsLoaded()) {
+      auto state = instance->State();
+      if (state != ReactInstanceState::HasError && state != ReactInstanceState::Unloaded) {
         if (instance->UseWebDebugger()) {
           // While using a CxxModule for UIManager (which we do when running under webdebugger)
           // We need to post the batch complete to the NativeQueue to ensure that the UIManager
@@ -510,6 +511,7 @@ void ReactInstanceWin::Initialize() noexcept {
                 std::move(bundleRootPath), // bundleRootPath
                 std::move(cxxModules),
                 m_options.TurboModuleProvider,
+                m_options.TurboModuleProvider->LongLivedObjectCollection(),
                 std::make_unique<BridgeUIBatchInstanceCallback>(weakThis),
                 m_jsMessageThread.Load(),
                 m_nativeMessageThread.Load(),