react-native-windows 0.76.3 → 0.77.0-preview.2

package/Microsoft.ReactNative/AsynchronousEventBeat.cpp

@@ -3,20 +3,21 @@
 namespace Microsoft::ReactNative {
 
 AsynchronousEventBeat::AsynchronousEventBeat(
-    facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
+    std::shared_ptr<facebook::react::EventBeat::OwnerBox> const ownerBox,
     const winrt::Microsoft::ReactNative::ReactContext &context,
-    facebook::react::RuntimeExecutor runtimeExecutor)
-    : EventBeat(ownerBox), m_context(context), m_runtimeExecutor(runtimeExecutor) {}
+    std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler)
+    : EventBeat(ownerBox, *runtimeScheduler), m_context(context), m_runtimeScheduler(std::move(runtimeScheduler)) {}
 
 void AsynchronousEventBeat::induce() const {
-  if (!isRequested_ || m_isBeatCallbackScheduled) {
-    isRequested_ = false;
+  if (!isEventBeatRequested_ || m_isBeatCallbackScheduled) {
+    isEventBeatRequested_ = false;
     return;
   }
-  isRequested_ = false;
+  isEventBeatRequested_ = false;
   m_isBeatCallbackScheduled = true;
 
-  m_runtimeExecutor([this, ownerBox = ownerBox_](facebook::jsi::Runtime &runtime) {
+  facebook::react::RuntimeScheduler &schedulerRef = *m_runtimeScheduler.get();
+  schedulerRef.scheduleWork([this, ownerBox = ownerBox_](facebook::jsi::Runtime &runtime) {
     auto owner = ownerBox->owner.lock();
     if (!owner) {
       return;
@@ -30,7 +31,7 @@ void AsynchronousEventBeat::induce() const {
 }
 
 void AsynchronousEventBeat::request() const {
-  bool alreadyRequested = isRequested_.exchange(true);
+  bool alreadyRequested = isEventBeatRequested_.exchange(true);
   if (!alreadyRequested) {
     if (m_context.UIDispatcher().HasThreadAccess()) {
       induce();

package/Microsoft.ReactNative/AsynchronousEventBeat.h

@@ -1,23 +1,23 @@
 #include <NativeModules.h>
-#include <ReactCommon/RuntimeExecutor.h>
 #include <react/renderer/core/EventBeat.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 
 namespace Microsoft::ReactNative {
 
 class AsynchronousEventBeat final : public facebook::react::EventBeat {
  public:
   AsynchronousEventBeat(
-      facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
+      std::shared_ptr<facebook::react::EventBeat::OwnerBox> const ownerBox,
       const winrt::Microsoft::ReactNative::ReactContext &context,
-      facebook::react::RuntimeExecutor runtimeExecutor);
+      std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler);
 
-  void induce() const override;
+  void induce() const;
   void request() const override;
 
  private:
   mutable std::atomic<bool> m_isBeatCallbackScheduled{false};
   winrt::Microsoft::ReactNative::ReactContext m_context;
-  facebook::react::RuntimeExecutor m_runtimeExecutor;
+  std::shared_ptr<facebook::react::RuntimeScheduler> m_runtimeScheduler;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/FBReactNativeSpec/FBReactNativeSpecJSI.h

@@ -0,0 +1,5 @@
+// Core RN code expects to be able to use #include <FBReactNativeSpec/FBReactNativeSpecJSI.h> to import the generated
+// headers. We should look into moving the codegen output into a FBReactNativeSpec folder, and running codegen using
+// FBReactNative as the library name But for now this redirection header will suffice
+// https://github.com/microsoft/react-native-windows/issues/14129 tracks removing this file
+#include <codegen/rnwcoreJSI.h>

package/Microsoft.ReactNative/Fabric/AbiComponentDescriptor.cpp

@@ -7,10 +7,10 @@
 
 #include <Fabric/WindowsComponentDescriptorRegistry.h>
 #include <ReactContext.h>
-#include <react/utils/CoreFeatures.h>
 #include <type_traits>
 #include "DynamicReader.h"
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 namespace Microsoft::ReactNative {
 
 AbiComponentDescriptor::AbiComponentDescriptor(facebook::react::ComponentDescriptorParameters const &parameters)
@@ -90,7 +90,7 @@ facebook::react::Props::Shared AbiComponentDescriptor::cloneProps(
   }
 
   if constexpr (std::is_base_of_v<facebook::react::YogaLayoutableShadowNode, ShadowNodeT>) {
-    if (facebook::react::CoreFeatures::excludeYogaFromRawProps) {
+    if (facebook::react::ReactNativeFeatureFlags::excludeYogaFromRawProps()) {
       rawProps.filterYogaStylePropsInDynamicConversion();
     }
   }

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

@@ -11,7 +11,21 @@ namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
     const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
-    : m_view{componentView} {}
+    : 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);
+  }
+}
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
     NavigateDirection direction,
@@ -178,10 +192,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
       props->accessibilityRole.empty() ? compositionView->DefaultControlType() : props->accessibilityRole;
   // Invoke control pattern is used to support controls that do not maintain state
   // when activated but rather initiate or perform a single, unambiguous action.
-  if (patternId == UIA_InvokePatternId &&
-      (accessibilityRole == "button" || accessibilityRole == "imagebutton" || accessibilityRole == "link" ||
-       accessibilityRole == "splitbutton" || (accessibilityRole == "menuitem" && props->onAccessibilityTap) ||
-       (accessibilityRole == "treeitem" && props->onAccessibilityTap))) {
+  if (patternId == UIA_InvokePatternId && (props->onAccessibilityTap)) {
     *pRetVal = static_cast<IInvokeProvider *>(this);
     AddRef();
   }
@@ -192,14 +203,8 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
   }
 
   if (patternId == UIA_ValuePatternId &&
-      (accessibilityRole == "textinput" || accessibilityRole == "searchbox" ||
-       (accessibilityRole == "button" && accessibilityValueHasValue(props->accessibilityValue)) ||
-       (accessibilityRole == "combobox" && accessibilityValueHasValue(props->accessibilityValue)) ||
-       (accessibilityRole == "link" && accessibilityValueHasValue(props->accessibilityValue)) ||
-       (accessibilityRole == "listitem" && accessibilityValueHasValue(props->accessibilityValue)) ||
-       (accessibilityRole == "progressbar" && accessibilityValueHasValue(props->accessibilityValue)) ||
-       (accessibilityRole == "adjustable" && accessibilityValueHasValue(props->accessibilityValue)) ||
-       (accessibilityRole == "spinbutton" && accessibilityValueHasValue(props->accessibilityValue)))) {
+      (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>() ||
+       accessibilityValueHasValue(props->accessibilityValue))) {
     *pRetVal = static_cast<IValueProvider *>(this);
     AddRef();
   }
@@ -211,15 +216,23 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
-  if (patternId == UIA_ExpandCollapsePatternId &&
-      (accessibilityRole == "combobox" || accessibilityRole == "splitbutton" || accessibilityRole == "treeitem" ||
-       (expandableControl(props) &&
-        (accessibilityRole == "toolbar" || accessibilityRole == "menuitem" || accessibilityRole == "menubar" ||
-         accessibilityRole == "listitem" || accessibilityRole == "group" || accessibilityRole == "button")))) {
+  if (patternId == UIA_ExpandCollapsePatternId && expandableControl(props)) {
     *pRetVal = static_cast<IExpandCollapseProvider *>(this);
     AddRef();
   }
 
+  if (patternId == UIA_SelectionPatternId && props->accessibilityState.has_value() &&
+      props->accessibilityState->multiselectable.has_value() && props->accessibilityState->required.has_value()) {
+    *pRetVal = static_cast<ISelectionProvider *>(this);
+    AddRef();
+  }
+
+  if (patternId == UIA_SelectionItemPatternId && props->accessibilityState.has_value() &&
+      props->accessibilityState->selected.has_value()) {
+    *pRetVal = static_cast<ISelectionItemProvider *>(this);
+    AddRef();
+  }
+
   return S_OK;
 }
 
@@ -363,6 +376,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     case UIA_IsOffscreenPropertyId: {
       pRetVal->vt = VT_BOOL;
       pRetVal->boolVal = (compositionView->getClipState() == ClipState::FullyClipped) ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
     }
     case UIA_HelpTextPropertyId: {
       pRetVal->vt = VT_BSTR;
@@ -585,4 +599,169 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Collapse() {
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_CanSelectMultiple(BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props =
+      std::static_pointer_cast<const facebook::react::ViewProps>(winrt::get_self<ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = (props->accessibilityState.has_value() && props->accessibilityState->multiselectable.has_value())
+      ? props->accessibilityState->multiselectable.value()
+      : false;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsSelectionRequired(BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = (props->accessibilityState.has_value() && props->accessibilityState->required.has_value())
+      ? props->accessibilityState->required.value()
+      : false;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::GetSelection(SAFEARRAY **pRetVal) {
+  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);
+    auto provider = selectionItem.as<CompositionDynamicAutomationProvider>();
+    BOOL selected;
+    auto hr = provider->get_IsSelected(&selected);
+    if (hr == S_OK && selected) {
+      selectedItems.push_back(int(i));
+    }
+  }
+
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, ULONG(selectedItems.size()));
+  if (*pRetVal == nullptr)
+    return E_OUTOFMEMORY;
+
+  for (size_t i = 0; i < selectedItems.size(); i++) {
+    auto pos = static_cast<long>(i);
+    SafeArrayPutElement(*pRetVal, &pos, m_selectionItems.at(selectedItems.at(i)).get());
+  }
+  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();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  DispatchAccessibilityAction(m_view, "addToSelection");
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsSelected(BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = (props->accessibilityState.has_value() && props->accessibilityState->selected.has_value())
+      ? props->accessibilityState->selected.value()
+      : false;
+
+  return S_OK;
+}
+
+IRawElementProviderSimple *findSelectionContainer(winrt::Microsoft::ReactNative::ComponentView current) {
+  if (!current)
+    return nullptr;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(current)->props());
+  if (props->accessibilityState.has_value() && props->accessibilityState->multiselectable.has_value() &&
+      props->accessibilityState->required.has_value()) {
+    auto uiaProvider =
+        current.as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()->EnsureUiaProvider();
+    if (uiaProvider != nullptr) {
+      auto spProviderSimple = uiaProvider.try_as<IRawElementProviderSimple>();
+      if (spProviderSimple != nullptr) {
+        spProviderSimple->AddRef();
+        return spProviderSimple.get();
+      }
+    }
+  } else {
+    return findSelectionContainer(current.Parent());
+  }
+  return nullptr;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_SelectionContainer(IRawElementProviderSimple **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = findSelectionContainer(strongView.Parent());
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::RemoveFromSelection() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  DispatchAccessibilityAction(m_view, "removeFromSelection");
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::Select() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  DispatchAccessibilityAction(m_view, "select");
+  return S_OK;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -17,7 +17,9 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
                                                  IScrollItemProvider,
                                                  IValueProvider,
                                                  IToggleProvider,
-                                                 IExpandCollapseProvider> {
+                                                 IExpandCollapseProvider,
+                                                 ISelectionProvider,
+                                                 ISelectionItemProvider> {
  public:
   CompositionDynamicAutomationProvider(
       const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
@@ -57,8 +59,24 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall Expand() override;
   virtual HRESULT __stdcall Collapse() override;
 
+  // inherited via ISelectionProvider
+  virtual HRESULT __stdcall get_CanSelectMultiple(BOOL *pRetVal) override;
+  virtual HRESULT __stdcall get_IsSelectionRequired(BOOL *pRetVal) override;
+  virtual HRESULT __stdcall GetSelection(SAFEARRAY **pRetVal) override;
+
+  // inherited via ISelectionItemProvider
+  virtual HRESULT __stdcall AddToSelection() override;
+  virtual HRESULT __stdcall get_IsSelected(BOOL *pRetVal) override;
+  virtual HRESULT __stdcall get_SelectionContainer(IRawElementProviderSimple **pRetVal) override;
+  virtual HRESULT __stdcall RemoveFromSelection() override;
+  virtual HRESULT __stdcall Select() override;
+
+  void AddToSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
+  void RemoveFromSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
+
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
+  std::vector<winrt::com_ptr<IRawElementProviderSimple>> m_selectionItems;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -761,6 +761,19 @@ void ComponentView::updateAccessibilityProps(
       UIA_LiveSettingPropertyId,
       oldViewProps.accessibilityLiveRegion,
       newViewProps.accessibilityLiveRegion);
+
+  if ((oldViewProps.accessibilityState.has_value() && oldViewProps.accessibilityState->selected.has_value()) !=
+      ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value()))) {
+    auto compProvider =
+        m_uiaProvider.try_as<winrt::Microsoft::ReactNative::implementation::CompositionDynamicAutomationProvider>();
+    if (compProvider) {
+      if ((newViewProps.accessibilityState.has_value() && newViewProps.accessibilityState->selected.has_value())) {
+        winrt::Microsoft::ReactNative::implementation::AddSelectionItemsToContainer(compProvider.get());
+      } else {
+        winrt::Microsoft::ReactNative::implementation::RemoveSelectionItemsFromContainer(compProvider.get());
+      }
+    }
+  }
 }
 
 std::optional<std::string> ComponentView::getAccessiblityValue() noexcept {

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

@@ -577,7 +577,7 @@ facebook::react::AttributedStringBox CreateLoadingAttributedString() noexcept {
   auto fragment = facebook::react::AttributedString::Fragment{};
   fragment.string = "Loading";
   fragment.textAttributes.fontSize = loadingBarFontSize;
-  attributedString.appendFragment(fragment);
+  attributedString.appendFragment(std::move(fragment));
   return facebook::react::AttributedStringBox{attributedString};
 }
 

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

@@ -97,26 +97,24 @@ virtual State::Shared createInitialState(
           !textInputProps.hasPaddingHorizontal) {
         changedPadding = true;
         style.setPadding(
-            YGEdgeStart, yoga::CompactValue::of<YGUnitPoint>(theme.start));
+            yoga::Edge::Start, yoga::StyleLength::points(theme.start));
       }
       if (!textInputProps.hasPadding && !textInputProps.hasPaddingEnd &&
           !textInputProps.hasPaddingRight &&
           !textInputProps.hasPaddingHorizontal) {
         changedPadding = true;
-        style.setPadding(
-            YGEdgeEnd, yoga::CompactValue::of<YGUnitPoint>(theme.end));
+        style.setPadding(yoga::Edge::End, yoga::StyleLength::points(theme.end));
       }
       if (!textInputProps.hasPadding && !textInputProps.hasPaddingTop &&
           !textInputProps.hasPaddingVertical) {
         changedPadding = true;
-        style.setPadding(
-            YGEdgeTop, yoga::CompactValue::of<YGUnitPoint>(theme.top));
+        style.setPadding(yoga::Edge::Top, yoga::StyleLength::points(theme.top));
       }
       if (!textInputProps.hasPadding && !textInputProps.hasPaddingBottom &&
           !textInputProps.hasPaddingVertical) {
         changedPadding = true;
         style.setPadding(
-            YGEdgeBottom, yoga::CompactValue::of<YGUnitPoint>(theme.bottom));
+            yoga::Edge::Bottom, yoga::StyleLength::points(theme.bottom));
       }
 
       // If the TextInput initially does not have paddingLeft or paddingStart, a
@@ -127,12 +125,12 @@ virtual State::Shared createInitialState(
       if ((textInputProps.hasPadding || textInputProps.hasPaddingLeft ||
            textInputProps.hasPaddingHorizontal) &&
           !textInputProps.hasPaddingStart) {
-        style.setPadding(YGEdgeStart, yoga::CompactValue::ofUndefined());
+        style.setPadding(yoga::Edge::Start, yoga::StyleLength::undefined());
       }
       if ((textInputProps.hasPadding || textInputProps.hasPaddingRight ||
            textInputProps.hasPaddingHorizontal) &&
           !textInputProps.hasPaddingEnd) {
-        style.setPadding(YGEdgeEnd, yoga::CompactValue::ofUndefined());
+        style.setPadding(yoga::Edge::End, yoga::StyleLength::undefined());
       }
 
       // Note that this is expensive: on every adopt, we need to set the Yoga

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

@@ -487,7 +487,7 @@ facebook::react::AttributedString WindowsTextInputComponentView::getAttributedSt
     // that effect.
     fragment.textAttributes.backgroundColor = facebook::react::clearColor();
     // fragment.parentShadowView = facebook::react::ShadowView(*this);
-    attributedString.prependFragment(fragment);
+    attributedString.prependFragment(std::move(fragment));
   }
 
   return attributedString;
@@ -1366,7 +1366,7 @@ winrt::com_ptr<::IDWriteTextLayout> WindowsTextInputComponentView::CreatePlaceho
   textAttributes.fontSizeMultiplier = m_fontSizeMultiplier;
   fragment1.string = props.placeholder;
   fragment1.textAttributes = textAttributes;
-  attributedString.appendFragment(fragment1);
+  attributedString.appendFragment(std::move(fragment1));
 
   facebook::react::LayoutConstraints constraints;
   constraints.maximumSize.width = static_cast<FLOAT>(m_imgWidth);

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

@@ -38,6 +38,7 @@ AttributedString WindowsTextInputShadowNode::getAttributedString(const LayoutCon
   auto attributedString = AttributedString{};
   auto attachments = BaseTextShadowNode::Attachments{};
   BaseTextShadowNode::buildAttributedString(childTextAttributes, *this, attributedString, attachments);
+  attributedString.setBaseTextAttributes(childTextAttributes);
 
   // BaseTextShadowNode only gets children. We must detect and prepend text
   // value attributes manually.
@@ -53,7 +54,7 @@ AttributedString WindowsTextInputShadowNode::getAttributedString(const LayoutCon
     // that effect.
     fragment.textAttributes.backgroundColor = clearColor();
     fragment.parentShadowView = ShadowView(*this);
-    attributedString.prependFragment(fragment);
+    attributedString.prependFragment(std::move(fragment));
   }
 
   return attributedString;
@@ -83,7 +84,7 @@ AttributedString WindowsTextInputShadowNode::getPlaceholderAttributedString(cons
   // appended to the AttributedString (see implementation of appendFragment)
   fragment.textAttributes = textAttributes;
   fragment.parentShadowView = ShadowView(*this);
-  textAttributedString.appendFragment(fragment);
+  textAttributedString.appendFragment(std::move(fragment));
 
   return textAttributedString;
 }

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

@@ -49,7 +49,7 @@ facebook::react::AttributedStringBox CreateTooltipAttributedString(const std::st
   auto fragment = facebook::react::AttributedString::Fragment{};
   fragment.string = tooltip;
   fragment.textAttributes.fontSize = tooltipFontSize;
-  attributedString.appendFragment(fragment);
+  attributedString.appendFragment(std::move(fragment));
   return facebook::react::AttributedStringBox{attributedString};
 }
 

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

@@ -214,6 +214,30 @@ ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
   }
 }
 
+void AddSelectionItemsToContainer(CompositionDynamicAutomationProvider *provider) noexcept {
+  winrt::com_ptr<IRawElementProviderSimple> selectionContainer;
+  provider->get_SelectionContainer(selectionContainer.put());
+  if (!selectionContainer)
+    return;
+  auto selectionContainerProvider = selectionContainer.as<CompositionDynamicAutomationProvider>();
+  auto simpleProvider = static_cast<IRawElementProviderSimple *>(provider);
+  winrt::com_ptr<IRawElementProviderSimple> simpleProviderPtr;
+  simpleProviderPtr.copy_from(simpleProvider);
+  selectionContainerProvider->AddToSelectionItems(simpleProviderPtr);
+}
+
+void RemoveSelectionItemsFromContainer(CompositionDynamicAutomationProvider *provider) noexcept {
+  winrt::com_ptr<IRawElementProviderSimple> selectionContainer;
+  provider->get_SelectionContainer(selectionContainer.put());
+  if (!selectionContainer)
+    return;
+  auto selectionContainerProvider = selectionContainer.as<CompositionDynamicAutomationProvider>();
+  auto simpleProvider = static_cast<IRawElementProviderSimple *>(provider);
+  winrt::com_ptr<IRawElementProviderSimple> simpleProviderPtr;
+  simpleProviderPtr.copy_from(simpleProvider);
+  selectionContainerProvider->RemoveFromSelectionItems(simpleProviderPtr);
+}
+
 ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept {
   if (state.has_value()) {
     if (state->checked == facebook::react::AccessibilityState::Checked) {

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <Fabric/ComponentView.h>
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
 #include <Fabric/ReactTaggedView.h>
 #include <UIAutomation.h>
 
@@ -37,5 +38,9 @@ void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view
 
 ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
 
+void AddSelectionItemsToContainer(CompositionDynamicAutomationProvider *provider) noexcept;
+
+void RemoveSelectionItemsFromContainer(CompositionDynamicAutomationProvider *provider) noexcept;
+
 ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -30,7 +30,6 @@
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/scheduler/SchedulerToolbox.h>
 #include <react/utils/ContextContainer.h>
-#include <react/utils/CoreFeatures.h>
 #include <winrt/Windows.Graphics.Display.h>
 #include <winrt/Windows.UI.Composition.Desktop.h>
 #include "DynamicReader.h"
@@ -52,9 +51,7 @@ FabicUIManagerProperty() noexcept {
   return props.Get(FabicUIManagerProperty()).Value();
 }
 
-FabricUIManager::FabricUIManager() {
-  facebook::react::CoreFeatures::enablePropIteratorSetter = true;
-}
+FabricUIManager::FabricUIManager() {}
 
 FabricUIManager::~FabricUIManager() {
   // Make sure that we destroy UI components on UI thread.
@@ -76,8 +73,9 @@ void FabricUIManager::installFabricUIManager() noexcept {
 
   facebook::react::RuntimeExecutor runtimeExecutor;
   auto toolbox = facebook::react::SchedulerToolbox{};
+  auto runtimeScheduler = SchedulerSettings::RuntimeSchedulerFromProperties(m_context.Properties());
 
-  if (auto runtimeScheduler = SchedulerSettings::RuntimeSchedulerFromProperties(m_context.Properties())) {
+  if (runtimeScheduler) {
     contextContainer->insert("RuntimeScheduler", runtimeScheduler);
     runtimeExecutor = [runtimeScheduler](std::function<void(facebook::jsi::Runtime & runtime)> &&callback) {
       runtimeScheduler->scheduleWork(std::move(callback));
@@ -87,8 +85,8 @@ void FabricUIManager::installFabricUIManager() noexcept {
   }
 
   facebook::react::EventBeat::Factory asynchronousBeatFactory =
-      [runtimeExecutor, context = m_context](facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsynchronousEventBeat>(ownerBox, context, runtimeExecutor);
+      [runtimeScheduler, context = m_context](std::shared_ptr<facebook::react::EventBeat::OwnerBox> const &ownerBox) {
+        return std::make_unique<AsynchronousEventBeat>(ownerBox, context, runtimeScheduler);
       };
 
   contextContainer->insert("ReactNativeConfig", config);
@@ -111,7 +109,7 @@ void FabricUIManager::installFabricUIManager() noexcept {
     return registry;
   };
   toolbox.runtimeExecutor = runtimeExecutor;
-  toolbox.asynchronousEventBeatFactory = asynchronousBeatFactory;
+  toolbox.eventBeatFactory = asynchronousBeatFactory;
 
   m_scheduler = std::make_shared<facebook::react::Scheduler>(
       toolbox, (/*animationDriver_ ? animationDriver_.get() :*/ nullptr), this);
@@ -299,7 +297,8 @@ void FabricUIManager::RCTPerformMountInstructions(
   }
 }
 
-void FabricUIManager::performTransaction(facebook::react::MountingCoordinator::Shared const &mountingCoordinator) {
+void FabricUIManager::performTransaction(
+    std::shared_ptr<const facebook::react::MountingCoordinator> const &mountingCoordinator) {
   auto surfaceId = mountingCoordinator->getSurfaceId();
 
   mountingCoordinator->getTelemetryController().pullTransaction(
@@ -321,7 +320,8 @@ void FabricUIManager::performTransaction(facebook::react::MountingCoordinator::S
       });
 }
 
-void FabricUIManager::initiateTransaction(facebook::react::MountingCoordinator::Shared mountingCoordinator) {
+void FabricUIManager::initiateTransaction(
+    std::shared_ptr<const facebook::react::MountingCoordinator> mountingCoordinator) {
   if (m_transactionInFlight) {
     m_followUpTransactionRequired = true;
     return;
@@ -336,7 +336,7 @@ void FabricUIManager::initiateTransaction(facebook::react::MountingCoordinator::
 }
 
 void FabricUIManager::schedulerDidFinishTransaction(
-    const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {
+    const std::shared_ptr<const facebook::react::MountingCoordinator> &mountingCoordinator) {
   // Should cache this locally
 
   if (m_context.UIDispatcher().HasThreadAccess()) {
@@ -348,7 +348,7 @@ void FabricUIManager::schedulerDidFinishTransaction(
 }
 
 void FabricUIManager::schedulerShouldRenderTransactions(
-    const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {
+    const std::shared_ptr<const facebook::react::MountingCoordinator> &mountingCoordinator) {
   if (m_context.UIDispatcher().HasThreadAccess()) {
     initiateTransaction(mountingCoordinator);
   } else {