react-native-windows 0.84.0-preview.5 → 0.84.0-preview.6

package/Libraries/Modal/Modal.windows.js

@@ -41,13 +41,7 @@ export type PublicModalInstance = HostInstance;
 const ModalEventEmitter =
   (Platform.OS === 'ios' || Platform.OS === 'windows') && // [Windows]
   NativeModalManager != null
-    ? new NativeEventEmitter<ModalEventDefinitions>(
-        // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
-        // If you want to use the native module on other platforms, please remove this condition and test its behavior
-        Platform.OS !== 'ios' && Platform.OS !== 'windows' // [Windows]
-          ? null
-          : NativeModalManager,
-      )
+    ? new NativeEventEmitter<ModalEventDefinitions>(NativeModalManager)
     : null;
 
 /**

package/Microsoft.ReactNative/Fabric/Composition/CompositionContextHelper.cpp

@@ -2,6 +2,9 @@
 #include "pch.h"
 #include "CompositionContextHelper.h"
 #include <algorithm>
+#include <cassert>
+#include <exception>
+#include <vector>
 #if __has_include("Composition.Experimental.SystemCompositionContextHelper.g.cpp")
 #include "Composition.Experimental.SystemCompositionContextHelper.g.cpp"
 #endif
@@ -431,30 +434,43 @@ struct CompVisualImpl {
   void InsertAt(
       const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &visual,
       uint32_t index) noexcept {
+    if (index > m_childrenCache.size()) {
+      std::terminate();
+    }
     auto containerChildren = InnerVisual().as<typename TTypeRedirects::ContainerVisual>().Children();
     auto compVisual = TTypeRedirects::CompositionContextHelper::InnerVisual(visual);
     if (index == 0) {
       containerChildren.InsertAtBottom(compVisual);
-      return;
+    } else {
+      auto insertAfter = containerChildren.First();
+      for (uint32_t i = 1; i < index; i++)
+        insertAfter.MoveNext();
+      containerChildren.InsertAbove(compVisual, insertAfter.Current());
+    }
+    if (index >= m_childrenCache.size()) {
+      m_childrenCache.push_back(visual);
+    } else {
+      m_childrenCache.insert(m_childrenCache.begin() + index, visual);
     }
-    auto insertAfter = containerChildren.First();
-    for (uint32_t i = 1; i < index; i++)
-      insertAfter.MoveNext();
-    containerChildren.InsertAbove(compVisual, insertAfter.Current());
   }
 
   void Remove(const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &visual) noexcept {
     auto compVisual = TTypeRedirects::CompositionContextHelper::InnerVisual(visual);
     auto containerChildren = InnerVisual().as<typename TTypeRedirects::ContainerVisual>().Children();
     containerChildren.Remove(compVisual);
+    auto it = std::find_if(
+        m_childrenCache.begin(), m_childrenCache.end(), [&visual](const auto &cached) { return cached == visual; });
+    if (it != m_childrenCache.end()) {
+      m_childrenCache.erase(it);
+    }
   }
 
   winrt::Microsoft::ReactNative::Composition::Experimental::IVisual GetAt(uint32_t index) noexcept {
-    auto containerChildren = m_visual.as<typename TTypeRedirects::ContainerVisual>().Children();
-    auto it = containerChildren.First();
-    for (uint32_t i = 0; i < index; i++)
-      it.MoveNext();
-    return TTypeRedirects::CompositionContextHelper::CreateVisual(it.Current());
+    if (index < m_childrenCache.size()) {
+      return m_childrenCache[index];
+    }
+    assert(false && "GetAt called with out-of-range index");
+    return nullptr;
   }
 
   void SetClippingPath(ID2D1Geometry *clippingPath) noexcept {
@@ -534,6 +550,7 @@ struct CompVisualImpl {
 
  protected:
   TVisual m_visual;
+  std::vector<winrt::Microsoft::ReactNative::Composition::Experimental::IVisual> m_childrenCache;
 };
 
 template <typename TTypeRedirects>
@@ -848,30 +865,43 @@ struct CompScrollerVisual : winrt::implements<
   void InsertAt(
       const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &visual,
       uint32_t index) noexcept {
+    if (index > m_childrenCache.size()) {
+      std::terminate();
+    }
     auto containerChildren = m_contentVisual.Children();
     auto compVisual = TTypeRedirects::CompositionContextHelper::InnerVisual(visual);
     if (index == 0) {
       containerChildren.InsertAtBottom(compVisual);
-      return;
+    } else {
+      auto insertAfter = containerChildren.First();
+      for (uint32_t i = 1; i < index; i++)
+        insertAfter.MoveNext();
+      containerChildren.InsertAbove(compVisual, insertAfter.Current());
+    }
+    if (index >= m_childrenCache.size()) {
+      m_childrenCache.push_back(visual);
+    } else {
+      m_childrenCache.insert(m_childrenCache.begin() + index, visual);
     }
-    auto insertAfter = containerChildren.First();
-    for (uint32_t i = 1; i < index; i++)
-      insertAfter.MoveNext();
-    containerChildren.InsertAbove(compVisual, insertAfter.Current());
   }
 
   void Remove(const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &visual) noexcept {
     auto compVisual = TTypeRedirects::CompositionContextHelper::InnerVisual(visual);
     auto containerChildren = m_contentVisual.Children();
     containerChildren.Remove(compVisual);
+    auto it = std::find_if(
+        m_childrenCache.begin(), m_childrenCache.end(), [&visual](const auto &cached) { return cached == visual; });
+    if (it != m_childrenCache.end()) {
+      m_childrenCache.erase(it);
+    }
   }
 
   winrt::Microsoft::ReactNative::Composition::Experimental::IVisual GetAt(uint32_t index) noexcept {
-    auto containerChildren = m_visual.as<typename TTypeRedirects::ContainerVisual>().Children();
-    auto it = containerChildren.First();
-    for (uint32_t i = 0; i < index; i++)
-      it.MoveNext();
-    return TTypeRedirects::CompositionContextHelper::CreateVisual(it.Current());
+    if (index < m_childrenCache.size()) {
+      return m_childrenCache[index];
+    }
+    assert(false && "GetAt called with out-of-range index");
+    return nullptr;
   }
 
   void Brush(const winrt::Microsoft::ReactNative::Composition::Experimental::IBrush &brush) noexcept {
@@ -1255,6 +1285,12 @@ struct CompScrollerVisual : winrt::implements<
     std::sort(snapPositions.begin(), snapPositions.end());
     snapPositions.erase(std::unique(snapPositions.begin(), snapPositions.end()), snapPositions.end());
 
+    // Skip reconfiguration if snap points haven't changed
+    if (snapPositions == m_previousSnapPositions) {
+      return;
+    }
+    m_previousSnapPositions = snapPositions;
+
     std::vector<typename TTypeRedirects::InteractionTrackerInertiaRestingValue> restingValues;
 
     for (size_t i = 0; i < snapPositions.size(); ++i) {
@@ -1384,6 +1420,7 @@ struct CompScrollerVisual : winrt::implements<
   winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment m_snapToAlignment{
       winrt::Microsoft::ReactNative::Composition::Experimental::SnapPointsAlignment::Near};
   std::vector<float> m_snapToOffsets;
+  std::vector<float> m_previousSnapPositions;
   bool m_inertia{false};
   bool m_custom{false};
   bool m_interacting{false};
@@ -1410,6 +1447,7 @@ struct CompScrollerVisual : winrt::implements<
   typename TTypeRedirects::SpriteVisual m_contentVisual{nullptr};
   typename TTypeRedirects::InteractionTracker m_interactionTracker{nullptr};
   typename TTypeRedirects::VisualInteractionSource m_visualInteractionSource{nullptr};
+  std::vector<winrt::Microsoft::ReactNative::Composition::Experimental::IVisual> m_childrenCache;
 };
 using WindowsCompScrollerVisual = CompScrollerVisual<WindowsTypeRedirects>;
 using MicrosoftCompScrollerVisual = CompScrollerVisual<MicrosoftTypeRedirects>;

package/Microsoft.ReactNative/Fabric/Composition/CompositionEventHandler.cpp

@@ -250,7 +250,10 @@ void CompositionEventHandler::Initialize() noexcept {
           if (strongThis->SurfaceId() == -1)
             return;
 
-          auto focusedComponent = strongThis->RootComponentView().GetFocusedComponent();
+          auto *rootView = strongThis->RootComponentView();
+          if (!rootView)
+            return;
+          auto focusedComponent = rootView->GetFocusedComponent();
           auto keyboardSource = winrt::make<CompositionInputKeyboardSource>(source);
           auto keyArgs =
               winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::KeyRoutedEventArgs>(
@@ -276,7 +279,10 @@ void CompositionEventHandler::Initialize() noexcept {
           if (strongThis->SurfaceId() == -1)
             return;
 
-          auto focusedComponent = strongThis->RootComponentView().GetFocusedComponent();
+          auto *rootView = strongThis->RootComponentView();
+          if (!rootView)
+            return;
+          auto focusedComponent = rootView->GetFocusedComponent();
           auto keyboardSource = winrt::make<CompositionInputKeyboardSource>(source);
           auto keyArgs =
               winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::KeyRoutedEventArgs>(
@@ -303,7 +309,10 @@ void CompositionEventHandler::Initialize() noexcept {
               if (strongThis->SurfaceId() == -1)
                 return;
 
-              auto focusedComponent = strongThis->RootComponentView().GetFocusedComponent();
+              auto *rootView = strongThis->RootComponentView();
+              if (!rootView)
+                return;
+              auto focusedComponent = rootView->GetFocusedComponent();
               auto keyboardSource = winrt::make<CompositionInputKeyboardSource>(source);
               auto charArgs = winrt::make<
                   winrt::Microsoft::ReactNative::Composition::Input::implementation::CharacterReceivedRoutedEventArgs>(
@@ -330,7 +339,10 @@ void CompositionEventHandler::Initialize() noexcept {
               if (strongThis->SurfaceId() == -1)
                 return;
 
-              auto focusedComponent = strongThis->RootComponentView().GetFocusedComponent();
+              auto *rootView = strongThis->RootComponentView();
+              if (!rootView)
+                return;
+              auto focusedComponent = rootView->GetFocusedComponent();
               if (focusedComponent) {
                 auto tag =
                     winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(focusedComponent)
@@ -358,6 +370,7 @@ CompositionEventHandler::~CompositionEventHandler() {
       pointerSource.PointerMoved(m_pointerMovedToken);
       pointerSource.PointerCaptureLost(m_pointerCaptureLostToken);
       pointerSource.PointerWheelChanged(m_pointerWheelChangedToken);
+      pointerSource.PointerExited(m_pointerExitedToken);
       auto keyboardSource = winrt::Microsoft::UI::Input::InputKeyboardSource::GetForIsland(island);
       keyboardSource.KeyDown(m_keyDownToken);
       keyboardSource.KeyUp(m_keyUpToken);
@@ -380,10 +393,15 @@ facebook::react::SurfaceId CompositionEventHandler::SurfaceId() const noexcept {
   return -1;
 }
 
-winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView &
+winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *
 CompositionEventHandler::RootComponentView() const noexcept {
   auto island = m_wkRootView.get();
-  return *winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>(island)->GetComponentView();
+  if (!island) {
+    return nullptr;
+  }
+  return winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>(island)
+      ->GetComponentView()
+      .get();
 }
 
 void CompositionEventHandler::onPointerWheelChanged(
@@ -398,8 +416,11 @@ void CompositionEventHandler::onPointerWheelChanged(
 
     // In the case of a sub rootview, we may have a non-zero origin.  hitTest takes a pt in the parent coords, so we
     // need to apply the current origin
-    ptScaled += RootComponentView().layoutMetrics().frame.origin;
-    auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
+    auto *rootView = RootComponentView();
+    if (!rootView)
+      return;
+    ptScaled += rootView->layoutMetrics().frame.origin;
+    auto tag = rootView->hitTest(ptScaled, ptLocal);
 
     if (tag == -1)
       return;
@@ -553,7 +574,10 @@ int64_t CompositionEventHandler::SendMessage(HWND hwnd, uint32_t msg, uint64_t w
     case WM_CHAR:
     case WM_SYSCHAR: {
       if (auto strongRootView = m_wkRootView.get()) {
-        auto focusedComponent = RootComponentView().GetFocusedComponent();
+        auto *rootView = RootComponentView();
+        if (!rootView)
+          break;
+        auto focusedComponent = rootView->GetFocusedComponent();
         auto keyboardSource = winrt::make<CompositionKeyboardSource>(this);
         auto args = winrt::make<
             winrt::Microsoft::ReactNative::Composition::Input::implementation::CharacterReceivedRoutedEventArgs>(
@@ -576,7 +600,10 @@ int64_t CompositionEventHandler::SendMessage(HWND hwnd, uint32_t msg, uint64_t w
     case WM_SYSKEYDOWN:
     case WM_SYSKEYUP: {
       if (auto strongRootView = m_wkRootView.get()) {
-        auto focusedComponent = RootComponentView().GetFocusedComponent();
+        auto *rootView = RootComponentView();
+        if (!rootView)
+          break;
+        auto focusedComponent = rootView->GetFocusedComponent();
         auto keyboardSource = winrt::make<CompositionKeyboardSource>(this);
         auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::KeyRoutedEventArgs>(
             focusedComponent
@@ -608,9 +635,12 @@ int64_t CompositionEventHandler::SendMessage(HWND hwnd, uint32_t msg, uint64_t w
 
 void CompositionEventHandler::onKeyDown(
     const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept {
-  RootComponentView().UseKeyboardForProgrammaticFocus(true);
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  rootView->UseKeyboardForProgrammaticFocus(true);
 
-  if (auto focusedComponent = RootComponentView().GetFocusedComponent()) {
+  if (auto focusedComponent = rootView->GetFocusedComponent()) {
     winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(focusedComponent)->OnKeyDown(args);
 
     if (args.Handled())
@@ -633,7 +663,7 @@ void CompositionEventHandler::onKeyDown(
   }
 
   if (!fCtrl && args.Key() == winrt::Windows::System::VirtualKey::Tab) {
-    if (RootComponentView().TryMoveFocus(!fShift, winrt::Microsoft::ReactNative::FocusState::Keyboard)) {
+    if (rootView->TryMoveFocus(!fShift, winrt::Microsoft::ReactNative::FocusState::Keyboard)) {
       args.Handled(true);
     }
 
@@ -643,9 +673,12 @@ void CompositionEventHandler::onKeyDown(
 
 void CompositionEventHandler::onKeyUp(
     const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept {
-  RootComponentView().UseKeyboardForProgrammaticFocus(true);
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  rootView->UseKeyboardForProgrammaticFocus(true);
 
-  if (auto focusedComponent = RootComponentView().GetFocusedComponent()) {
+  if (auto focusedComponent = rootView->GetFocusedComponent()) {
     winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(focusedComponent)->OnKeyUp(args);
 
     if (args.Handled())
@@ -655,7 +688,10 @@ void CompositionEventHandler::onKeyUp(
 
 void CompositionEventHandler::onCharacterReceived(
     const winrt::Microsoft::ReactNative::Composition::Input::CharacterReceivedRoutedEventArgs &args) noexcept {
-  if (auto focusedComponent = RootComponentView().GetFocusedComponent()) {
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  if (auto focusedComponent = rootView->GetFocusedComponent()) {
     winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(focusedComponent)
         ->OnCharacterReceived(args);
 
@@ -664,7 +700,7 @@ void CompositionEventHandler::onCharacterReceived(
   }
 }
 
-std::vector<winrt::Microsoft::ReactNative::ComponentView> GetTouchableViewsInPathToRoot(
+std::vector<winrt::Microsoft::ReactNative::ComponentView> CompositionEventHandler::GetTouchableViewsInPathToRoot(
     const winrt::Microsoft::ReactNative::ComponentView &componentView) {
   std::vector<winrt::Microsoft::ReactNative::ComponentView> results;
   auto view = componentView;
@@ -674,6 +710,7 @@ std::vector<winrt::Microsoft::ReactNative::ComponentView> GetTouchableViewsInPat
     }
     view = view.Parent();
   }
+
   return results;
 }
 
@@ -974,8 +1011,8 @@ void CompositionEventHandler::UpdateActiveTouch(
   // activeTouch.touch.isEraser = false;
   activeTouch.touch.pagePoint.x = ptScaled.x;
   activeTouch.touch.pagePoint.y = ptScaled.y;
-  activeTouch.touch.screenPoint.x = ptLocal.x;
-  activeTouch.touch.screenPoint.y = ptLocal.y;
+  activeTouch.touch.screenPoint.x = ptScaled.x;
+  activeTouch.touch.screenPoint.y = ptScaled.y;
   activeTouch.touch.offsetPoint.x = ptLocal.x;
   activeTouch.touch.offsetPoint.y = ptLocal.y;
   activeTouch.touch.timestamp = static_cast<facebook::react::Float>(
@@ -1028,9 +1065,12 @@ void CompositionEventHandler::getTargetPointerArgs(
 
   // In the case of a sub rootview, we may have a non-zero origin.  hitTest takes a pt in the parent coords, so we need
   // to apply the current origin
-  ptScaled += RootComponentView().layoutMetrics().frame.origin;
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  ptScaled += rootView->layoutMetrics().frame.origin;
 
-  if (std::find(m_capturedPointers.begin(), m_capturedPointers.end(), pointerId) != m_capturedPointers.end()) {
+  if (m_capturedPointers.count(pointerId)) {
     assert(m_pointerCapturingComponentTag != -1);
     tag = m_pointerCapturingComponentTag;
 
@@ -1042,7 +1082,7 @@ void CompositionEventHandler::getTargetPointerArgs(
       ptLocal.y = ptScaled.y - (clientRect.top / strongRootView.ScaleFactor());
     }
   } else {
-    tag = RootComponentView().hitTest(ptScaled, ptLocal);
+    tag = rootView->hitTest(ptScaled, ptLocal);
   }
 }
 
@@ -1054,7 +1094,7 @@ void CompositionEventHandler::onPointerCaptureLost(
 
   if (m_pointerCapturingComponentTag) {
     // copy array to avoid iterator being invalidated during deletion
-    std::vector<PointerId> capturedPointers = m_capturedPointers;
+    std::unordered_set<PointerId> capturedPointers = m_capturedPointers;
 
     for (auto pointerId : capturedPointers) {
       releasePointerCapture(pointerId, m_pointerCapturingComponentTag);
@@ -1101,10 +1141,11 @@ void CompositionEventHandler::onPointerMoved(
 
     auto handler = [&, targetView, pointerEvent, isActiveTouch](
                        std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {
+      auto *rootViewForEmitter = RootComponentView();
       const auto eventEmitter = targetView
           ? winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(targetView)
                 ->eventEmitterAtPoint(pointerEvent.offsetPoint)
-          : RootComponentView().eventEmitterAtPoint(pointerEvent.offsetPoint);
+          : (rootViewForEmitter ? rootViewForEmitter->eventEmitterAtPoint(pointerEvent.offsetPoint) : nullptr);
 
       if (eventEmitter != nullptr) {
         eventEmitter->onPointerMove(pointerEvent);
@@ -1130,7 +1171,10 @@ void CompositionEventHandler::ClearAllHoveredForPointer(const facebook::react::P
   // events. If we get null for the targetView, that means that the mouse is no over any components, so we have no
   // element to send the move event to. However we need to send something so that any previously hovered elements
   // are no longer hovered.
-  auto children = RootComponentView().Children();
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  auto children = rootView->Children();
   if (auto size = children.Size()) {
     auto firstChild = children.GetAt(0);
     if (auto childEventEmitter =
@@ -1175,23 +1219,31 @@ void CompositionEventHandler::onPointerPressed(
     winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
   namespace Composition = winrt::Microsoft::ReactNative::Composition;
 
-  RootComponentView().UseKeyboardForProgrammaticFocus(false);
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  rootView->UseKeyboardForProgrammaticFocus(false);
 
   // Clears any active text selection when left pointer is pressed
   if (pointerPoint.Properties().PointerUpdateKind() != Composition::Input::PointerUpdateKind::RightButtonPressed) {
-    RootComponentView().ClearCurrentTextSelection();
+    rootView->ClearCurrentTextSelection();
   }
 
   PointerId pointerId = pointerPoint.PointerId();
 
-  auto staleTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {
-    return pair.second.touch.identifier == pointerId;
-  });
+  auto staleTouch = m_activeTouches.find(pointerId);
 
   if (staleTouch != m_activeTouches.end()) {
-    // A pointer with this ID already exists - Should we fire a button cancel or something?
-    // assert(false);
-    return;
+    // A previous pointer with this ID was never properly released (e.g., app lost focus,
+    // pointer left window). Cancel the stale touch and clean it up so the new press can proceed.
+    // Copy and erase before dispatching to avoid holding a reference into m_activeTouches
+    // across DispatchSynthesizedTouchCancelForActiveTouch, which calls HandleIncomingPointerEvent
+    // and iterates m_activeTouches internally.
+    ActiveTouch staleTouchCopy = std::move(staleTouch->second);
+    m_activeTouches.erase(staleTouch);
+    if (staleTouchCopy.eventEmitter) {
+      DispatchSynthesizedTouchCancelForActiveTouch(staleTouchCopy, pointerPoint, keyModifiers);
+    }
   }
 
   const auto eventType = TouchEventType::Start;
@@ -1212,7 +1264,18 @@ void CompositionEventHandler::onPointerPressed(
         ->OnPointerPressed(args);
 
     ActiveTouch activeTouch{0};
-    activeTouch.touchType = UITouchType::Mouse;
+    switch (pointerPoint.PointerDeviceType()) {
+      case Composition::Input::PointerDeviceType::Touch:
+        activeTouch.touchType = UITouchType::Touch;
+        break;
+      case Composition::Input::PointerDeviceType::Pen:
+        activeTouch.touchType = UITouchType::Pen;
+        break;
+      case Composition::Input::PointerDeviceType::Mouse:
+      default:
+        activeTouch.touchType = UITouchType::Mouse;
+        break;
+    }
 
     // Map PointerUpdateKind to W3C button value
     // https://developer.mozilla.org/docs/Web/API/MouseEvent/button
@@ -1250,6 +1313,12 @@ void CompositionEventHandler::onPointerPressed(
       targetComponentView = targetComponentView.Parent();
     }
 
+    // Don't register the touch if no eventEmitter was found — inserting a null-emitter entry
+    // into m_activeTouches would block future presses with the same pointer ID.
+    if (!activeTouch.eventEmitter) {
+      return;
+    }
+
     UpdateActiveTouch(activeTouch, ptScaled, ptLocal);
 
     activeTouch.isPrimary = pointerId == 1;
@@ -1273,11 +1342,12 @@ void CompositionEventHandler::onPointerReleased(
     winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
   int pointerId = pointerPoint.PointerId();
 
-  RootComponentView().UseKeyboardForProgrammaticFocus(false);
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return;
+  rootView->UseKeyboardForProgrammaticFocus(false);
 
-  auto activeTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {
-    return pair.second.touch.identifier == pointerId;
-  });
+  auto activeTouch = m_activeTouches.find(pointerId);
 
   if (activeTouch == m_activeTouches.end()) {
     return;
@@ -1289,8 +1359,13 @@ void CompositionEventHandler::onPointerReleased(
     facebook::react::Point ptLocal, ptScaled;
     getTargetPointerArgs(fabricuiManager, pointerPoint, tag, ptScaled, ptLocal);
 
-    if (tag == -1)
+    if (tag == -1) {
+      if (activeTouch->second.eventEmitter) {
+        DispatchSynthesizedTouchCancelForActiveTouch(activeTouch->second, pointerPoint, keyModifiers);
+      }
+      m_activeTouches.erase(pointerId);
       return;
+    }
 
     auto targetComponentView = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view;
     auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
@@ -1322,7 +1397,7 @@ bool CompositionEventHandler::CapturePointer(
   }
 
   m_pointerCapturingComponentTag = tag;
-  m_capturedPointers.push_back(pointer.PointerId());
+  m_capturedPointers.insert(pointer.PointerId());
   return true;
 }
 
@@ -1337,11 +1412,9 @@ bool CompositionEventHandler::releasePointerCapture(PointerId pointerId, faceboo
   bool result = false;
 
   if (m_pointerCapturingComponentTag == tag) {
-    auto it = std::find(m_capturedPointers.begin(), m_capturedPointers.end(), pointerId);
-    if (it == m_capturedPointers.end()) {
+    if (m_capturedPointers.erase(pointerId) == 0) {
       return false;
     }
-    m_capturedPointers.erase(it);
 
     if (std::shared_ptr<FabricUIManager> fabricuiManager =
             ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
@@ -1352,7 +1425,7 @@ bool CompositionEventHandler::releasePointerCapture(PointerId pointerId, faceboo
           ->OnPointerCaptureLost();
     }
 
-    if (m_capturedPointers.size() == 0) {
+    if (m_capturedPointers.empty()) {
       m_pointerCapturingComponentTag = -1;
       return true;
     }
@@ -1467,16 +1540,83 @@ bool CompositionEventHandler::IsPointerWithinInitialTree(const ActiveTouch &acti
   if (!initialComponentView)
     return false;
 
-  auto initialViewSet = GetTouchableViewsInPathToRoot(initialComponentView);
+  auto *rootView = RootComponentView();
+  if (!rootView)
+    return false;
+
+  facebook::react::Point ptLocal;
+  auto currentTag = rootView->hitTest(activeTouch.touch.pagePoint, ptLocal);
+  if (currentTag == -1)
+    return false;
 
-  for (const auto &view : initialViewSet) {
-    if (view.Tag() == activeTouch.touch.target)
+  auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties());
+  if (!fabricuiManager)
+    return false;
+
+  auto initialTag = initialComponentView.Tag();
+  auto &viewRegistry = fabricuiManager->GetViewRegistry();
+  auto currentView = viewRegistry.componentViewDescriptorWithTag(currentTag).view;
+  while (currentView) {
+    if (currentView.Tag() == initialTag)
+      return true;
+    currentView = currentView.Parent();
+  }
+
+  // Fallback: if the pointer drifted spatially but the original target
+  // is still structurally within the initial tree, honor the tap.
+  // This provides touch-device tolerance for finger drift.
+  auto targetView = viewRegistry.componentViewDescriptorWithTag(activeTouch.touch.target).view;
+  while (targetView) {
+    if (targetView.Tag() == initialTag)
       return true;
+    targetView = targetView.Parent();
   }
 
   return false;
 }
 
+void CompositionEventHandler::DispatchSynthesizedTouchCancelForActiveTouch(
+    const ActiveTouch &cancelledTouch,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) {
+  if (!cancelledTouch.eventEmitter) {
+    return;
+  }
+
+  facebook::react::PointerEvent pointerEvent =
+      CreatePointerEventFromActiveTouch(cancelledTouch, TouchEventType::Cancel);
+  winrt::Microsoft::ReactNative::ComponentView targetView{nullptr};
+  facebook::react::SharedTouchEventEmitter emitter = cancelledTouch.eventEmitter;
+  auto pointerHandler = [emitter, pointerEvent](std::vector<winrt::Microsoft::ReactNative::ComponentView> &) {
+    emitter->onPointerCancel(pointerEvent);
+  };
+  HandleIncomingPointerEvent(pointerEvent, targetView, pointerPoint, keyModifiers, pointerHandler);
+
+  facebook::react::TouchEvent touchEvent;
+  touchEvent.changedTouches.insert(cancelledTouch.touch);
+
+  for (const auto &pair : m_activeTouches) {
+    if (!pair.second.eventEmitter) {
+      continue;
+    }
+
+    if (touchEvent.changedTouches.find(pair.second.touch) != touchEvent.changedTouches.end()) {
+      continue;
+    }
+
+    touchEvent.touches.insert(pair.second.touch);
+  }
+
+  for (const auto &pair : m_activeTouches) {
+    if (pair.second.eventEmitter == cancelledTouch.eventEmitter &&
+        touchEvent.changedTouches.find(pair.second.touch) == touchEvent.changedTouches.end()) {
+      touchEvent.targetTouches.insert(pair.second.touch);
+    }
+  }
+
+  cancelledTouch.eventEmitter->onTouchCancel(touchEvent);
+}
+
 // If we have events that include multiple pointer updates, we should change arg from pointerId to vector<pointerId>
 void CompositionEventHandler::DispatchTouchEvent(
     TouchEventType eventType,
@@ -1512,16 +1652,19 @@ void CompositionEventHandler::DispatchTouchEvent(
     bool shouldLeave = (eventType == TouchEventType::End && activeTouch.shouldLeaveWhenReleased) ||
         eventType == TouchEventType::Cancel;
     if (!shouldLeave) {
-      const auto &viewRegistry = fabricuiManager->GetViewRegistry();
-      facebook::react::Point ptLocal;
-      auto targetTag = RootComponentView().hitTest(pointerEvent.clientPoint, ptLocal);
-      if (targetTag != -1) {
-        auto targetComponentViewDescriptor = viewRegistry.componentViewDescriptorWithTag(targetTag);
-        targetView = FindClosestFabricManagedTouchableView(targetComponentViewDescriptor.view);
+      auto *rootViewForHit = RootComponentView();
+      if (rootViewForHit) {
+        const auto &viewRegistry = fabricuiManager->GetViewRegistry();
+        facebook::react::Point ptLocal;
+        auto targetTag = rootViewForHit->hitTest(pointerEvent.clientPoint, ptLocal);
+        if (targetTag != -1) {
+          auto targetComponentViewDescriptor = viewRegistry.componentViewDescriptorWithTag(targetTag);
+          targetView = FindClosestFabricManagedTouchableView(targetComponentViewDescriptor.view);
+        }
       }
     }
 
-    auto handler = [&activeTouch, eventType, &pointerEvent](
+    auto handler = [this, &activeTouch, eventType, &pointerEvent](
                        std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {
       switch (eventType) {
         case TouchEventType::Start:

package/Microsoft.ReactNative/Fabric/Composition/CompositionEventHandler.h

@@ -14,6 +14,7 @@
 #include <winrt/Windows.Devices.Input.h>
 #include <optional>
 #include <set>
+#include <unordered_set>
 
 namespace winrt {
 using namespace Windows::UI;
@@ -79,7 +80,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   bool releasePointerCapture(PointerId pointerId, facebook::react::Tag tag) noexcept;
 
   facebook::react::SurfaceId SurfaceId() const noexcept;
-  winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView &RootComponentView() const noexcept;
+  winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *RootComponentView() const noexcept;
 
   enum class UITouchType {
     Mouse,
@@ -141,7 +142,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
     ReactTaggedView initialComponentView{nullptr};
   };
 
-  static bool IsPointerWithinInitialTree(const ActiveTouch &activeTouch) noexcept;
+  bool IsPointerWithinInitialTree(const ActiveTouch &activeTouch) noexcept;
   static bool IsEndishEventType(TouchEventType eventType) noexcept;
   static const char *PointerTypeCStringFromUITouchType(UITouchType type) noexcept;
   static facebook::react::PointerEvent CreatePointerEventFromActiveTouch(
@@ -150,6 +151,14 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   static void
   UpdateActiveTouch(ActiveTouch &activeTouch, facebook::react::Point ptScaled, facebook::react::Point ptLocal) noexcept;
 
+  void DispatchSynthesizedTouchCancelForActiveTouch(
+      const ActiveTouch &cancelledTouch,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers);
+
+  std::vector<winrt::Microsoft::ReactNative::ComponentView> GetTouchableViewsInPathToRoot(
+      const winrt::Microsoft::ReactNative::ComponentView &componentView);
+
   void UpdateCursor() noexcept;
   void SetCursor(facebook::react::Cursor cursor, HCURSOR hcur) noexcept;
 
@@ -161,7 +170,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   winrt::Microsoft::ReactNative::ReactContext m_context;
 
   facebook::react::Tag m_pointerCapturingComponentTag{-1}; // Component that has captured input
-  std::vector<PointerId> m_capturedPointers;
+  std::unordered_set<PointerId> m_capturedPointers;
   HCURSOR m_hcursor{nullptr};
   bool m_hcursorOwned{false}; // If we create the cursor, so we need to destroy it
   facebook::react::Cursor m_currentCursor{facebook::react::Cursor::Auto};

package/Microsoft.ReactNative/Fabric/Composition/CompositionViewComponentView.cpp

@@ -6,6 +6,8 @@
 
 #include "CompositionViewComponentView.h"
 
+#include <vector>
+
 #include <AutoDraw.h>
 #include <Fabric/AbiState.h>
 #include <Fabric/AbiViewProps.h>
@@ -1013,15 +1015,18 @@ bool ComponentView::anyHitTestHelper(
     facebook::react::Tag &targetTag,
     facebook::react::Point &ptContent,
     facebook::react::Point &localPt) const noexcept {
-  if (auto index = m_children.Size()) {
-    do {
-      index--;
-      targetTag = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(m_children.GetAt(index))
-                      ->hitTest(ptContent, localPt);
-      if (targetTag != -1) {
-        return true;
-      }
-    } while (index != 0);
+  auto size = m_children.Size();
+  if (size == 0) {
+    return false;
+  }
+
+  // m_children is backed by single_threaded_vector (std::vector), so GetAt is O(1)
+  for (uint32_t i = size; i > 0; --i) {
+    targetTag = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(m_children.GetAt(i - 1))
+                    ->hitTest(ptContent, localPt);
+    if (targetTag != -1) {
+      return true;
+    }
   }
 
   return false;

package/Microsoft.ReactNative/Fabric/Composition/ScrollViewComponentView.cpp

@@ -981,8 +981,6 @@ void ScrollViewComponentView::OnPointerPressed(
   Super::OnPointerPressed(args);
 
   if (!args.Handled()) {
-    auto f = args.Pointer();
-    auto g = f.PointerDeviceType();
     m_scrollVisual.OnPointerPressed(args);
   }
 }

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.cpp

@@ -18,6 +18,7 @@
 #include <winrt/Microsoft.UI.Input.h>
 #include <winrt/Windows.System.h>
 #include <winrt/Windows.UI.h>
+#include <mutex>
 #include "../Composition.Input.h"
 #include "../CompositionHelpers.h"
 #include "../RootComponentView.h"
@@ -75,37 +76,38 @@ WindowsTextInputComponentView::DrawBlock::~DrawBlock() {
 
 // 	Msftedit.dll vs "Riched20.dll"?
 
+static std::once_flag g_richEditLoadedFlag;
 static HINSTANCE g_hInstRichEdit = nullptr;
 static PCreateTextServices g_pfnCreateTextServices;
 
 HRESULT HrEnsureRichEd20Loaded() noexcept {
-  if (g_hInstRichEdit == nullptr) {
+  HRESULT hr = S_OK;
+  std::call_once(g_richEditLoadedFlag, [&hr]() {
     g_hInstRichEdit = LoadLibrary(L"Msftedit.dll");
-    if (!g_hInstRichEdit)
-      return E_FAIL;
+    if (!g_hInstRichEdit) {
+      hr = E_FAIL;
+      return;
+    }
 
     // Create the windowless control (text services object)
     g_pfnCreateTextServices = (PCreateTextServices)GetProcAddress(g_hInstRichEdit, "CreateTextServices");
-    if (!g_pfnCreateTextServices)
-      return E_FAIL;
-
-    /*
-    // Calling the REExtendedRegisterClass() function is required for
-    // registering the REComboboxW and REListBoxW window classes.
-    PFNREGISTER pfnRegister = (PFNREGISTER)GetProcAddress(g_hInstRichEdit, "REExtendedRegisterClass");
-    if (pfnRegister) {
-      pfnRegister();
-      return S_OK;
-    } else
-      return E_FAIL;
-      */
-  }
-  return NOERROR;
+    if (!g_pfnCreateTextServices) {
+      hr = E_FAIL;
+      return;
+    }
+  });
+  if (!g_hInstRichEdit || !g_pfnCreateTextServices)
+    return E_FAIL;
+  return hr;
 }
 
 struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
   CompTextHost(WindowsTextInputComponentView *outer) : m_outer(outer) {}
 
+  void Detach() {
+    m_outer = nullptr;
+  }
+
   //@cmember Get the DC for the host
   HDC TxGetDC() override {
     assert(false);
@@ -144,6 +146,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember InvalidateRect
   void TxInvalidateRect(LPCRECT prc, BOOL fMode) override {
+    if (!m_outer)
+      return;
     if (m_outer->m_drawing)
       return;
     m_outer->DrawText();
@@ -151,6 +155,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Send a WM_PAINT to the window
   void TxViewChange(BOOL fUpdate) override {
+    if (!m_outer)
+      return;
     // When keyboard scrolling without scrollbar, TxInvalidateRect is not called.
     // Instead TxViewChange is called with fUpdate = true
     // if (fUpdate && !OnInnerViewerExtentChanged())
@@ -163,12 +169,16 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Create the caret
   BOOL TxCreateCaret(HBITMAP hbmp, INT xWidth, INT yHeight) override {
+    if (!m_outer)
+      return false;
     m_outer->m_caretVisual.Size({static_cast<float>(xWidth), static_cast<float>(yHeight)});
     return true;
   }
 
   //@cmember Show the caret
   BOOL TxShowCaret(BOOL fShow) override {
+    if (!m_outer)
+      return false;
     // Only show the caret if we have focus
     if (fShow && !m_outer->m_hasFocus) {
       return false;
@@ -179,6 +189,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Set the caret position
   BOOL TxSetCaretPos(INT x, INT y) override {
+    if (!m_outer)
+      return false;
     if (x < 0 && y < 0) {
       // RichEdit sends (-32000,-32000) when the caret is not currently visible.
       return false;
@@ -217,6 +229,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get mouse capture
   void TxSetCapture(BOOL fCapture) override {
+    if (!m_outer)
+      return;
     auto mousePointer = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::Pointer>(
         winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse, 1 /* 1 is Mouse PointerId*/);
 
@@ -229,6 +243,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Set the focus to the text window
   void TxSetFocus() override {
+    if (!m_outer)
+      return;
     winrt::Microsoft::ReactNative::ComponentView view{nullptr};
     winrt::check_hresult(
         m_outer->QueryInterface(winrt::guid_of<winrt::Microsoft::ReactNative::ComponentView>(), winrt::put_abi(view)));
@@ -242,11 +258,15 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Establish a new cursor shape
   void TxSetCursor(HCURSOR hcur, BOOL fText) override {
+    if (!m_outer)
+      return;
     m_outer->m_hcursor = hcur;
   }
 
   //@cmember Converts screen coordinates of a specified point to the client coordinates
   BOOL TxScreenToClient(LPPOINT lppt) override {
+    if (!m_outer)
+      return false;
     winrt::Windows::Foundation::Point pt{static_cast<float>(lppt->x), static_cast<float>(lppt->y)};
     pt.X -= m_outer->m_contentOffsetPx.x;
     pt.Y -= m_outer->m_contentOffsetPx.y;
@@ -258,6 +278,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Converts the client coordinates of a specified point to screen coordinates
   BOOL TxClientToScreen(LPPOINT lppt) override {
+    if (!m_outer)
+      return false;
     winrt::Windows::Foundation::Point pt{static_cast<float>(lppt->x), static_cast<float>(lppt->y)};
 
     if (!m_outer->m_parent) {
@@ -284,6 +306,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Retrieves the coordinates of a window's client area
   HRESULT TxGetClientRect(LPRECT prc) override {
+    if (!m_outer)
+      return E_FAIL;
     *prc = m_outer->getClientRect();
 
     prc->top += m_outer->m_contentOffsetPx.y;
@@ -310,6 +334,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get the default character format for the text
   HRESULT TxGetCharFormat(const CHARFORMATW **ppCF) override {
+    if (!m_outer)
+      return E_FAIL;
     m_outer->UpdateCharFormat();
 
     *ppCF = &(m_outer->m_cf);
@@ -318,6 +344,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get the default paragraph format for the text
   HRESULT TxGetParaFormat(const PARAFORMAT **ppPF) override {
+    if (!m_outer)
+      return E_FAIL;
     m_outer->UpdateParaFormat();
 
     *ppPF = &(m_outer->m_pf);
@@ -326,6 +354,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get the background color for the window
   COLORREF TxGetSysColor(int nIndex) override {
+    if (!m_outer)
+      return GetSysColor(nIndex);
     // if (/* !m_isDisabled || */ nIndex != COLOR_WINDOW && nIndex != COLOR_WINDOWTEXT && nIndex != COLOR_GRAYTEXT) {
     // This window is either not disabled or the color isn't interesting
     // in the disabled case.
@@ -400,6 +430,10 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get the maximum length for the text
   HRESULT TxGetMaxLength(DWORD *plength) override {
+    if (!m_outer) {
+      *plength = std::numeric_limits<DWORD>::max();
+      return S_OK;
+    }
     auto length = m_outer->windowsTextInputProps().maxLength;
     if (length > static_cast<decltype(m_outer->windowsTextInputProps().maxLength)>(std::numeric_limits<DWORD>::max())) {
       length = std::numeric_limits<DWORD>::max();
@@ -410,6 +444,10 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get the bits representing requested scroll bars for the window
   HRESULT TxGetScrollBars(DWORD *pdwScrollBar) override {
+    if (!m_outer) {
+      *pdwScrollBar = WS_HSCROLL | ES_AUTOHSCROLL;
+      return S_OK;
+    }
     if (m_outer->m_multiline) {
       *pdwScrollBar = WS_VSCROLL | WS_HSCROLL | ES_AUTOVSCROLL | ES_AUTOHSCROLL;
     } else {
@@ -457,7 +495,8 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Notify host of events
   HRESULT TxNotify(DWORD iNotify, void *pv) override {
-    // TODO
+    if (!m_outer)
+      return S_OK;
 
     switch (iNotify) {
       case EN_UPDATE:
@@ -542,6 +581,16 @@ WindowsTextInputComponentView::WindowsTextInputComponentView(
           reactContext,
           ComponentViewFeatures::Default & ~ComponentViewFeatures::Background) {}
 
+WindowsTextInputComponentView::~WindowsTextInputComponentView() {
+  // Release text services first to prevent further callbacks into CompTextHost.
+  m_textServices = nullptr;
+
+  // Detach the CompTextHost so any lingering references cannot use a dangling pointer.
+  if (m_textHost) {
+    winrt::get_self<CompTextHost>(m_textHost)->Detach();
+  }
+}
+
 void WindowsTextInputComponentView::HandleCommand(
     const winrt::Microsoft::ReactNative::HandleCommandArgs &args) noexcept {
   Super::HandleCommand(args);
@@ -649,17 +698,22 @@ WPARAM PointerRoutedEventArgsToMouseWParam(
   return wParam;
 }
 
-bool WindowsTextInputComponentView::IsDoubleClick() {
+bool WindowsTextInputComponentView::IsDoubleClick(uint32_t pointerId) {
   using namespace std::chrono;
 
   auto now = steady_clock::now();
-  auto duration = duration_cast<milliseconds>(now - m_lastClickTime).count();
+  auto it = m_lastClickTimeByPointer.find(pointerId);
+  bool isDouble = false;
 
-  const int DOUBLE_CLICK_TIME_MS = ::GetDoubleClickTime();
-
-  m_lastClickTime = now;
+  if (it != m_lastClickTimeByPointer.end()) {
+    auto duration = duration_cast<milliseconds>(now - it->second).count();
+    isDouble = (duration < ::GetDoubleClickTime());
+    it->second = now;
+  } else {
+    m_lastClickTimeByPointer[pointerId] = now;
+  }
 
-  return (duration < DOUBLE_CLICK_TIME_MS);
+  return isDouble;
 }
 
 void WindowsTextInputComponentView::OnPointerPressed(
@@ -678,7 +732,7 @@ void WindowsTextInputComponentView::OnPointerPressed(
   if (pp.PointerDeviceType() == winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse) {
     switch (pp.Properties().PointerUpdateKind()) {
       case winrt::Microsoft::ReactNative::Composition::Input::PointerUpdateKind::LeftButtonPressed:
-        if (IsDoubleClick()) {
+        if (IsDoubleClick(pp.PointerId())) {
           msg = WM_LBUTTONDBLCLK;
         } else {
           msg = WM_LBUTTONDOWN;
@@ -699,10 +753,14 @@ void WindowsTextInputComponentView::OnPointerPressed(
         wParam |= (XBUTTON2 << 16);
         break;
     }
-    wParam = PointerRoutedEventArgsToMouseWParam(args);
+    wParam |= PointerRoutedEventArgsToMouseWParam(args);
   } else {
-    msg = WM_POINTERDOWN;
-    wParam = PointerPointToPointerWParam(pp);
+    if (IsDoubleClick(pp.PointerId())) {
+      msg = WM_LBUTTONDBLCLK;
+    } else {
+      msg = WM_LBUTTONDOWN;
+    }
+    wParam = PointerRoutedEventArgsToMouseWParam(args);
   }
 
   if (m_textServices && msg) {
@@ -764,10 +822,10 @@ void WindowsTextInputComponentView::OnPointerReleased(
         wParam |= (XBUTTON2 << 16);
         break;
     }
-    wParam = PointerRoutedEventArgsToMouseWParam(args);
+    wParam |= PointerRoutedEventArgsToMouseWParam(args);
   } else {
-    msg = WM_POINTERUP;
-    wParam = PointerPointToPointerWParam(pp);
+    msg = WM_LBUTTONUP;
+    wParam = PointerRoutedEventArgsToMouseWParam(args);
   }
 
   if (m_textServices && msg) {
@@ -817,23 +875,18 @@ void WindowsTextInputComponentView::OnPointerMoved(
       static_cast<LONG>(position.Y * m_layoutMetrics.pointScaleFactor)};
   lParam = static_cast<LPARAM>(POINTTOPOINTS(ptContainer));
 
-  if (pp.PointerDeviceType() == winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse) {
-    msg = WM_MOUSEMOVE;
-    wParam = PointerRoutedEventArgsToMouseWParam(args);
-  } else {
-    msg = WM_POINTERUPDATE;
-    wParam = PointerPointToPointerWParam(pp);
-  }
+  msg = WM_MOUSEMOVE;
+  wParam = PointerRoutedEventArgsToMouseWParam(args);
 
   if (m_textServices) {
     LRESULT lresult;
     DrawBlock db(*this);
     auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
     args.Handled(hr != S_FALSE);
-  }
 
-  m_textServices->OnTxSetCursor(
-      DVASPECT_CONTENT, -1, nullptr, nullptr, nullptr, nullptr, nullptr, ptContainer.x, ptContainer.y);
+    m_textServices->OnTxSetCursor(
+        DVASPECT_CONTENT, -1, nullptr, nullptr, nullptr, nullptr, nullptr, ptContainer.x, ptContainer.y);
+  }
 }
 
 void WindowsTextInputComponentView::OnPointerWheelChanged(
@@ -935,7 +988,7 @@ bool WindowsTextInputComponentView::ShouldSubmit(
         bool ctrlDown = (args.KeyboardSource().GetKeyState(winrt::Windows::System::VirtualKey::Control) &
                          winrt::Microsoft::UI::Input::VirtualKeyStates::Down) ==
             winrt::Microsoft::UI::Input::VirtualKeyStates::Down;
-        bool altDown = (args.KeyboardSource().GetKeyState(winrt::Windows::System::VirtualKey::Control) &
+        bool altDown = (args.KeyboardSource().GetKeyState(winrt::Windows::System::VirtualKey::Menu) &
                         winrt::Microsoft::UI::Input::VirtualKeyStates::Down) ==
             winrt::Microsoft::UI::Input::VirtualKeyStates::Down;
         bool metaDown = (args.KeyboardSource().GetKeyState(winrt::Windows::System::VirtualKey::LeftWindows) &
@@ -946,7 +999,7 @@ bool WindowsTextInputComponentView::ShouldSubmit(
                 winrt::Microsoft::UI::Input::VirtualKeyStates::Down;
         return (submitKeyEvent.shiftKey && shiftDown) || (submitKeyEvent.ctrlKey && ctrlDown) ||
             (submitKeyEvent.altKey && altDown) || (submitKeyEvent.metaKey && metaDown) ||
-            (!submitKeyEvent.shiftKey && !submitKeyEvent.altKey && !submitKeyEvent.metaKey && !submitKeyEvent.altKey &&
+            (!submitKeyEvent.shiftKey && !submitKeyEvent.ctrlKey && !submitKeyEvent.altKey && !submitKeyEvent.metaKey &&
              !shiftDown && !ctrlDown && !altDown && !metaDown);
       } else {
         shouldSubmit = false;
@@ -1836,6 +1889,7 @@ WindowsTextInputComponentView::createVisual() noexcept {
   winrt::com_ptr<::IUnknown> spUnk;
   winrt::check_hresult(g_pfnCreateTextServices(nullptr, m_textHost.get(), spUnk.put()));
   spUnk.as(m_textServices);
+  winrt::check_bool(m_textServices != nullptr);
 
   LRESULT res;
   winrt::check_hresult(m_textServices->TxSendMessage(EM_SETTEXTMODE, TM_PLAINTEXT, 0, &res));

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.h

@@ -11,6 +11,7 @@
 #include <textserv.h>
 #include <windows.ui.composition.interop.h>
 #include <winrt/Windows.UI.Composition.h>
+#include <unordered_map>
 #include "../ComponentView.h"
 #include "../CompositionHelpers.h"
 #include "../CompositionViewComponentView.h"
@@ -74,12 +75,13 @@ struct WindowsTextInputComponentView
   std::optional<std::string> getAccessiblityValue() noexcept override;
   void setAcccessiblityValue(std::string &&value) noexcept override;
   bool getAcccessiblityIsReadOnly() noexcept override;
-  bool IsDoubleClick();
+  bool IsDoubleClick(uint32_t pointerId);
 
   WindowsTextInputComponentView(
       const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
       facebook::react::Tag tag,
       winrt::Microsoft::ReactNative::ReactContext const &reactContext);
+  ~WindowsTextInputComponentView();
 
   winrt::Microsoft::ReactNative::Composition::Experimental::IVisual createVisual() noexcept;
 
@@ -152,7 +154,7 @@ struct WindowsTextInputComponentView
   DWORD m_propBits{0};
   HCURSOR m_hcursor{nullptr};
   POINT m_caretPosition{0, 0};
-  std::chrono::steady_clock::time_point m_lastClickTime{};
+  std::unordered_map<uint32_t, std::chrono::steady_clock::time_point> m_lastClickTimeByPointer;
   std::vector<facebook::react::CompWindowsTextInputSubmitKeyEventsStruct> m_submitKeyEvents;
 };
 

package/Microsoft.ReactNative/Fabric/WindowsComponentDescriptorRegistry.cpp

@@ -46,12 +46,12 @@ WindowsComponentDescriptorRegistry::WindowsComponentDescriptorRegistry()
 }
 
 void WindowsComponentDescriptorRegistry::add(const facebook::react::ComponentDescriptorProvider &provider) noexcept {
-  m_componentNames.push_back(provider.name);
+  m_componentNames.insert(provider.name);
   m_componentDescriptorRegistry->add(provider);
 }
 
 bool WindowsComponentDescriptorRegistry::hasComponentProvider(const std::string &name) noexcept {
-  return std::find(m_componentNames.begin(), m_componentNames.end(), name) != m_componentNames.end();
+  return m_componentNames.count(name) != 0;
 }
 
 bool WindowsComponentDescriptorRegistry::isXamlSupportRequired() const noexcept {
@@ -68,7 +68,7 @@ void WindowsComponentDescriptorRegistry::Add(
   auto builder = winrt::make<winrt::Microsoft::ReactNative::Composition::ReactCompositionViewComponentBuilder>();
   provider(builder);
 
-  m_componentNames.push_back(winrt::to_string(componentName));
+  m_componentNames.insert(winrt::to_string(componentName));
   m_descriptorFlavors.emplace_back(std::make_shared<std::string>(winrt::to_string(componentName)));
   auto handle = reinterpret_cast<facebook::react::ComponentHandle>(
       facebook::react::ComponentName(m_descriptorFlavors.back()->c_str()));

package/Microsoft.ReactNative/Fabric/WindowsComponentDescriptorRegistry.h

@@ -10,6 +10,8 @@
 #include <ReactPropertyBag.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 
+#include <unordered_set>
+
 namespace Microsoft::ReactNative {
 
 struct WindowsComponentDescriptorRegistry {
@@ -41,7 +43,7 @@ struct WindowsComponentDescriptorRegistry {
   void add(const facebook::react::ComponentDescriptorProvider &provider) noexcept;
 
   std::vector<std::shared_ptr<const std::string>> m_descriptorFlavors;
-  std::vector<std::string> m_componentNames;
+  std::unordered_set<std::string> m_componentNames;
   std::shared_ptr<facebook::react::ComponentDescriptorProviderRegistry> m_componentDescriptorRegistry;
 
   std::map<std::shared_ptr<const std::string>, winrt::Microsoft::ReactNative::IReactViewComponentBuilder const>

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -72,7 +72,6 @@ wicBitmapSourceFromStream(const winrt::Windows::Storage::Streams::IRandomAccessS
     return {decodedFrame, imagingFactory, nullptr};
   } catch (winrt::hresult_error const &ex) {
     auto errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
-    errorInfo = std::make_shared<facebook::react::ImageErrorInfo>();
     errorInfo->error = ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex));
     return {nullptr, nullptr, errorInfo};
   }

package/Microsoft.ReactNative/Modules/Animated/AnimatedNode.cpp

@@ -22,19 +22,19 @@ int64_t AnimatedNode::Tag() {
 }
 
 void AnimatedNode::AddChild(const int64_t animatedNodeTag) {
-  m_children.push_back(animatedNodeTag);
+  m_children.insert(animatedNodeTag);
   GetChildNode(animatedNodeTag)->OnAttachToNode(m_tag);
 }
 
 void AnimatedNode::RemoveChild(const int64_t tag) {
   if (const auto childNode = GetChildNode(tag)) {
     childNode->OnDetachedFromNode(m_tag);
-    m_children.erase(std::find(m_children.begin(), m_children.end(), tag));
+    m_children.erase(tag);
   }
 }
 
 AnimatedNode *AnimatedNode::GetChildNode(int64_t tag) {
-  if (std::find(m_children.begin(), m_children.end(), tag) != m_children.end()) {
+  if (m_children.count(tag)) {
     if (const auto manager = m_manager.lock()) {
       return manager->GetAnimatedNode(tag);
     }

package/Microsoft.ReactNative/Modules/Animated/AnimatedNode.h

@@ -6,6 +6,7 @@
 #include <JSValue.h>
 #include <cstdint>
 #include <memory>
+#include <unordered_set>
 #include <vector>
 
 namespace Microsoft::ReactNative {
@@ -20,7 +21,7 @@ class AnimatedNode {
   void AddChild(int64_t animatedNode);
   void RemoveChild(int64_t animatedNode);
 
-  std::vector<int64_t> &Children() {
+  std::unordered_set<int64_t> &Children() {
     return m_children;
   }
 
@@ -37,7 +38,7 @@ class AnimatedNode {
   AnimatedNode *GetChildNode(int64_t tag);
   int64_t m_tag{0};
   const std::weak_ptr<NativeAnimatedNodeManager> m_manager;
-  std::vector<int64_t> m_children{};
+  std::unordered_set<int64_t> m_children{};
   bool m_useComposition{false};
 
   bool HasCompatibleAnimationDriver(int64_t tag);

package/Microsoft.ReactNative/Modules/Timing.h

@@ -9,6 +9,7 @@
 #include <ReactCoreInjection.h>
 #include <react/runtime/PlatformTimerRegistry.h>
 #include <react/runtime/TimerManager.h>
+#include <atomic>
 
 namespace Microsoft::ReactNative {
 
@@ -114,7 +115,7 @@ struct Timing : public std::enable_shared_from_this<Timing> {
   xaml::Media::CompositionTarget::Rendering_revoker m_rendering;
   winrt::Microsoft::ReactNative::ITimer m_dispatcherQueueTimer{nullptr};
   winrt::weak_ref<winrt::Microsoft::ReactNative::IReactDispatcher> m_uiDispatcher;
-  bool m_usingRendering{false};
+  std::atomic<bool> m_usingRendering{false};
   bool m_usePostForRendering{false};
 };
 

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.84.0-preview.5</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.84.0-preview.6</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>84</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>4065de3a56f0db924a7b8849b5946af2472ee050</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>91ceaa8418a39db986927aaaff0cdd07dbf9ba2e</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.84.0-preview.5",
+  "version": "0.84.0-preview.6",
   "license": "MIT",
   "repository": {
     "type": "git",