react-native-windows 0.81.2 → 0.81.4

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

@@ -11,18 +11,14 @@
 namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionTextRangeProvider::CompositionTextRangeProvider(
-    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
-    CompositionDynamicAutomationProvider *parentProvider) noexcept
-    : m_view{componentView} {
-  m_parentProvider.copy_from(parentProvider);
-}
+    const winrt::Microsoft::ReactNative::ComponentView &componentView) noexcept
+    : m_view{componentView} {}
 
 HRESULT __stdcall CompositionTextRangeProvider::Clone(ITextRangeProvider **pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
 
-  auto clone = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionTextRangeProvider>(
-      m_view.view().as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), m_parentProvider.get());
+  auto clone = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionTextRangeProvider>(m_view.view());
   *pRetVal = clone.detach();
   return S_OK;
 }
@@ -91,13 +87,13 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  auto props = std::static_pointer_cast<const facebook::react::ParagraphProps>(
+  auto props = std::static_pointer_cast<const facebook::react::BaseViewProps>(
       winrt::get_self<ComponentView>(strongView)->props());
 
-  auto textinputProps = std::static_pointer_cast<const facebook::react::WindowsTextInputProps>(
-      winrt::get_self<ComponentView>(strongView)->props());
+  auto asParagraph =
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>();
 
-  auto isTextInput =
+  auto asTextInput =
       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>();
 
   if (props == nullptr)
@@ -106,15 +102,16 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
   if (attributeId == UIA_BackgroundColorAttributeId) {
     pRetVal->vt = VT_I4;
     pRetVal->lVal = (*props->backgroundColor).AsColorRefWithAlpha();
-  } else if (attributeId == UIA_CapStyleAttributeId) {
+  } else if (attributeId == UIA_CapStyleAttributeId && asParagraph) {
     pRetVal->vt = VT_I4;
     auto fontVariant = facebook::react::FontVariant::Default;
     auto textTransform = facebook::react::TextTransform::None;
-    if (props->textAttributes.fontVariant.has_value()) {
-      fontVariant = props->textAttributes.fontVariant.value();
+
+    if (asParagraph->paragraphProps().textAttributes.fontVariant.has_value()) {
+      fontVariant = asParagraph->paragraphProps().textAttributes.fontVariant.value();
     }
-    if (props->textAttributes.textTransform.has_value()) {
-      textTransform = props->textAttributes.textTransform.value();
+    if (asParagraph->paragraphProps().textAttributes.textTransform.has_value()) {
+      textTransform = asParagraph->paragraphProps().textAttributes.textTransform.value();
     }
     if (fontVariant == facebook::react::FontVariant::SmallCaps) {
       pRetVal->lVal = CapStyle_SmallCap;
@@ -125,39 +122,44 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
     } else if (textTransform == facebook::react::TextTransform::Uppercase) {
       pRetVal->lVal = CapStyle_AllCap;
     }
-  } else if (attributeId == UIA_FontNameAttributeId) {
+  } else if (attributeId == UIA_FontNameAttributeId && asParagraph) {
     pRetVal->vt = VT_BSTR;
-    auto fontName = props->textAttributes.fontFamily;
+    auto fontName = asParagraph->paragraphProps().textAttributes.fontFamily;
     if (fontName.empty()) {
       fontName = "Segoe UI";
     }
     std::wstring wfontName(fontName.begin(), fontName.end());
     pRetVal->bstrVal = SysAllocString(wfontName.c_str());
-  } else if (attributeId == UIA_FontSizeAttributeId) {
+  } else if (attributeId == UIA_FontSizeAttributeId && asParagraph) {
     pRetVal->vt = VT_R8;
-    pRetVal->dblVal = props->textAttributes.fontSize;
-  } else if (attributeId == UIA_FontWeightAttributeId) {
-    if (props->textAttributes.fontWeight.has_value()) {
+    pRetVal->dblVal = asParagraph->paragraphProps().textAttributes.fontSize;
+  } else if (attributeId == UIA_FontWeightAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.fontWeight.has_value()) {
       pRetVal->vt = VT_I4;
-      pRetVal->lVal = static_cast<long>(props->textAttributes.fontWeight.value());
+      pRetVal->lVal = static_cast<long>(asParagraph->paragraphProps().textAttributes.fontWeight.value());
     }
-  } else if (attributeId == UIA_ForegroundColorAttributeId) {
+  } else if (attributeId == UIA_ForegroundColorAttributeId && asParagraph) {
     pRetVal->vt = VT_I4;
-    pRetVal->lVal = (*props->textAttributes.foregroundColor).AsColorRefWithAlpha();
-  } else if (attributeId == UIA_IsItalicAttributeId) {
+    pRetVal->lVal = (*asParagraph->paragraphProps().textAttributes.foregroundColor).AsColorRefWithAlpha();
+  } else if (attributeId == UIA_IsItalicAttributeId && asParagraph) {
     pRetVal->vt = VT_BOOL;
-    pRetVal->boolVal = (props->textAttributes.fontStyle.has_value() &&
-                        props->textAttributes.fontStyle.value() == facebook::react::FontStyle::Italic)
+    pRetVal->boolVal =
+        (asParagraph->paragraphProps().textAttributes.fontStyle.has_value() &&
+         asParagraph->paragraphProps().textAttributes.fontStyle.value() == facebook::react::FontStyle::Italic)
         ? VARIANT_TRUE
         : VARIANT_FALSE;
   } else if (attributeId == UIA_IsReadOnlyAttributeId) {
     pRetVal->vt = VT_BOOL;
-    pRetVal->boolVal = isTextInput ? textinputProps->editable ? VARIANT_FALSE : VARIANT_TRUE : VARIANT_TRUE;
-  } else if (attributeId == UIA_HorizontalTextAlignmentAttributeId) {
+    if (asTextInput) {
+      pRetVal->boolVal = asTextInput->windowsTextInputProps().editable ? VARIANT_FALSE : VARIANT_TRUE;
+    } else {
+      pRetVal->boolVal = VARIANT_TRUE;
+    }
+  } else if (attributeId == UIA_HorizontalTextAlignmentAttributeId && asParagraph) {
     pRetVal->vt = VT_I4;
     auto textAlign = facebook::react::TextAlignment::Center;
-    if (props->textAttributes.alignment.has_value()) {
-      textAlign = props->textAttributes.alignment.value();
+    if (asParagraph->paragraphProps().textAttributes.alignment.has_value()) {
+      textAlign = asParagraph->paragraphProps().textAttributes.alignment.value();
     }
     if (textAlign == facebook::react::TextAlignment::Left) {
       pRetVal->lVal = HorizontalTextAlignment_Left;
@@ -170,40 +172,42 @@ HRESULT __stdcall CompositionTextRangeProvider::GetAttributeValue(TEXTATTRIBUTEI
     } else if (textAlign == facebook::react::TextAlignment::Natural) {
       pRetVal->lVal = HorizontalTextAlignment_Left;
     }
-  } else if (attributeId == UIA_StrikethroughColorAttributeId) {
-    if (props->textAttributes.textDecorationLineType.has_value() &&
-        (props->textAttributes.textDecorationLineType.value() ==
+  } else if (attributeId == UIA_StrikethroughColorAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::Strikethrough ||
-         props->textAttributes.textDecorationLineType.value() ==
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      pRetVal->lVal = (*props->textAttributes.textDecorationColor).AsColorRefWithAlpha();
+      pRetVal->lVal = (*asParagraph->paragraphProps().textAttributes.textDecorationColor).AsColorRefWithAlpha();
     }
-  } else if (attributeId == UIA_StrikethroughStyleAttributeId) {
-    if (props->textAttributes.textDecorationLineType.has_value() &&
-        (props->textAttributes.textDecorationLineType.value() ==
+  } else if (attributeId == UIA_StrikethroughStyleAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::Strikethrough ||
-         props->textAttributes.textDecorationLineType.value() ==
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      auto style = props->textAttributes.textDecorationStyle.value();
+      auto style = asParagraph->paragraphProps().textAttributes.textDecorationStyle.value();
       pRetVal->lVal = GetTextDecorationLineStyle(style);
     }
-  } else if (attributeId == UIA_UnderlineColorAttributeId) {
-    if (props->textAttributes.textDecorationLineType.has_value() &&
-        (props->textAttributes.textDecorationLineType.value() == facebook::react::TextDecorationLineType::Underline ||
-         props->textAttributes.textDecorationLineType.value() ==
+  } else if (attributeId == UIA_UnderlineColorAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::Underline ||
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      pRetVal->lVal = (*props->textAttributes.textDecorationColor).AsColorRefWithAlpha();
+      pRetVal->lVal = (*asParagraph->paragraphProps().textAttributes.textDecorationColor).AsColorRefWithAlpha();
     }
-  } else if (attributeId == UIA_UnderlineStyleAttributeId) {
-    if (props->textAttributes.textDecorationLineType.has_value() &&
-        (props->textAttributes.textDecorationLineType.value() == facebook::react::TextDecorationLineType::Underline ||
-         props->textAttributes.textDecorationLineType.value() ==
+  } else if (attributeId == UIA_UnderlineStyleAttributeId && asParagraph) {
+    if (asParagraph->paragraphProps().textAttributes.textDecorationLineType.has_value() &&
+        (asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
+             facebook::react::TextDecorationLineType::Underline ||
+         asParagraph->paragraphProps().textAttributes.textDecorationLineType.value() ==
              facebook::react::TextDecorationLineType::UnderlineStrikethrough)) {
       pRetVal->vt = VT_I4;
-      auto style = props->textAttributes.textDecorationStyle.value();
+      auto style = asParagraph->paragraphProps().textAttributes.textDecorationStyle.value();
       pRetVal->lVal = GetTextDecorationLineStyle(style);
     }
   }
@@ -214,7 +218,18 @@ HRESULT __stdcall CompositionTextRangeProvider::GetBoundingRectangles(SAFEARRAY
   if (pRetVal == nullptr)
     return E_POINTER;
   UiaRect rect;
-  auto hr = m_parentProvider->get_BoundingRectangle(&rect);
+
+  auto strongView = m_view.view();
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto componentView = strongView.as<winrt::Microsoft::ReactNative::implementation::ComponentView>();
+  auto provider = componentView->EnsureUiaProvider();
+  auto repf = provider.try_as<IRawElementProviderFragment>();
+  if (!repf)
+    return E_FAIL;
+
+  auto hr = repf->get_BoundingRectangle(&rect);
   if (FAILED(hr))
     return hr;
   *pRetVal = SafeArrayCreateVector(VT_R8, 0, 4);

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

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
 #include <Fabric/Composition/CompositionTextProvider.h>
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <Fabric/ReactTaggedView.h>
@@ -12,9 +11,7 @@ namespace winrt::Microsoft::ReactNative::implementation {
 
 class CompositionTextRangeProvider : public winrt::implements<CompositionTextRangeProvider, ITextRangeProvider> {
  public:
-  CompositionTextRangeProvider(
-      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
-      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+  CompositionTextRangeProvider(const winrt::Microsoft::ReactNative::ComponentView &componentView) noexcept;
 
   // inherited via ITextRangeProvider
   virtual HRESULT __stdcall Clone(ITextRangeProvider **pRetVal) override;
@@ -53,7 +50,6 @@ class CompositionTextRangeProvider : public winrt::implements<CompositionTextRan
 
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
-  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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(
@@ -801,8 +880,8 @@ void ComponentView::updateAccessibilityProps(
   winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
       EnsureUiaProvider(),
       UIA_LiveSettingPropertyId,
-      oldViewProps.accessibilityLiveRegion,
-      newViewProps.accessibilityLiveRegion);
+      winrt::Microsoft::ReactNative::implementation::GetLiveSetting(oldViewProps.accessibilityLiveRegion),
+      winrt::Microsoft::ReactNative::implementation::GetLiveSetting(newViewProps.accessibilityLiveRegion));
 
   winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
       EnsureUiaProvider(), UIA_LevelPropertyId, oldViewProps.accessibilityLevel, newViewProps.accessibilityLevel);
@@ -857,14 +936,13 @@ void ComponentView::updateAccessibilityProps(
 
   if ((oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->selected.has_value()) !=
       ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value()))) {
-    auto compProvider =
-        EnsureUiaProvider()
-            .try_as<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>();
-    if (compProvider) {
+    EnsureUiaProvider();
+    if (m_innerAutomationProvider) {
       if ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value())) {
-        winrt::Microsoft::ReactNative::implementation::AddSelectionItemsToContainer(compProvider.get());
+        winrt::Microsoft::ReactNative::implementation::AddSelectionItemsToContainer(m_innerAutomationProvider.get());
       } else {
-        winrt::Microsoft::ReactNative::implementation::RemoveSelectionItemsFromContainer(compProvider.get());
+        winrt::Microsoft::ReactNative::implementation::RemoveSelectionItemsFromContainer(
+            m_innerAutomationProvider.get());
       }
     }
   }
@@ -1354,12 +1432,17 @@ std::string ViewComponentView::DefaultControlType() const noexcept {
   return "group";
 }
 
-winrt::IInspectable ComponentView::EnsureUiaProvider() noexcept {
-  if (m_uiaProvider == nullptr) {
-    m_uiaProvider =
-        winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>(*get_strong());
-  }
-  return m_uiaProvider;
+winrt::Windows::Foundation::IInspectable ComponentView::CreateAutomationProvider() noexcept {
+  Assert(!m_innerAutomationProvider);
+  m_innerAutomationProvider =
+      winrt::make_self<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>(
+          *get_strong());
+  return *m_innerAutomationProvider;
+}
+
+const winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>
+    &ComponentView::InnerAutomationProvider() const noexcept {
+  return m_innerAutomationProvider;
 }
 
 bool IntersectRect(RECT *prcDst, const RECT &prcSrc1, const RECT &prcSrc2) {

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

@@ -19,8 +19,11 @@ namespace Microsoft::ReactNative {
 struct CompContext;
 } // namespace Microsoft::ReactNative
 
-namespace winrt::Microsoft::ReactNative::Composition::implementation {
+namespace winrt::Microsoft::ReactNative::implementation {
+class CompositionDynamicAutomationProvider;
+}
 
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
 struct FocusPrimitive {
   std::shared_ptr<BorderPrimitive> m_focusInnerPrimitive;
   std::shared_ptr<BorderPrimitive> m_focusOuterPrimitive;
@@ -100,7 +103,9 @@ struct ComponentView : public ComponentViewT<
   comp::CompositionPropertySet EnsureCenterPointPropertySet() noexcept;
   void EnsureTransformMatrixFacade() noexcept;
 
-  winrt::IInspectable EnsureUiaProvider() noexcept override;
+  winrt::Windows::Foundation::IInspectable CreateAutomationProvider() noexcept override;
+  const winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>
+      &InnerAutomationProvider() const noexcept;
   std::optional<std::string> getAccessiblityValue() noexcept override;
   void setAcccessiblityValue(std::string &&value) noexcept override;
   bool getAcccessiblityIsReadOnly() noexcept override;
@@ -130,7 +135,9 @@ struct ComponentView : public ComponentViewT<
       facebook::react::Point &ptContent,
       facebook::react::Point &localPt) const noexcept;
 
-  winrt::IInspectable m_uiaProvider{nullptr};
+  // Most access should be through EnsureUIAProvider, instead of direct access to this.
+  winrt::com_ptr<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>
+      m_innerAutomationProvider;
   winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext m_compContext;
   comp::CompositionPropertySet m_centerPropSet{nullptr};
   facebook::react::SharedViewEventEmitter m_eventEmitter;

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 {
@@ -111,12 +152,11 @@ void ContentIslandComponentView::ParentLayoutChanged() noexcept {
   });
 }
 
-winrt::IInspectable ContentIslandComponentView::EnsureUiaProvider() noexcept {
-  if (m_uiaProvider == nullptr) {
-    m_uiaProvider = winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>(
-        *get_strong(), m_childSiteLink);
-  }
-  return m_uiaProvider;
+winrt::Windows::Foundation::IInspectable ContentIslandComponentView::CreateAutomationProvider() noexcept {
+  m_innerAutomationProvider =
+      winrt::make_self<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>(
+          *get_strong(), m_childSiteLink);
+  return *m_innerAutomationProvider;
 }
 
 bool ContentIslandComponentView::focusable() const noexcept {
@@ -126,6 +166,27 @@ bool ContentIslandComponentView::focusable() const noexcept {
   return true;
 }
 
+facebook::react::Tag ContentIslandComponentView::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};
+
+  // Check if the point is within the bounds of this ContentIslandComponentView.
+  // This ensures that hit tests correctly return this view's tag for UIA purposes,
+  // even when the actual content (XAML buttons, etc.) is hosted in the ContentIsland.
+  auto props = viewProps();
+  if ((ignorePointerEvents || props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+       props->pointerEvents == facebook::react::PointerEventsMode::BoxOnly) &&
+      ptLocal.x >= 0 && ptLocal.x <= m_layoutMetrics.frame.size.width && ptLocal.y >= 0 &&
+      ptLocal.y <= m_layoutMetrics.frame.size.height) {
+    localPt = ptLocal;
+    return Tag();
+  }
+
+  return -1;
+}
+
 // Helper to convert a FocusNavigationDirection to a FocusNavigationReason.
 winrt::Microsoft::UI::Input::FocusNavigationReason GetFocusNavigationReason(
     winrt::Microsoft::ReactNative::FocusNavigationDirection direction) noexcept {
@@ -178,14 +239,12 @@ ContentIslandComponentView::~ContentIslandComponentView() noexcept {
 void ContentIslandComponentView::MountChildComponentView(
     const winrt::Microsoft::ReactNative::ComponentView &childComponentView,
     uint32_t index) noexcept {
-  assert(false);
   base_type::MountChildComponentView(childComponentView, index);
 }
 
 void ContentIslandComponentView::UnmountChildComponentView(
     const winrt::Microsoft::ReactNative::ComponentView &childComponentView,
     uint32_t index) noexcept {
-  assert(false);
   base_type::UnmountChildComponentView(childComponentView, index);
 }
 
@@ -262,6 +321,10 @@ void ContentIslandComponentView::ConfigureChildSiteLinkAutomation() noexcept {
         args.AutomationProvider(nullptr);
         args.Handled(true);
       });
+
+  if (m_innerAutomationProvider) {
+    m_innerAutomationProvider->SetChildSiteLink(m_childSiteLink);
+  }
 }
 
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -40,7 +40,10 @@ struct ContentIslandComponentView : ContentIslandComponentViewT<ContentIslandCom
 
   bool focusable() const noexcept override;
 
-  winrt::Windows::Foundation::IInspectable EnsureUiaProvider() noexcept override;
+  facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt, bool ignorePointerEvents)
+      const noexcept override;
+
+  winrt::Windows::Foundation::IInspectable CreateAutomationProvider() noexcept override;
 
   void onGotFocus(const winrt::Microsoft::ReactNative::Composition::Input::RoutedEventArgs &args) noexcept override;
 
@@ -55,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/DebuggingOverlayComponentView.cpp

@@ -86,10 +86,11 @@ void DebuggingOverlayComponentView::HandleCommand(
     if (auto root = rootComponentView()) {
       auto rootVisual = root->OuterVisual();
       auto brush = m_compContext.CreateColorBrush({204, 200, 230, 255});
+      float scaleFactor = m_layoutMetrics.pointScaleFactor;
       for (auto &element : elements) {
         auto overlayVisual = m_compContext.CreateSpriteVisual();
-        overlayVisual.Size({element.width, element.height});
-        overlayVisual.Offset({element.x, element.y, 0.0f});
+        overlayVisual.Size({element.width * scaleFactor, element.height * scaleFactor});
+        overlayVisual.Offset({element.x * scaleFactor, element.y * scaleFactor, 0.0f});
         overlayVisual.Brush(brush);
 
         rootVisual.InsertAt(overlayVisual, root->overlayIndex() + m_activeOverlays);

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

@@ -22,7 +22,6 @@
 #include <winrt/Windows.UI.Composition.h>
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
-#include "CompositionDynamicAutomationProvider.h"
 #include "CompositionHelpers.h"
 #include "RootComponentView.h"