react-native-windows 0.85.0-preview.1 → 0.85.0

package/Directory.Build.props

@@ -15,7 +15,7 @@
 
     <!--
       SourceLink is disabled by default since customer projects are still building our projects and therefore we don't want to force customers to use this.
-      The PR (windows-vs-pr.yml) and CI (publish.yml() turn it back on.
+      In-repo builds (BuildingInRnwRepo=true) turn it back on below.
     -->
     <EnableSourceLink Condition="'$(EnableSourceLink)' == '' AND '$(BuildingInRnwRepo)' == 'true'">true</EnableSourceLink>
     <EnableSourceLink Condition="'$(EnableSourceLink)' == ''">false</EnableSourceLink>

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

@@ -32,21 +32,7 @@ bool IsHiddenByParent(const winrt::Microsoft::ReactNative::ComponentView &view)
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
     const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
-    : m_view{componentView} {
-  auto strongView = m_view.view();
-
-  if (!strongView)
-    return;
-
-  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
-      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
-  if (!props)
-    return;
-
-  if (props->accessibilityState.has_value() && props->accessibilityState->selected.has_value()) {
-    AddSelectionItemsToContainer(this);
-  }
-}
+    : m_view{componentView} {}
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
     const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
@@ -951,53 +937,49 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsSelectionRequired(
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::GetSelection(SAFEARRAY **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
   auto strongView = m_view.view();
 
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  std::vector<int> selectedItems;
-  for (size_t i = 0; i < m_selectionItems.size(); i++) {
-    auto selectionItem = m_selectionItems.at(i);
-
-    winrt::com_ptr<IUnknown> unkSelectionItemProvider;
-    auto hr = selectionItem->GetPatternProvider(UIA_SelectionItemPatternId, unkSelectionItemProvider.put());
-    if (FAILED(hr))
-      return hr;
-
-    auto selectionItemProvider = unkSelectionItemProvider.try_as<ISelectionItemProvider>();
-    if (!selectionItemProvider)
-      return E_FAIL;
-
-    BOOL selected;
-    hr = selectionItemProvider->get_IsSelected(&selected);
-    if (hr == S_OK && selected) {
-      selectedItems.push_back(int(i));
-    }
-  }
+  auto selectedItems = GetSelectedItemsInSelectionContainer(strongView);
 
   *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, ULONG(selectedItems.size()));
   if (*pRetVal == nullptr)
     return E_OUTOFMEMORY;
 
   for (size_t i = 0; i < selectedItems.size(); i++) {
+    auto selectionItem =
+        selectedItems[i].try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
+    if (!selectionItem) {
+      SafeArrayDestroy(*pRetVal);
+      *pRetVal = nullptr;
+      return E_FAIL;
+    }
+
+    auto selectionItemProvider = selectionItem->EnsureUiaProvider().try_as<IRawElementProviderSimple>();
+    if (!selectionItemProvider) {
+      SafeArrayDestroy(*pRetVal);
+      *pRetVal = nullptr;
+      return E_FAIL;
+    }
+
     auto pos = static_cast<long>(i);
-    SafeArrayPutElement(*pRetVal, &pos, m_selectionItems.at(selectedItems.at(i)).get());
+    auto hr = SafeArrayPutElement(*pRetVal, &pos, selectionItemProvider.get());
+    if (FAILED(hr)) {
+      SafeArrayDestroy(*pRetVal);
+      *pRetVal = nullptr;
+      return hr;
+    }
   }
   return S_OK;
 }
 
-void CompositionDynamicAutomationProvider::AddToSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item) {
-  if (std::find(m_selectionItems.begin(), m_selectionItems.end(), item) != m_selectionItems.end()) {
-    return;
-  }
-  m_selectionItems.push_back(item);
-}
-
-void CompositionDynamicAutomationProvider::RemoveFromSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item) {
-  std::erase(m_selectionItems, item);
-}
-
 HRESULT __stdcall CompositionDynamicAutomationProvider::AddToSelection() {
   auto strongView = m_view.view();
 

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

@@ -95,8 +95,6 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall RemoveFromSelection() override;
   virtual HRESULT __stdcall Select() override;
 
-  void AddToSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
-  void RemoveFromSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
   winrt::Microsoft::ReactNative::ComponentView GetSelectionContainer() noexcept;
 
   void SetChildSiteLink(winrt::Microsoft::UI::Content::ChildSiteLink childSiteLink) {
@@ -111,7 +109,6 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   ::Microsoft::ReactNative::ReactTaggedView m_view;
   winrt::com_ptr<ITextProvider2> m_textProvider;
   winrt::com_ptr<IAnnotationProvider> m_annotationProvider;
-  std::vector<winrt::com_ptr<IRawElementProviderSimple>> m_selectionItems;
   // Non-null when this UIA node is the peer of a ContentIslandComponentView.
   winrt::Microsoft::UI::Content::ChildSiteLink m_childSiteLink{nullptr};
 };

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

@@ -23,6 +23,7 @@
 #include "CompositionDynamicAutomationProvider.h"
 #include "CompositionHelpers.h"
 #include "RootComponentView.h"
+#include "SelectionItemAutomationEvent.h"
 #include "Theme.h"
 #include "TooltipService.h"
 #include "UiaHelpers.h"
@@ -963,19 +964,6 @@ void ComponentView::updateAccessibilityProps(
         static_cast<int>(winrt::Microsoft::ReactNative::implementation::GetExpandCollapseState(oldExpanded)),
         static_cast<int>(winrt::Microsoft::ReactNative::implementation::GetExpandCollapseState(newExpanded)));
   }
-
-  if ((oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->selected.has_value()) !=
-      ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value()))) {
-    EnsureUiaProvider();
-    if (m_innerAutomationProvider) {
-      if ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value())) {
-        winrt::Microsoft::ReactNative::implementation::AddSelectionItemsToContainer(m_innerAutomationProvider.get());
-      } else {
-        winrt::Microsoft::ReactNative::implementation::RemoveSelectionItemsFromContainer(
-            m_innerAutomationProvider.get());
-      }
-    }
-  }
 }
 
 std::optional<std::string> ComponentView::getAccessiblityValue() noexcept {
@@ -1271,6 +1259,10 @@ void ViewComponentView::updateProps(
     facebook::react::Props::Shared const &oldProps) noexcept {
   const auto &oldViewProps = *std::static_pointer_cast<const facebook::react::ViewProps>(oldProps ? oldProps : m_props);
   const auto &newViewProps = *std::static_pointer_cast<const facebook::react::ViewProps>(props);
+  const auto oldSelected =
+      oldViewProps.accessibilityState.has_value() ? oldViewProps.accessibilityState->selected : std::nullopt;
+  const auto newSelected =
+      newViewProps.accessibilityState.has_value() ? newViewProps.accessibilityState->selected : std::nullopt;
 
   ensureVisual();
   if (oldViewProps.opacity != newViewProps.opacity) {
@@ -1286,6 +1278,20 @@ void ViewComponentView::updateProps(
   base_type::updateProps(props, oldProps);
 
   m_props = std::static_pointer_cast<facebook::react::ViewProps const>(props);
+
+  if (UiaClientsAreListening() &&
+      winrt::Microsoft::ReactNative::implementation::ShouldRaiseSelectionItemStateChanged(
+          isMounted(), oldSelected, newSelected)) {
+    auto provider = EnsureUiaProvider();
+    winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+        provider, UIA_SelectionItemIsSelectedPropertyId, oldSelected.value_or(false), newSelected.value_or(false));
+
+    if (m_innerAutomationProvider) {
+      auto root = rootComponentView();
+      winrt::Microsoft::ReactNative::implementation::RaiseSelectionItemAutomationEvent(
+          m_innerAutomationProvider.get(), newSelected.value_or(false), root && root->GetFocusedComponent() == *this);
+    }
+  }
 }
 
 const winrt::Microsoft::ReactNative::IComponentProps ViewComponentView::userProps(

package/Microsoft.ReactNative/Fabric/Composition/Modal/WindowsModalHostViewComponentView.cpp

@@ -15,6 +15,22 @@
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
+static winrt::Windows::UI::Color CompositeOverOpaqueBackground(
+    const winrt::Windows::UI::Color &foreground,
+    const winrt::Windows::UI::Color &background) noexcept {
+  const uint32_t alpha = foreground.A;
+  const uint32_t inverseAlpha = 0xFF - alpha;
+  const auto compositeChannel = [alpha, inverseAlpha](uint8_t foregroundChannel, uint8_t backgroundChannel) {
+    return static_cast<uint8_t>((foregroundChannel * alpha + backgroundChannel * inverseAlpha + 0x7F) / 0xFF);
+  };
+
+  return {
+      0xFF,
+      compositeChannel(foreground.R, background.R),
+      compositeChannel(foreground.G, background.G),
+      compositeChannel(foreground.B, background.B)};
+}
+
 struct ModalHostState
     : winrt::implements<ModalHostState, winrt::Microsoft::ReactNative::Composition::IPortalStateData> {
   ModalHostState(winrt::Microsoft::ReactNative::LayoutConstraints layoutConstraints, float scaleFactor)
@@ -36,6 +52,8 @@ struct ModalHostState
 struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::Foundation::IInspectable>,
                        ::Microsoft::ReactNativeSpecs::BaseModalHostView<ModalHostView> {
   ~ModalHostView() {
+    UnsubscribeFromThemeChanges();
+
     if (m_popUp) {
       // Unregister closing event handler
       if (m_appWindowClosingToken) {
@@ -171,6 +189,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
 
  private:
   void OnMounted(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+    SubscribeToThemeChanges(view);
     m_mounted = true;
     if (m_visible) {
       QueueShow(view);
@@ -178,9 +197,47 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   }
 
   void OnUnmounted(const winrt::Microsoft::ReactNative::ComponentView & /*view*/) noexcept {
+    UnsubscribeFromThemeChanges();
     m_mounted = false;
   }
 
+  void SubscribeToThemeChanges(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+    UnsubscribeFromThemeChanges();
+
+    auto themeSource = view.Parent().as<winrt::Microsoft::ReactNative::Composition::ComponentView>();
+    m_themeSource = winrt::make_weak(themeSource);
+    m_theme = themeSource.Theme();
+    const auto themeSubscriptionGeneration = m_themeSubscriptionGeneration;
+    m_themeChangedToken = themeSource.ThemeChanged([wkThis = get_weak(), themeSubscriptionGeneration](
+                                                       const winrt::Windows::Foundation::IInspectable &sender,
+                                                       const winrt::Windows::Foundation::IInspectable & /*args*/) {
+      auto theme = sender.as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Theme();
+      if (auto strongThis = wkThis.get()) {
+        strongThis->m_reactContext.UIDispatcher().Post([wkThis, theme, themeSubscriptionGeneration]() {
+          if (auto strongThis = wkThis.get()) {
+            if (strongThis->m_themeSubscriptionGeneration != themeSubscriptionGeneration) {
+              return;
+            }
+            strongThis->m_theme = theme;
+            strongThis->UpdateTitleBarColors();
+          }
+        });
+      }
+    });
+  }
+
+  void UnsubscribeFromThemeChanges() noexcept {
+    if (m_themeChangedToken) {
+      if (auto themeSource = m_themeSource.get()) {
+        themeSource.ThemeChanged(m_themeChangedToken);
+      }
+      m_themeChangedToken = {};
+    }
+    m_themeSource = {};
+    m_theme = nullptr;
+    ++m_themeSubscriptionGeneration;
+  }
+
   void AdjustWindowSize(const winrt::Microsoft::ReactNative::LayoutMetrics &layoutMetrics) noexcept {
     if (!m_rnWindow) {
       return;
@@ -318,6 +375,52 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
 
       titleBar.IconShowOptions(winrt::Microsoft::UI::Windowing::IconShowOptions::HideIconAndSystemMenu);
     }
+
+    UpdateTitleBarColors();
+  }
+
+  void UpdateTitleBarColors() noexcept {
+    if (!m_rnWindow || !m_theme || !m_localProps || m_localProps->hideTitleBar.value_or(false) ||
+        !winrt::Microsoft::UI::Windowing::AppWindowTitleBar::IsCustomizationSupported()) {
+      return;
+    }
+
+    winrt::Windows::UI::Color background;
+    winrt::Windows::UI::Color activeForeground;
+    winrt::Windows::UI::Color inactiveForeground;
+    winrt::Windows::UI::Color buttonHoverBackground;
+    winrt::Windows::UI::Color buttonPressedBackground;
+    winrt::Windows::UI::Color buttonPressedForeground;
+    if (!m_theme.TryGetPlatformColor(L"SolidBackgroundFillColorBase", background) ||
+        !m_theme.TryGetPlatformColor(L"TextFillColorPrimary", activeForeground) ||
+        !m_theme.TryGetPlatformColor(L"TextFillColorSecondary", inactiveForeground) ||
+        !m_theme.TryGetPlatformColor(L"ControlFillColorSecondary", buttonHoverBackground) ||
+        !m_theme.TryGetPlatformColor(L"ControlFillColorTertiary", buttonPressedBackground) ||
+        !m_theme.TryGetPlatformColor(L"ButtonForegroundPressed", buttonPressedForeground)) {
+      return;
+    }
+
+    // AppWindowTitleBar ignores alpha, so resolve RNW's translucent semantic text colors to opaque colors first.
+    background.A = 0xFF;
+    activeForeground = CompositeOverOpaqueBackground(activeForeground, background);
+    inactiveForeground = CompositeOverOpaqueBackground(inactiveForeground, background);
+    buttonHoverBackground = CompositeOverOpaqueBackground(buttonHoverBackground, background);
+    buttonPressedBackground = CompositeOverOpaqueBackground(buttonPressedBackground, background);
+    buttonPressedForeground = CompositeOverOpaqueBackground(buttonPressedForeground, buttonPressedBackground);
+
+    auto titleBar = m_rnWindow.AppWindow().TitleBar();
+    titleBar.ForegroundColor(activeForeground);
+    titleBar.BackgroundColor(background);
+    titleBar.InactiveForegroundColor(inactiveForeground);
+    titleBar.InactiveBackgroundColor(background);
+    titleBar.ButtonForegroundColor(activeForeground);
+    titleBar.ButtonBackgroundColor(background);
+    titleBar.ButtonHoverForegroundColor(activeForeground);
+    titleBar.ButtonHoverBackgroundColor(buttonHoverBackground);
+    titleBar.ButtonPressedForegroundColor(buttonPressedForeground);
+    titleBar.ButtonPressedBackgroundColor(buttonPressedBackground);
+    titleBar.ButtonInactiveForegroundColor(inactiveForeground);
+    titleBar.ButtonInactiveBackgroundColor(background);
   }
 
   // creates a new modal window
@@ -453,6 +556,10 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
   winrt::Microsoft::ReactNative::ReactNativeWindow m_rnWindow{nullptr};
   winrt::Microsoft::UI::Content::DesktopPopupSiteBridge m_popUp{nullptr};
   winrt::event_token m_appWindowClosingToken;
+  winrt::weak_ref<winrt::Microsoft::ReactNative::Composition::ComponentView> m_themeSource;
+  winrt::event_token m_themeChangedToken;
+  uint64_t m_themeSubscriptionGeneration{0};
+  winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
   winrt::com_ptr<::Microsoft::ReactNativeSpecs::ModalHostViewProps> m_localProps{nullptr};
 };
 

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

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <UIAutomationClient.h>
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+inline bool ShouldRaiseSelectionItemStateChanged(
+    bool isMounted,
+    const std::optional<bool> &oldSelected,
+    const std::optional<bool> &newSelected) noexcept {
+  return isMounted && oldSelected.value_or(false) != newSelected.value_or(false);
+}
+
+template <typename Node, typename GetChildren, typename IsMounted, typename IsSelectionContainer, typename IsSelected>
+std::vector<Node> GetSelectedItemsInSelectionContainer(
+    const Node &selectionContainer,
+    GetChildren &&getChildren,
+    IsMounted &&isMounted,
+    IsSelectionContainer &&isSelectionContainer,
+    IsSelected &&isSelected) {
+  std::vector<Node> selectedItems;
+  std::function<void(const Node &)> visitChildren = [&](const Node &parent) {
+    for (const auto &child : getChildren(parent)) {
+      if (!isMounted(child)) {
+        continue;
+      }
+
+      if (isSelected(child)) {
+        selectedItems.push_back(child);
+      }
+
+      if (!isSelectionContainer(child)) {
+        visitChildren(child);
+      }
+    }
+  };
+
+  visitChildren(selectionContainer);
+  return selectedItems;
+}
+
+inline EVENTID
+GetSelectionItemAutomationEventId(bool isSelected, bool canSelectMultiple, size_t selectedItemCount) noexcept {
+  if (isSelected && (!canSelectMultiple || selectedItemCount == 1)) {
+    return UIA_SelectionItem_ElementSelectedEventId;
+  }
+
+  if (isSelected) {
+    return UIA_SelectionItem_ElementAddedToSelectionEventId;
+  }
+
+  return canSelectMultiple && selectedItemCount == 1 ? UIA_SelectionItem_ElementSelectedEventId
+                                                     : UIA_SelectionItem_ElementRemovedFromSelectionEventId;
+}
+
+inline bool
+ShouldRaiseSelectionItemNotification(bool isSelected, bool canSelectMultiple, bool hasKeyboardFocus) noexcept {
+  return isSelected && !canSelectMultiple && hasKeyboardFocus;
+}
+
+inline std::wstring GetSelectionItemNotificationText(const std::wstring &name, const std::wstring &selectedText) {
+  return name.empty() ? selectedText : name + L", " + selectedText;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -3,11 +3,27 @@
 #include <Fabric/Composition/CompositionViewComponentView.h>
 #include <atlcomcli.h>
 #include <inspectable.h>
+#include <oleacc.h>
 #include "CompositionRootAutomationProvider.h"
 #include "RootComponentView.h"
+#include "SelectionItemAutomationEvent.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
+namespace {
+
+using GetStateTextWFn = UINT(WINAPI *)(DWORD, LPWSTR, UINT);
+
+GetStateTextWFn GetStateTextFunction() noexcept {
+  static const auto getStateText = []() noexcept {
+    auto oleacc = LoadLibraryExW(L"oleacc.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32);
+    return oleacc ? reinterpret_cast<GetStateTextWFn>(GetProcAddress(oleacc, "GetStateTextW")) : nullptr;
+  }();
+  return getStateText;
+}
+
+} // namespace
+
 HRESULT UiaNavigateHelper(
     const winrt::Microsoft::ReactNative::ComponentView &view,
     NavigateDirection direction,
@@ -519,46 +535,103 @@ ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
   }
 }
 
-void AddSelectionItemsToContainer(CompositionDynamicAutomationProvider *provider) noexcept {
-  auto selectionContainerView = provider->GetSelectionContainer();
-  if (!selectionContainerView)
-    return;
-
-  auto selectionContainerCompView =
-      selectionContainerView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
-  if (!selectionContainerCompView)
-    return;
+std::vector<winrt::Microsoft::ReactNative::ComponentView> GetSelectedItemsInSelectionContainer(
+    const winrt::Microsoft::ReactNative::ComponentView &selectionContainer) noexcept {
+  return GetSelectedItemsInSelectionContainer(
+      selectionContainer,
+      [](const auto &view) { return view.Children(); },
+      [](const auto &view) {
+        return winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)->isMounted();
+      },
+      [](const auto &view) {
+        auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+            winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)->props());
+        return props && props->accessibilityState.has_value() &&
+            props->accessibilityState->multiselectable.has_value() && props->accessibilityState->required.has_value();
+      },
+      [](const auto &view) {
+        auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+            winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)->props());
+        return props && props->accessibilityState.has_value() && props->accessibilityState->selected.value_or(false);
+      });
+}
 
-  selectionContainerCompView->EnsureUiaProvider();
+void RaiseSelectionItemAutomationEvent(
+    CompositionDynamicAutomationProvider *provider,
+    bool isSelected,
+    bool hasKeyboardFocus) noexcept {
+  BOOL canSelectMultiple = false;
+  size_t selectedItemCount = isSelected ? 1 : 0;
+  winrt::com_ptr<IRawElementProviderSimple> eventProvider;
+  eventProvider.copy_from(static_cast<IRawElementProviderSimple *>(provider));
 
-  if (!selectionContainerCompView->InnerAutomationProvider())
-    return;
+  auto selectionContainerView = provider->GetSelectionContainer();
+  if (selectionContainerView) {
+    auto selectionContainerCompView =
+        selectionContainerView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
+    if (selectionContainerCompView) {
+      auto props = selectionContainerCompView->viewProps();
+      canSelectMultiple =
+          props->accessibilityState.has_value() && props->accessibilityState->multiselectable.value_or(false);
+
+      auto selectedItems = GetSelectedItemsInSelectionContainer(selectionContainerView);
+      selectedItemCount = selectedItems.size();
+      if (!isSelected && canSelectMultiple && selectedItemCount == 1) {
+        auto remainingSelectedItem =
+            selectedItems[0].try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
+        if (!remainingSelectedItem) {
+          return;
+        }
 
-  auto simpleProvider = static_cast<IRawElementProviderSimple *>(provider);
-  winrt::com_ptr<IRawElementProviderSimple> simpleProviderPtr;
-  simpleProviderPtr.copy_from(simpleProvider);
-  selectionContainerCompView->InnerAutomationProvider()->AddToSelectionItems(simpleProviderPtr);
-}
+        auto remainingSelectedItemProvider =
+            remainingSelectedItem->EnsureUiaProvider().try_as<IRawElementProviderSimple>();
+        if (!remainingSelectedItemProvider) {
+          return;
+        }
+        eventProvider = std::move(remainingSelectedItemProvider);
+      }
+    }
+  }
 
-void RemoveSelectionItemsFromContainer(CompositionDynamicAutomationProvider *provider) noexcept {
-  auto selectionContainerView = provider->GetSelectionContainer();
-  if (!selectionContainerView)
-    return;
+  UiaRaiseAutomationEvent(
+      eventProvider.get(), GetSelectionItemAutomationEventId(isSelected, canSelectMultiple, selectedItemCount));
 
-  auto selectionContainerCompView =
-      selectionContainerView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
-  if (!selectionContainerCompView)
-    return;
+  if (ShouldRaiseSelectionItemNotification(isSelected, canSelectMultiple, hasKeyboardFocus)) {
+    const auto getStateText = GetStateTextFunction();
+    if (!getStateText) {
+      return;
+    }
 
-  selectionContainerCompView->EnsureUiaProvider();
+    const auto selectedTextLength = getStateText(STATE_SYSTEM_SELECTED, nullptr, 0);
+    if (selectedTextLength == 0) {
+      return;
+    }
 
-  if (!selectionContainerCompView->InnerAutomationProvider())
-    return;
+    std::vector<wchar_t> selectedText(selectedTextLength + 1);
+    if (getStateText(STATE_SYSTEM_SELECTED, selectedText.data(), static_cast<UINT>(selectedText.size())) == 0) {
+      return;
+    }
 
-  auto simpleProvider = static_cast<IRawElementProviderSimple *>(provider);
-  winrt::com_ptr<IRawElementProviderSimple> simpleProviderPtr;
-  simpleProviderPtr.copy_from(simpleProvider);
-  selectionContainerCompView->InnerAutomationProvider()->RemoveFromSelectionItems(simpleProviderPtr);
+    VARIANT name{};
+    VariantInit(&name);
+    eventProvider->GetPropertyValue(UIA_NamePropertyId, &name);
+    auto announcement =
+        GetSelectionItemNotificationText(name.vt == VT_BSTR && name.bstrVal ? name.bstrVal : L"", selectedText.data());
+    VariantClear(&name);
+
+    auto announcementBstr = SysAllocString(announcement.c_str());
+    auto activityId = SysAllocString(L"ReactNative.SelectionItem.Selected");
+    if (announcementBstr && activityId) {
+      UiaRaiseNotificationEvent(
+          eventProvider.get(),
+          NotificationKind_ActionCompleted,
+          NotificationProcessing_ImportantMostRecent,
+          announcementBstr,
+          activityId);
+    }
+    SysFreeString(activityId);
+    SysFreeString(announcementBstr);
+  }
 }
 
 ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept {

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

@@ -5,6 +5,7 @@
 #include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/ReactTaggedView.h>
 #include <UIAutomation.h>
+#include <vector>
 
 namespace Microsoft::ReactNative {
 struct winrt::Microsoft::ReactNative::implementation::ComponentView;
@@ -75,9 +76,13 @@ void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view
 
 ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
 
-void AddSelectionItemsToContainer(CompositionDynamicAutomationProvider *provider) noexcept;
+std::vector<winrt::Microsoft::ReactNative::ComponentView> GetSelectedItemsInSelectionContainer(
+    const winrt::Microsoft::ReactNative::ComponentView &selectionContainer) noexcept;
 
-void RemoveSelectionItemsFromContainer(CompositionDynamicAutomationProvider *provider) noexcept;
+void RaiseSelectionItemAutomationEvent(
+    CompositionDynamicAutomationProvider *provider,
+    bool isSelected,
+    bool hasKeyboardFocus) noexcept;
 
 ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept;
 

package/PropertySheets/CIBuildOptimizations.props

@@ -1,9 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <!--
-    CI-specific C++ build optimizations for the publish pipeline.
+    CI-specific C++ build optimizations.
 
-    This file is injected via /p:ForceImportAfterCppTargets in .ado/publish.yml.
+    This file is injected via /p:ForceImportAfterCppTargets by the Desktop and Universal build jobs.
     It overrides defaults that are tuned for developer workflows (incremental builds,
     file tracking) with settings that are better for CI clean builds.
 

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.85.0-preview.1</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.85.0</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>85</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>e4ec8fe57ee86faa8c79d87f7083ce2457cc9fb3</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>0e2b495c27e04e4dacfcb02765d80cf61daef23b</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/PropertySheets/JSEngine.props

@@ -6,7 +6,7 @@
     <!-- Enabling this will (1) Include hermes glues in the Microsoft.ReactNative binaries AND (2) Make hermes the default engine -->
     <UseHermes Condition="'$(UseHermes)' == ''">true</UseHermes>
     <!-- This will be true if (1) the client want to use hermes by setting UseHermes to true OR (2) We are building for UWP where dynamic switching is enabled -->
-    <HermesVersion Condition="'$(HermesVersion)' == ''">0.0.0-2605.6002-2279da22 </HermesVersion>
+    <HermesVersion Condition="'$(HermesVersion)' == ''">0.0.0-2608.12001-35d34796</HermesVersion>
     <HermesPackageName Condition="'$(HermesPackageName)' == ''">Microsoft.JavaScript.Hermes</HermesPackageName>
     <HermesPackage Condition="'$(HermesPackage)' == '' And Exists('$(PkgMicrosoft_JavaScript_Hermes)')">$(PkgMicrosoft_JavaScript_Hermes)</HermesPackage>
     <HermesPackage Condition="'$(HermesPackage)' == ''">$(NuGetPackageRoot)\$(HermesPackageName)\$(HermesVersion)</HermesPackage>

package/PropertySheets/NuGet.LockFile.props

@@ -8,15 +8,8 @@
        -->
 
   <PropertyGroup>
-    <RestoreLockedMode Condition="'$(RestoreLockedMode)'=='' OR '$(BuildingInRnwRepo)'=='true'">true</RestoreLockedMode>
-    <!--
-      VS's NuGet restore cannot evaluate vcxproj PackageReferences through the project reference
-      chain (the VC project system does not report them via the CPS nomination API). This causes
-      NU1004 lock file mismatches for csproj files that reference vcxproj. Disable locked mode
-      in VS so the initial restore succeeds and package targets load correctly.
-      CI is unaffected: it passes /p:RestoreLockedMode=true as a global property which overrides this.
-    -->
-    <RestoreLockedMode Condition="'$(BuildingInsideVisualStudio)' == 'true' AND '$(MSBuildProjectExtension)' == '.csproj'">false</RestoreLockedMode>
+    <!-- Locked vs. force-evaluate is decided centrally in the repo-root Directory.Build.props (force-evaluate locally, locked in CI); don't force locked mode on here or it conflicts with force-evaluate (NU1512). -->
+    <RestoreLockedMode Condition="'$(RestoreLockedMode)'==''">false</RestoreLockedMode>
 
     <NuGetLockFileName>packages</NuGetLockFileName>
     <NuGetLockFileName Condition="'$(UseExperimentalWinUI3)'=='true'">$(NuGetLockFileName).experimentalwinui3</NuGetLockFileName>