react-native-windows 0.81.3 → 0.81.4

package/Microsoft.ReactNative/ABIViewManager.cpp

@@ -190,8 +190,19 @@ void ABIViewManager::AddView(const xaml::DependencyObject &parent, const xaml::D
 }
 
 void ABIViewManager::RemoveAllChildren(const xaml::DependencyObject &parent) {
+  if (!parent) {
+    return;
+  }
+
   if (m_viewManagerWithChildren) {
-    m_viewManagerWithChildren.RemoveAllChildren(parent.as<xaml::FrameworkElement>());
+    auto fe = parent.try_as<xaml::FrameworkElement>();
+    if (fe) {
+      try {
+        m_viewManagerWithChildren.RemoveAllChildren(fe);
+      } catch (...) {
+        // External view manager may fail during shutdown if view is already disposed
+      }
+    }
   } else {
     Super::RemoveAllChildren(parent);
   }

package/Microsoft.ReactNative/CompositionSwitcher.idl

@@ -45,9 +45,16 @@ enum SnapPointsAlignment {
   void Opacity(Single value);
   void BlurRadius(Single value);
   void Color(Windows.UI.Color value);
+  void Mask(IBrush mask);
+  void SourcePolicy(CompositionDropShadowSourcePolicy policy);
 }
 
-    [webhosthidden][experimental] interface IVisual {
+    [webhosthidden][experimental] enum CompositionDropShadowSourcePolicy {
+      Default = 0,
+      InheritedOnly = 1
+    };
+
+[webhosthidden][experimental] interface IVisual {
   void InsertAt(IVisual visual, Int32 index);
   void Remove(IVisual visual);
   IVisual GetAt(UInt32 index);
@@ -72,14 +79,14 @@ enum SnapPointsAlignment {
   void AnimationClass(AnimationClass value);
 }
 
-[webhosthidden][experimental] interface ISpriteVisual
+    [webhosthidden][experimental] interface ISpriteVisual
   requires IVisual
 {
   void Brush(IBrush brush);
   void Shadow(IDropShadow shadow);
 }
 
-    [webhosthidden][experimental] interface IRoundedRectangleVisual
+[webhosthidden][experimental] interface IRoundedRectangleVisual
   requires IVisual
 {
   void Brush(IBrush brush);
@@ -88,13 +95,13 @@ enum SnapPointsAlignment {
   void StrokeThickness(Single value);
 }
 
-[webhosthidden][experimental] interface IScrollPositionChangedArgs {
+    [webhosthidden][experimental] interface IScrollPositionChangedArgs {
   Windows.Foundation.Numerics.Vector2 Position {
     get;
   };
 }
 
-    [webhosthidden][experimental] interface IScrollVisual
+[webhosthidden][experimental] interface IScrollVisual
   requires IVisual
 {
   void Brush(IBrush brush);
@@ -122,7 +129,7 @@ enum SnapPointsAlignment {
   void SnapToAlignment(SnapPointsAlignment alignment);
 }
 
-[webhosthidden][experimental] interface IActivityVisual
+    [webhosthidden][experimental] interface IActivityVisual
   requires IVisual
 {
   void Size(Single value);
@@ -131,7 +138,7 @@ enum SnapPointsAlignment {
   void StopAnimation();
 }
 
-    [webhosthidden][experimental] interface ICaretVisual {
+[webhosthidden][experimental] interface ICaretVisual {
   IVisual InnerVisual {
     get;
   };
@@ -144,7 +151,7 @@ enum SnapPointsAlignment {
   void Brush(IBrush brush);
 }
 
-[webhosthidden][experimental] interface IFocusVisual {
+    [webhosthidden][experimental] interface IFocusVisual {
   IVisual InnerVisual {
     get;
   };
@@ -158,7 +165,7 @@ enum SnapPointsAlignment {
   };
 }
 
-    [webhosthidden][experimental] interface ICompositionContext {
+[webhosthidden][experimental] interface ICompositionContext {
   ISpriteVisual CreateSpriteVisual();
   IScrollVisual CreateScrollerVisual();
   IRoundedRectangleVisual CreateRoundedRectangleVisual();

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

@@ -54,6 +54,7 @@ struct CompositionTypeTraits<WindowsTypeTag> {
   using CompositionStretch = winrt::Windows::UI::Composition::CompositionStretch;
   using CompositionStrokeCap = winrt::Windows::UI::Composition::CompositionStrokeCap;
   using CompositionSurfaceBrush = winrt::Windows::UI::Composition::CompositionSurfaceBrush;
+  using CompositionDropShadowSourcePolicy = winrt::Windows::UI::Composition::CompositionDropShadowSourcePolicy;
   using Compositor = winrt::Windows::UI::Composition::Compositor;
   using ContainerVisual = winrt::Windows::UI::Composition::ContainerVisual;
   using CubicBezierEasingFunction = winrt::Windows::UI::Composition::CubicBezierEasingFunction;
@@ -127,6 +128,7 @@ struct CompositionTypeTraits<MicrosoftTypeTag> {
   using CompositionStretch = winrt::Microsoft::UI::Composition::CompositionStretch;
   using CompositionStrokeCap = winrt::Microsoft::UI::Composition::CompositionStrokeCap;
   using CompositionSurfaceBrush = winrt::Microsoft::UI::Composition::CompositionSurfaceBrush;
+  using CompositionDropShadowSourcePolicy = winrt::Microsoft::UI::Composition::CompositionDropShadowSourcePolicy;
   using Compositor = winrt::Microsoft::UI::Composition::Compositor;
   using ContainerVisual = winrt::Microsoft::UI::Composition::ContainerVisual;
   using CubicBezierEasingFunction = winrt::Microsoft::UI::Composition::CubicBezierEasingFunction;
@@ -224,6 +226,19 @@ struct CompDropShadow : public winrt::implements<
     m_shadow.Color(color);
   }
 
+  void Mask(winrt::Microsoft::ReactNative::Composition::Experimental::IBrush const &mask) noexcept {
+    if (mask) {
+      m_shadow.Mask(mask.as<typename TTypeRedirects::IInnerCompositionBrush>()->InnerBrush());
+    } else {
+      m_shadow.Mask(nullptr);
+    }
+  }
+
+  void SourcePolicy(
+      winrt::Microsoft::ReactNative::Composition::Experimental::CompositionDropShadowSourcePolicy policy) noexcept {
+    m_shadow.SourcePolicy(static_cast<typename TTypeRedirects::CompositionDropShadowSourcePolicy>(policy));
+  }
+
  private:
   typename TTypeRedirects::DropShadow m_shadow;
 };

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

@@ -710,7 +710,86 @@ void ComponentView::applyShadowProps(const facebook::react::ViewProps &viewProps
       shadow.Color(theme()->Color(*viewProps.shadowColor));
   }
 
-  Visual().as<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual>().Shadow(shadow);
+  // Check if any border radius is set
+  auto borderMetrics = BorderPrimitive::resolveAndAlignBorderMetrics(m_layoutMetrics, viewProps);
+  bool hasBorderRadius = borderMetrics.borderRadii.topLeft.horizontal != 0 ||
+      borderMetrics.borderRadii.topRight.horizontal != 0 || borderMetrics.borderRadii.bottomLeft.horizontal != 0 ||
+      borderMetrics.borderRadii.bottomRight.horizontal != 0 || borderMetrics.borderRadii.topLeft.vertical != 0 ||
+      borderMetrics.borderRadii.topRight.vertical != 0 || borderMetrics.borderRadii.bottomLeft.vertical != 0 ||
+      borderMetrics.borderRadii.bottomRight.vertical != 0;
+
+  if (hasBorderRadius) {
+    // When borderRadius is set, we need to create a shadow mask that follows the rounded rectangle shape.
+    // Use CompositionVisualSurface to capture the clipped visual's appearance as the shadow mask.
+    bool maskSet = false;
+
+    // Try Microsoft (WinUI3) Composition first
+    auto msCompositor =
+        winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::InnerCompositor(
+            m_compContext);
+    if (msCompositor) {
+      auto innerVisual =
+          winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::InnerVisual(
+              Visual());
+      if (innerVisual) {
+        // Create a VisualSurface that captures the visual (with its clip applied)
+        auto visualSurface = msCompositor.CreateVisualSurface();
+        visualSurface.SourceVisual(innerVisual);
+        visualSurface.SourceSize(
+            {m_layoutMetrics.frame.size.width * m_layoutMetrics.pointScaleFactor,
+             m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor});
+
+        // Create a brush from the visual surface to use as shadow mask
+        auto maskBrush = msCompositor.CreateSurfaceBrush(visualSurface);
+        maskBrush.Stretch(winrt::Microsoft::UI::Composition::CompositionStretch::Fill);
+
+        // Get the inner shadow and set the mask
+        auto innerShadow = winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::
+            InnerDropShadow(shadow);
+        if (innerShadow) {
+          innerShadow.Mask(maskBrush);
+          maskSet = true;
+        }
+      }
+    }
+
+    // Fallback to System (Windows.UI) Composition if Microsoft Composition is not available
+    if (!maskSet) {
+      auto sysCompositor =
+          winrt::Microsoft::ReactNative::Composition::Experimental::SystemCompositionContextHelper::InnerCompositor(
+              m_compContext);
+      if (sysCompositor) {
+        auto innerVisual =
+            winrt::Microsoft::ReactNative::Composition::Experimental::SystemCompositionContextHelper::InnerVisual(
+                Visual());
+        if (innerVisual) {
+          auto visualSurface = sysCompositor.CreateVisualSurface();
+          visualSurface.SourceVisual(innerVisual);
+          visualSurface.SourceSize(
+              {m_layoutMetrics.frame.size.width * m_layoutMetrics.pointScaleFactor,
+               m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor});
+
+          auto maskBrush = sysCompositor.CreateSurfaceBrush(visualSurface);
+          maskBrush.Stretch(winrt::Windows::UI::Composition::CompositionStretch::Fill);
+
+          auto innerShadow =
+              winrt::Microsoft::ReactNative::Composition::Experimental::SystemCompositionContextHelper::InnerDropShadow(
+                  shadow);
+          if (innerShadow) {
+            innerShadow.Mask(maskBrush);
+          }
+        }
+      }
+    }
+
+    // Apply shadow to OuterVisual (which is not clipped) so the shadow can extend beyond the clip
+    OuterVisual().as<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual>().Shadow(shadow);
+    Visual().as<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual>().Shadow(nullptr);
+  } else {
+    // No border radius - apply shadow directly to Visual (original behavior)
+    Visual().as<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual>().Shadow(shadow);
+    OuterVisual().as<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual>().Shadow(nullptr);
+  }
 }
 
 void ComponentView::updateTransformProps(

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

@@ -43,9 +43,19 @@ ContentIslandComponentView::ContentIslandComponentView(
       });
 }
 
-void ContentIslandComponentView::OnMounted() noexcept {
+winrt::Microsoft::UI::Content::ContentIsland ContentIslandComponentView::ParentContentIsland() noexcept {
+  auto root = rootComponentView();
+  if (!root)
+    return nullptr;
+  return root->parentContentIsland();
+}
+
+void ContentIslandComponentView::ConnectInternal() noexcept {
+  if (!m_islandToConnect)
+    return;
+
   m_childSiteLink = winrt::Microsoft::UI::Content::ChildSiteLink::Create(
-      rootComponentView()->parentContentIsland(),
+      m_parentContentIsland,
       winrt::Microsoft::ReactNative::Composition::Experimental::CompositionContextHelper::InnerVisual(Visual())
           .as<winrt::Microsoft::UI::Composition::ContainerVisual>());
   m_childSiteLink.ActualSize({m_layoutMetrics.frame.size.width, m_layoutMetrics.frame.size.height});
@@ -69,6 +79,7 @@ void ContentIslandComponentView::OnMounted() noexcept {
     m_childSiteLink.Connect(m_islandToConnect);
     m_islandToConnect = nullptr;
   }
+  UnregisterForRootIslandEvents();
 
   ParentLayoutChanged();
   auto view = Parent();
@@ -85,12 +96,42 @@ void ContentIslandComponentView::OnMounted() noexcept {
   }
 }
 
+void ContentIslandComponentView::RegisterForRootIslandEvents() noexcept {
+  m_parentContentIsland = ParentContentIsland();
+
+  if (m_parentContentIsland.IsConnected()) {
+    ConnectInternal();
+  } else {
+    m_islandStateChangedToken = m_parentContentIsland.StateChanged(
+        [wkThis = get_weak()](
+            const winrt::Microsoft::UI::Content::ContentIsland & /*island*/,
+            const winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs & /*args*/) {
+          if (auto strongThis = wkThis.get()) {
+            strongThis->ConnectInternal();
+          }
+        });
+  }
+}
+
+void ContentIslandComponentView::UnregisterForRootIslandEvents() noexcept {
+  if (m_islandStateChangedToken) {
+    m_parentContentIsland.StateChanged(m_islandStateChangedToken);
+    m_islandStateChangedToken = {};
+    m_parentContentIsland = nullptr;
+  }
+}
+
+void ContentIslandComponentView::OnMounted() noexcept {
+  RegisterForRootIslandEvents();
+}
+
 void ContentIslandComponentView::OnUnmounted() noexcept {
   m_layoutMetricChangedRevokers.clear();
   if (m_navigationHostDepartFocusRequestedToken && m_navigationHost) {
     m_navigationHost.DepartFocusRequested(m_navigationHostDepartFocusRequestedToken);
     m_navigationHostDepartFocusRequestedToken = {};
   }
+  UnregisterForRootIslandEvents();
 }
 
 void ContentIslandComponentView::ParentLayoutChanged() noexcept {

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

@@ -58,9 +58,16 @@ struct ContentIslandComponentView : ContentIslandComponentViewT<ContentIslandCom
   void OnMounted() noexcept;
   void OnUnmounted() noexcept;
   void ParentLayoutChanged() noexcept;
+  void ConnectInternal() noexcept;
+  void RegisterForRootIslandEvents() noexcept;
+  void UnregisterForRootIslandEvents() noexcept;
+  winrt::Microsoft::UI::Content::ContentIsland ParentContentIsland() noexcept;
 
   bool m_layoutChangePosted{false};
+  winrt::Microsoft::UI::Content::ContentIsland m_parentContentIsland{nullptr};
   winrt::Microsoft::UI::Content::ContentIsland m_islandToConnect{nullptr};
+  winrt::event_token m_islandStateChangedToken;
+
   winrt::event_token m_mountedToken;
   winrt::event_token m_unmountedToken;
   std::vector<winrt::Microsoft::ReactNative::ComponentView::LayoutMetricsChanged_revoker> m_layoutMetricChangedRevokers;

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

@@ -167,6 +167,26 @@ void ParagraphComponentView::updateTextAlignment(
   m_textLayout = nullptr;
 }
 
+facebook::react::Tag ParagraphComponentView::hitTest(
+    facebook::react::Point pt,
+    facebook::react::Point &localPt,
+    bool ignorePointerEvents) const noexcept {
+  facebook::react::Point ptLocal{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+  const auto &props = paragraphProps();
+  const auto &vProps = *viewProps();
+
+  if (props.isSelectable && ptLocal.x >= 0 && ptLocal.x <= m_layoutMetrics.frame.size.width && ptLocal.y >= 0 &&
+      ptLocal.y <= m_layoutMetrics.frame.size.height) {
+    // claims if pointer events are enabled for this component
+    if (ignorePointerEvents || vProps.pointerEvents == facebook::react::PointerEventsMode::Auto ||
+        vProps.pointerEvents == facebook::react::PointerEventsMode::BoxOnly) {
+      localPt = ptLocal;
+      return Tag();
+    }
+  }
+  return Super::hitTest(pt, localPt, ignorePointerEvents);
+}
+
 bool ParagraphComponentView::IsTextSelectableAtPoint(facebook::react::Point pt) noexcept {
   // paragraph-level selectable prop is enabled
   const auto &props = paragraphProps();
@@ -519,6 +539,7 @@ void ParagraphComponentView::ClearSelection() noexcept {
   m_selectionStart = std::nullopt;
   m_selectionEnd = std::nullopt;
   m_isSelecting = false;
+  m_isWordSelecting = false;
   if (hadSelection) {
     // Clears selection highlight
     DrawText();
@@ -534,7 +555,8 @@ void ParagraphComponentView::OnPointerPressed(
     return;
   }
 
-  auto pp = args.GetCurrentPoint(-1);
+  // Use Tag() to get coordinates in component's local space
+  auto pp = args.GetCurrentPoint(static_cast<int32_t>(Tag()));
 
   // Ignores right-click
   if (pp.Properties().PointerUpdateKind() ==
@@ -545,8 +567,8 @@ void ParagraphComponentView::OnPointerPressed(
 
   auto position = pp.Position();
 
-  facebook::react::Point localPt{
-      position.X - m_layoutMetrics.frame.origin.x, position.Y - m_layoutMetrics.frame.origin.y};
+  // GetCurrentPoint(Tag()) returns position relative to component origin
+  facebook::react::Point localPt{position.X, position.Y};
 
   std::optional<int32_t> charPosition = GetTextPositionAtPoint(localPt);
 
@@ -568,7 +590,13 @@ void ParagraphComponentView::OnPointerPressed(
 
     if (isDoubleClick) {
       SelectWordAtPosition(*charPosition);
-      m_isSelecting = false;
+      if (m_selectionStart && m_selectionEnd) {
+        m_isWordSelecting = true;
+        m_wordAnchorStart = *m_selectionStart;
+        m_wordAnchorEnd = *m_selectionEnd;
+        m_isSelecting = true;
+        CapturePointer(args.Pointer());
+      }
     } else {
       // Single-click: start drag selection
       m_selectionStart = charPosition;
@@ -610,17 +638,35 @@ void ParagraphComponentView::OnPointerMoved(
   facebook::react::Point localPt{position.X, position.Y};
   std::optional<int32_t> charPosition = GetClampedTextPosition(localPt);
 
-  if (charPosition && charPosition != m_selectionEnd) {
-    m_selectionEnd = charPosition;
-    DrawText();
-    args.Handled(true);
+  if (charPosition) {
+    if (m_isWordSelecting) {
+      // Extend selection by whole words
+      auto [wordStart, wordEnd] = GetWordBoundariesAtPosition(*charPosition);
+
+      if (*charPosition < m_wordAnchorStart) {
+        m_selectionStart = wordStart;
+        m_selectionEnd = m_wordAnchorEnd;
+      } else if (*charPosition >= m_wordAnchorEnd) {
+        m_selectionStart = m_wordAnchorStart;
+        m_selectionEnd = wordEnd;
+      } else {
+        m_selectionStart = m_wordAnchorStart;
+        m_selectionEnd = m_wordAnchorEnd;
+      }
+      DrawText();
+      args.Handled(true);
+    } else if (charPosition != m_selectionEnd) {
+      m_selectionEnd = charPosition;
+      DrawText();
+      args.Handled(true);
+    }
   }
 }
 
 void ParagraphComponentView::OnPointerReleased(
     const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
   // Check for right-click to show context menu
-  auto pp = args.GetCurrentPoint(-1);
+  auto pp = args.GetCurrentPoint(static_cast<int32_t>(Tag()));
   if (pp.Properties().PointerUpdateKind() ==
       winrt::Microsoft::ReactNative::Composition::Input::PointerUpdateKind::RightButtonReleased) {
     const auto &props = paragraphProps();
@@ -637,6 +683,7 @@ void ParagraphComponentView::OnPointerReleased(
   }
 
   m_isSelecting = false;
+  m_isWordSelecting = false;
 
   ReleasePointerCapture(args.Pointer());
 
@@ -661,6 +708,7 @@ void ParagraphComponentView::OnPointerCaptureLost() noexcept {
   // Pointer capture was lost stop any active selection drag
   if (m_isSelecting) {
     m_isSelecting = false;
+    m_isWordSelecting = false;
 
     if (!m_selectionStart || !m_selectionEnd || *m_selectionStart == *m_selectionEnd) {
       m_selectionStart = std::nullopt;
@@ -711,12 +759,17 @@ void ParagraphComponentView::CopySelectionToClipboard() noexcept {
   winrt::Windows::ApplicationModel::DataTransfer::Clipboard::SetContent(dataPackage);
 }
 
-void ParagraphComponentView::SelectWordAtPosition(int32_t charPosition) noexcept {
+std::pair<int32_t, int32_t> ParagraphComponentView::GetWordBoundariesAtPosition(int32_t charPosition) noexcept {
   const std::wstring utf16Text{facebook::react::WindowsTextLayoutManager::GetTransformedText(m_attributedStringBox)};
   const int32_t textLength = static_cast<int32_t>(utf16Text.length());
 
-  if (utf16Text.empty() || charPosition < 0 || charPosition >= textLength) {
-    return;
+  if (utf16Text.empty() || charPosition < 0) {
+    return {0, 0};
+  }
+
+  charPosition = std::min(charPosition, textLength - 1);
+  if (charPosition < 0) {
+    return {0, 0};
   }
 
   int32_t wordStart = charPosition;
@@ -749,6 +802,12 @@ void ParagraphComponentView::SelectWordAtPosition(int32_t charPosition) noexcept
     }
   }
 
+  return {wordStart, wordEnd};
+}
+
+void ParagraphComponentView::SelectWordAtPosition(int32_t charPosition) noexcept {
+  auto [wordStart, wordEnd] = GetWordBoundariesAtPosition(charPosition);
+
   if (wordEnd > wordStart) {
     SetSelection(wordStart, wordEnd);
     DrawText();

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

@@ -49,6 +49,11 @@ struct ParagraphComponentView : ParagraphComponentViewT<ParagraphComponentView,
   static facebook::react::SharedViewProps defaultProps() noexcept;
   const facebook::react::ParagraphProps &paragraphProps() const noexcept;
 
+  facebook::react::Tag hitTest(
+      facebook::react::Point pt,
+      facebook::react::Point &localPt,
+      bool ignorePointerEvents = false) const noexcept override;
+
   // Returns true when text is selectable
   bool focusable() const noexcept override;
 
@@ -95,6 +100,7 @@ struct ParagraphComponentView : ParagraphComponentViewT<ParagraphComponentView,
 
   // Selects the word at the given character position
   void SelectWordAtPosition(int32_t charPosition) noexcept;
+  std::pair<int32_t, int32_t> GetWordBoundariesAtPosition(int32_t charPosition) noexcept;
 
   // Shows a context menu with Copy/Select All options on right-click
   void ShowContextMenu() noexcept;
@@ -113,6 +119,11 @@ struct ParagraphComponentView : ParagraphComponentViewT<ParagraphComponentView,
   std::optional<int32_t> m_selectionEnd;
   bool m_isSelecting{false};
 
+  // Double click + drag selection
+  bool m_isWordSelecting{false};
+  int32_t m_wordAnchorStart{0};
+  int32_t m_wordAnchorEnd{0};
+
   // Double-click detection
   std::chrono::steady_clock::time_point m_lastClickTime{};
   std::optional<int32_t> m_lastClickPosition;

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

@@ -48,7 +48,8 @@ HRESULT UiaNavigateHelper(
         uint32_t index = children.Size() - 1;
         do {
           auto child = children.GetAt(index).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-          if (uiaProvider = child->EnsureUiaProvider()) {
+          uiaProvider = child->EnsureUiaProvider();
+          if (uiaProvider) {
             break;
           }
         } while (index-- != 0);
@@ -60,7 +61,8 @@ HRESULT UiaNavigateHelper(
         uint32_t index = 0;
         do {
           auto child = children.GetAt(index).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-          if (uiaProvider = child->EnsureUiaProvider()) {
+          uiaProvider = child->EnsureUiaProvider();
+          if (uiaProvider) {
             break;
           }
         } while (++index != children.Size());
@@ -74,7 +76,8 @@ HRESULT UiaNavigateHelper(
 
         while (++it != children.end()) {
           auto nextchild = (*it).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-          if (uiaProvider = nextchild->EnsureUiaProvider()) {
+          uiaProvider = nextchild->EnsureUiaProvider();
+          if (uiaProvider) {
             break;
           }
         }
@@ -91,7 +94,8 @@ HRESULT UiaNavigateHelper(
           do {
             it--;
             auto prevchild = (*it).as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
-            if (uiaProvider = prevchild->EnsureUiaProvider()) {
+            uiaProvider = prevchild->EnsureUiaProvider();
+            if (uiaProvider) {
               break;
             }
           } while (it != children.begin());

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -30,20 +30,33 @@ using namespace xaml::Media::Imaging;
 
 namespace Microsoft::ReactNative {
 
+static const char *ERROR_INVALID_URI = "E_INVALID_URI";
+static const char *ERROR_GET_SIZE_FAILURE = "E_GET_SIZE_FAILURE";
+
 winrt::fire_and_forget GetImageSizeAsync(
     const winrt::Microsoft::ReactNative::IReactPropertyBag &properties,
     std::string uriString,
     winrt::Microsoft::ReactNative::JSValue &&headers,
     Mso::Functor<void(int32_t width, int32_t height)> successCallback,
-    Mso::Functor<void()> errorCallback
+    Mso::Functor<void(const char *errorCode, std::string errorMessage)> errorCallback
 #ifdef USE_FABRIC
     ,
     bool useFabric
 #endif // USE_FABRIC
 ) {
   bool succeeded{false};
+  const char *errorCode = ERROR_GET_SIZE_FAILURE;
+  std::string errorMessage;
 
   try {
+    // Validate URI is not empty
+    if (uriString.empty()) {
+      errorCode = ERROR_INVALID_URI;
+      errorMessage = "Cannot get the size of an image for an empty URI";
+      errorCallback(errorCode, errorMessage);
+      co_return;
+    }
+
     ReactImageSource source;
     source.uri = uriString;
     if (!headers.IsNull()) {
@@ -56,9 +69,10 @@ winrt::fire_and_forget GetImageSizeAsync(
     winrt::hstring scheme{uri.SchemeName()};
     bool needsDownload = (scheme == L"http") || (scheme == L"https");
     bool inlineData = scheme == L"data";
+    bool isLocalFile = (scheme == L"file") || (scheme == L"ms-appx") || (scheme == L"ms-appdata");
 
     winrt::IRandomAccessStream memoryStream;
-    if (needsDownload) {
+    if (needsDownload || isLocalFile) {
       memoryStream = co_await GetImageStreamAsync(properties, source);
     } else if (inlineData) {
       memoryStream = co_await GetImageInlineDataAsync(source);
@@ -77,23 +91,31 @@ winrt::fire_and_forget GetImageSizeAsync(
       }
 #ifdef USE_FABRIC
     } else {
-      auto result = wicBitmapSourceFromStream(memoryStream);
-      if (!std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
-        auto imagingFactory = std::get<winrt::com_ptr<IWICImagingFactory>>(result);
-        auto wicBmpSource = std::get<winrt::com_ptr<IWICBitmapSource>>(result);
-        UINT width, height;
-        if (SUCCEEDED(wicBmpSource->GetSize(&width, &height))) {
-          successCallback(width, height);
-          succeeded = true;
+      if (memoryStream) { // Added nullcheck to prevent app from crashing if value is uninitialized
+        auto result = wicBitmapSourceFromStream(memoryStream);
+        if (!std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
+          auto imagingFactory = std::get<winrt::com_ptr<IWICImagingFactory>>(result);
+          auto wicBmpSource = std::get<winrt::com_ptr<IWICBitmapSource>>(result);
+          UINT width, height;
+          if (SUCCEEDED(wicBmpSource->GetSize(&width, &height))) {
+            successCallback(width, height);
+            succeeded = true;
+          }
         }
       }
     }
 #endif // USE_FABRIC
-  } catch (winrt::hresult_error const &) {
+  } catch (winrt::hresult_error const &e) {
+    errorMessage = "Failed to get image size: " + Microsoft::Common::Unicode::Utf16ToUtf8(std::wstring(e.message())) +
+        " for URI: " + uriString;
   }
 
-  if (!succeeded)
-    errorCallback();
+  if (!succeeded) {
+    if (errorMessage.empty()) {
+      errorMessage = "Failed to get image size for URI: " + uriString;
+    }
+    errorCallback(errorCode, errorMessage);
+  }
 
   co_return;
 }
@@ -112,7 +134,9 @@ void ImageLoader::getSize(std::string uri, React::ReactPromise<std::vector<doubl
             [result](double width, double height) noexcept {
               result.Resolve(std::vector<double>{width, height});
             },
-            [result]() noexcept { result.Reject("Failed"); }
+            [result](const char *errorCode, std::string errorMessage) noexcept {
+              result.Reject(React::ReactError{errorCode, errorMessage});
+            }
 #ifdef USE_FABRIC
             ,
             IsFabricEnabled(context.Properties().Handle())
@@ -137,7 +161,9 @@ void ImageLoader::getSizeWithHeaders(
         [result](double width, double height) noexcept {
           result.Resolve(Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType{width, height});
         },
-        [result]() noexcept { result.Reject("Failed"); }
+        [result](const char *errorCode, std::string errorMessage) noexcept {
+          result.Reject(React::ReactError{errorCode, errorMessage});
+        }
 #ifdef USE_FABRIC
         ,
         IsFabricEnabled(context.Properties().Handle())

package/Mso/src/dispatchQueue/queueService.cpp

@@ -205,8 +205,10 @@ void QueueService::InvokeTask(
   DispatchTask taskToInvoke{std::move(task)};
   taskToInvoke.Get()->Invoke(); // Call Get()->Invoke instead of operator() to flatten call stack
 
-  while (taskToInvoke = context.TakeNextDeferredTask()) {
+  taskToInvoke = context.TakeNextDeferredTask();
+  while (taskToInvoke) {
     taskToInvoke.Get()->Invoke();
+    taskToInvoke = context.TakeNextDeferredTask();
   }
 }
 

package/Mso/src/dispatchQueue/uiScheduler_winrt.cpp

@@ -271,7 +271,8 @@ bool UISchedulerWinRT<TDispatcherTraits>::TryTakeTask(
     --m_taskCount;
   }
 
-  if (queue = m_queue.GetStrongPtr()) {
+  queue = m_queue.GetStrongPtr();
+  if (queue) {
     return queue->TryDequeTask(task);
   }
 

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.81.3</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.81.4</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>81</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>3</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>4</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>2c35b82f34d7821ca3d855c0bb51fb44d4d8c1df</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>6cfb66be9b4dbbdff53e896e215230cdeddc38a6</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Networking/OriginPolicyHttpFilter.cpp

@@ -758,7 +758,8 @@ ResponseOperation OriginPolicyHttpFilter::SendRequestAsync(HttpRequestMessage co
     if (originPolicy == OriginPolicy::CrossOriginResourceSharing) {
       // If inner filter can AllowRedirect, disable for preflight.
       winrt::impl::com_ref<IHttpBaseProtocolFilter> baseFilter;
-      if (baseFilter = m_innerFilter.try_as<IHttpBaseProtocolFilter>()) {
+      baseFilter = m_innerFilter.try_as<IHttpBaseProtocolFilter>();
+      if (baseFilter) {
         baseFilter.AllowAutoRedirect(false);
       }
 

package/codegen/react/components/rnwcore/AndroidDrawerLayout.g.h

@@ -59,55 +59,55 @@ struct AndroidDrawerLayoutProps : winrt::implements<AndroidDrawerLayoutProps, wi
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(AndroidDrawerLayout_OnDrawerSlide)
-struct AndroidDrawerLayout_OnDrawerSlide {
-  REACT_FIELD(offset)
-  float offset{};
+REACT_STRUCT(AndroidDrawerLayoutSpec_onDrawerClose)
+struct AndroidDrawerLayoutSpec_onDrawerClose {
 };
 
-REACT_STRUCT(AndroidDrawerLayout_OnDrawerStateChanged)
-struct AndroidDrawerLayout_OnDrawerStateChanged {
-  REACT_FIELD(drawerState)
-  int32_t drawerState{};
+REACT_STRUCT(AndroidDrawerLayoutSpec_onDrawerOpen)
+struct AndroidDrawerLayoutSpec_onDrawerOpen {
 };
 
-REACT_STRUCT(AndroidDrawerLayout_OnDrawerOpen)
-struct AndroidDrawerLayout_OnDrawerOpen {
+REACT_STRUCT(AndroidDrawerLayoutSpec_onDrawerStateChanged)
+struct AndroidDrawerLayoutSpec_onDrawerStateChanged {
+  REACT_FIELD(drawerState)
+  int32_t drawerState{};
 };
 
-REACT_STRUCT(AndroidDrawerLayout_OnDrawerClose)
-struct AndroidDrawerLayout_OnDrawerClose {
+REACT_STRUCT(AndroidDrawerLayoutSpec_onDrawerSlide)
+struct AndroidDrawerLayoutSpec_onDrawerSlide {
+  REACT_FIELD(offset)
+  float offset{};
 };
 
 struct AndroidDrawerLayoutEventEmitter {
   AndroidDrawerLayoutEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnDrawerSlide = AndroidDrawerLayout_OnDrawerSlide;
-  using OnDrawerStateChanged = AndroidDrawerLayout_OnDrawerStateChanged;
-  using OnDrawerOpen = AndroidDrawerLayout_OnDrawerOpen;
-  using OnDrawerClose = AndroidDrawerLayout_OnDrawerClose;
+  using OnDrawerSlide = AndroidDrawerLayoutSpec_onDrawerSlide;
+  using OnDrawerStateChanged = AndroidDrawerLayoutSpec_onDrawerStateChanged;
+  using OnDrawerOpen = AndroidDrawerLayoutSpec_onDrawerOpen;
+  using OnDrawerClose = AndroidDrawerLayoutSpec_onDrawerClose;
 
   void onDrawerSlide(OnDrawerSlide &value) const {
-    m_eventEmitter.DispatchEvent(L"drawerSlide", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"drawerSlide", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }
 
   void onDrawerStateChanged(OnDrawerStateChanged &value) const {
-    m_eventEmitter.DispatchEvent(L"drawerStateChanged", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"drawerStateChanged", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }
 
   void onDrawerOpen(OnDrawerOpen &value) const {
-    m_eventEmitter.DispatchEvent(L"drawerOpen", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"drawerOpen", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }
 
   void onDrawerClose(OnDrawerClose &value) const {
-    m_eventEmitter.DispatchEvent(L"drawerClose", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"drawerClose", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/codegen/react/components/rnwcore/AndroidSwipeRefreshLayout.g.h

@@ -59,18 +59,18 @@ struct AndroidSwipeRefreshLayoutProps : winrt::implements<AndroidSwipeRefreshLay
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(AndroidSwipeRefreshLayout_OnRefresh)
-struct AndroidSwipeRefreshLayout_OnRefresh {
+REACT_STRUCT(AndroidSwipeRefreshLayoutSpec_onRefresh)
+struct AndroidSwipeRefreshLayoutSpec_onRefresh {
 };
 
 struct AndroidSwipeRefreshLayoutEventEmitter {
   AndroidSwipeRefreshLayoutEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnRefresh = AndroidSwipeRefreshLayout_OnRefresh;
+  using OnRefresh = AndroidSwipeRefreshLayoutSpec_onRefresh;
 
   void onRefresh(OnRefresh &value) const {
-    m_eventEmitter.DispatchEvent(L"refresh", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"refresh", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/codegen/react/components/rnwcore/AndroidSwitch.g.h

@@ -71,8 +71,8 @@ struct AndroidSwitchProps : winrt::implements<AndroidSwitchProps, winrt::Microso
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(AndroidSwitch_OnChange)
-struct AndroidSwitch_OnChange {
+REACT_STRUCT(AndroidSwitchSpec_onChange)
+struct AndroidSwitchSpec_onChange {
   REACT_FIELD(value)
   bool value{};
 
@@ -84,10 +84,10 @@ struct AndroidSwitchEventEmitter {
   AndroidSwitchEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnChange = AndroidSwitch_OnChange;
+  using OnChange = AndroidSwitchSpec_onChange;
 
   void onChange(OnChange &value) const {
-    m_eventEmitter.DispatchEvent(L"change", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"change", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/codegen/react/components/rnwcore/ModalHostView.g.h

@@ -83,53 +83,53 @@ struct ModalHostViewProps : winrt::implements<ModalHostViewProps, winrt::Microso
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(ModalHostView_OnRequestClose)
-struct ModalHostView_OnRequestClose {
+REACT_STRUCT(ModalHostViewSpec_onOrientationChange)
+struct ModalHostViewSpec_onOrientationChange {
+  REACT_FIELD(orientation)
+  std::string orientation;
 };
 
-REACT_STRUCT(ModalHostView_OnShow)
-struct ModalHostView_OnShow {
+REACT_STRUCT(ModalHostViewSpec_onDismiss)
+struct ModalHostViewSpec_onDismiss {
 };
 
-REACT_STRUCT(ModalHostView_OnDismiss)
-struct ModalHostView_OnDismiss {
+REACT_STRUCT(ModalHostViewSpec_onShow)
+struct ModalHostViewSpec_onShow {
 };
 
-REACT_STRUCT(ModalHostView_OnOrientationChange)
-struct ModalHostView_OnOrientationChange {
-  REACT_FIELD(orientation)
-  std::string orientation;
+REACT_STRUCT(ModalHostViewSpec_onRequestClose)
+struct ModalHostViewSpec_onRequestClose {
 };
 
 struct ModalHostViewEventEmitter {
   ModalHostViewEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnRequestClose = ModalHostView_OnRequestClose;
-  using OnShow = ModalHostView_OnShow;
-  using OnDismiss = ModalHostView_OnDismiss;
-  using OnOrientationChange = ModalHostView_OnOrientationChange;
+  using OnRequestClose = ModalHostViewSpec_onRequestClose;
+  using OnShow = ModalHostViewSpec_onShow;
+  using OnDismiss = ModalHostViewSpec_onDismiss;
+  using OnOrientationChange = ModalHostViewSpec_onOrientationChange;
 
   void onRequestClose(OnRequestClose &value) const {
-    m_eventEmitter.DispatchEvent(L"requestClose", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"requestClose", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }
 
   void onShow(OnShow &value) const {
-    m_eventEmitter.DispatchEvent(L"show", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"show", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }
 
   void onDismiss(OnDismiss &value) const {
-    m_eventEmitter.DispatchEvent(L"dismiss", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"dismiss", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }
 
   void onOrientationChange(OnOrientationChange &value) const {
-    m_eventEmitter.DispatchEvent(L"orientationChange", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"orientationChange", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/codegen/react/components/rnwcore/PullToRefreshView.g.h

@@ -55,18 +55,18 @@ struct PullToRefreshViewProps : winrt::implements<PullToRefreshViewProps, winrt:
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(PullToRefreshView_OnRefresh)
-struct PullToRefreshView_OnRefresh {
+REACT_STRUCT(PullToRefreshViewSpec_onRefresh)
+struct PullToRefreshViewSpec_onRefresh {
 };
 
 struct PullToRefreshViewEventEmitter {
   PullToRefreshViewEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnRefresh = PullToRefreshView_OnRefresh;
+  using OnRefresh = PullToRefreshViewSpec_onRefresh;
 
   void onRefresh(OnRefresh &value) const {
-    m_eventEmitter.DispatchEvent(L"refresh", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"refresh", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/codegen/react/components/rnwcore/Switch.g.h

@@ -67,8 +67,8 @@ struct SwitchProps : winrt::implements<SwitchProps, winrt::Microsoft::ReactNativ
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(Switch_OnChange)
-struct Switch_OnChange {
+REACT_STRUCT(SwitchSpec_onChange)
+struct SwitchSpec_onChange {
   REACT_FIELD(value)
   bool value{};
 
@@ -80,10 +80,10 @@ struct SwitchEventEmitter {
   SwitchEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnChange = Switch_OnChange;
+  using OnChange = SwitchSpec_onChange;
 
   void onChange(OnChange &value) const {
-    m_eventEmitter.DispatchEvent(L"change", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"change", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/codegen/react/components/rnwcore/VirtualView.g.h

@@ -43,8 +43,38 @@ struct VirtualViewProps : winrt::implements<VirtualViewProps, winrt::Microsoft::
   const winrt::Microsoft::ReactNative::ViewProps ViewProps;
 };
 
-REACT_STRUCT(VirtualView_OnModeChange)
-struct VirtualView_OnModeChange {
+REACT_STRUCT(VirtualViewSpec_onModeChange3)
+struct VirtualViewSpec_onModeChange3 {
+  REACT_FIELD(x)
+  double x{};
+
+  REACT_FIELD(y)
+  double y{};
+
+  REACT_FIELD(width)
+  double width{};
+
+  REACT_FIELD(height)
+  double height{};
+};
+
+REACT_STRUCT(VirtualViewSpec_onModeChange2)
+struct VirtualViewSpec_onModeChange2 {
+  REACT_FIELD(x)
+  double x{};
+
+  REACT_FIELD(y)
+  double y{};
+
+  REACT_FIELD(width)
+  double width{};
+
+  REACT_FIELD(height)
+  double height{};
+};
+
+REACT_STRUCT(VirtualViewSpec_onModeChange)
+struct VirtualViewSpec_onModeChange {
   REACT_FIELD(mode)
   int32_t mode{};
 
@@ -59,12 +89,10 @@ struct VirtualViewEventEmitter {
   VirtualViewEventEmitter(const winrt::Microsoft::ReactNative::EventEmitter &eventEmitter)
       : m_eventEmitter(eventEmitter) {}
 
-  using OnModeChange = VirtualView_OnModeChange;
-  using OnModeChange2 = VirtualView_OnModeChange2;
-  using OnModeChange3 = VirtualView_OnModeChange3;
+  using OnModeChange = VirtualViewSpec_onModeChange;
 
   void onModeChange(OnModeChange &value) const {
-    m_eventEmitter.DispatchEvent(L"modeChange", [value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
+    m_eventEmitter.DispatchEvent(L"modeChange", [&value](const winrt::Microsoft::ReactNative::IJSValueWriter writer) {
       winrt::Microsoft::ReactNative::WriteValue(writer, value);
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.81.3",
+  "version": "0.81.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "@react-native-community/cli": "17.0.0",
     "@react-native-community/cli-platform-android": "17.0.0",
     "@react-native-community/cli-platform-ios": "17.0.0",
-    "@react-native-windows/cli": "0.81.1",
+    "@react-native-windows/cli": "0.81.2",
     "@react-native/assets": "1.0.0",
     "@react-native/assets-registry": "0.81.5",
     "@react-native/codegen": "0.81.5",
@@ -68,7 +68,7 @@
     "yargs": "^17.6.2"
   },
   "devDependencies": {
-    "@react-native-windows/codegen": "0.81.1",
+    "@react-native-windows/codegen": "0.81.2",
     "@react-native/metro-config": "0.81.5",
     "@rnw-scripts/babel-react-native-config": "0.0.0",
     "@rnw-scripts/eslint-config": "1.2.37",