react-native-windows 0.0.0-canary.950 → 0.0.0-canary.951

package/Directory.Build.props

@@ -26,7 +26,7 @@
     <FmtVersion>10.1.0</FmtVersion>
     <FmtCommitHash>ca2e3685b160617d3d95fcd9e789c4e06ca88</FmtCommitHash>
     <!-- Commit hash for https://github.com/microsoft/node-api-jsi code. -->
-    <NodeApiJsiCommitHash>83cfef428a97627c9185c73da097e42742de56eb</NodeApiJsiCommitHash>
+    <NodeApiJsiCommitHash>980cb60d7911237d0f647fc566543ef627adac70</NodeApiJsiCommitHash>
   </PropertyGroup>
 
   <!--

package/Libraries/Components/View/ViewAccessibility.d.ts

@@ -13,7 +13,8 @@ import {NativeSyntheticEvent} from '../../Types/CoreEventTypes';
  * @see https://reactnative.dev/docs/accessibility#accessibility-properties
  */
 export interface AccessibilityProps
-  extends AccessibilityPropsAndroid,
+  extends AccessibilityPropsWindows,
+    AccessibilityPropsAndroid,
     AccessibilityPropsIOS {
   /**
    * When true, indicates that the view is an accessibility element.
@@ -258,6 +259,52 @@ export type AccessibilityRole =
   | 'listitem' // Windows
   | 'toolbar';
 
+// [Windows]
+export type AnnotationType =
+  | 'AdvanceProofingIssue'
+  | 'Author'
+  | 'CircularReferenceError'
+  | 'Comment'
+  | 'ConflictingChange'
+  | 'DataValidationError'
+  | 'DeletionChange'
+  | 'EditingLockedChange'
+  | 'Endnote'
+  | 'ExternalChange'
+  | 'Footer'
+  | 'Footnote'
+  | 'FormatChange'
+  | 'FormulaError'
+  | 'GrammarError'
+  | 'Header'
+  | 'Highlighted'
+  | 'InsertionChange'
+  | 'Mathematics'
+  | 'MoveChange'
+  | 'SpellingError'
+  | 'TrackChanges'
+  | 'Unknown'
+  | 'UnsyncedChange';
+
+// [Windows]
+export type AccessibilityAnnotationInfo = Readonly<{
+  typeID: AnnotationType;
+  typeName?: string;
+  author?: string;
+  dateTime?: string;
+  target?: string;
+}>;
+export interface AccessibilityPropsWindows {
+  /**
+   * Tells a person using a screen reader what kind of annotation they
+   * have selected. If available, it will also tell a person the author of the annotation and
+   * the date and time the annotation was posted.
+   *
+   * Note: If typeID is 'Unknown', a typeName must be provided.
+   */
+  accessibilityAnnotation?: AccessibilityAnnotationInfo; //Windows
+}
+
 export interface AccessibilityPropsAndroid {
   /**
    * Identifies the element that labels the element it is applied to. When the assistive technology focuses on the component with this props,

package/Libraries/NativeComponent/BaseViewConfig.windows.js

@@ -371,6 +371,7 @@ const validAttributesForNonEventProps = {
   accessibilityLiveRegion: true, // [Windows]
   accessibilityPosInSet: true, // [Windows]
   accessibilitySetSize: true, // [Windows]
+  accessibilityAnnotation: true, // [Windows]
   disabled: true, // [Windows]
   focusable: true, // [Windows]
   keyDownEvents: true, // [Windows]

package/Microsoft.ReactNative/AsynchronousEventBeat.cpp

@@ -6,37 +6,16 @@ AsynchronousEventBeat::AsynchronousEventBeat(
     std::shared_ptr<facebook::react::EventBeat::OwnerBox> const ownerBox,
     const winrt::Microsoft::ReactNative::ReactContext &context,
     std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler)
-    : EventBeat(ownerBox, *runtimeScheduler), m_context(context), m_runtimeScheduler(std::move(runtimeScheduler)) {}
-
-void AsynchronousEventBeat::induce() const {
-  if (!isEventBeatRequested_ || m_isBeatCallbackScheduled) {
-    isEventBeatRequested_ = false;
-    return;
-  }
-  isEventBeatRequested_ = false;
-  m_isBeatCallbackScheduled = true;
-
-  facebook::react::RuntimeScheduler &schedulerRef = *m_runtimeScheduler.get();
-  schedulerRef.scheduleWork([this, ownerBox = ownerBox_](facebook::jsi::Runtime &runtime) {
-    auto owner = ownerBox->owner.lock();
-    if (!owner) {
-      return;
-    }
-
-    m_isBeatCallbackScheduled = false;
-    if (beatCallback_) {
-      beatCallback_(runtime);
-    }
-  });
-}
+    : EventBeat(ownerBox, *runtimeScheduler), m_context(context) {}
 
 void AsynchronousEventBeat::request() const {
   bool alreadyRequested = isEventBeatRequested_.exchange(true);
   if (!alreadyRequested) {
-    if (m_context.UIDispatcher().HasThreadAccess()) {
+    auto uiDispatcher = m_context.UIDispatcher();
+    if (uiDispatcher.HasThreadAccess()) {
       induce();
     } else {
-      m_context.UIDispatcher().Post([this, ownerBox = ownerBox_]() {
+      uiDispatcher.Post([this, ownerBox = ownerBox_]() {
         auto owner = ownerBox->owner.lock();
         if (!owner) {
           return;

package/Microsoft.ReactNative/AsynchronousEventBeat.h

@@ -11,13 +11,10 @@ class AsynchronousEventBeat final : public facebook::react::EventBeat {
       const winrt::Microsoft::ReactNative::ReactContext &context,
       std::shared_ptr<facebook::react::RuntimeScheduler> runtimeScheduler);
 
-  void induce() const;
   void request() const override;
 
  private:
-  mutable std::atomic<bool> m_isBeatCallbackScheduled{false};
   winrt::Microsoft::ReactNative::ReactContext m_context;
-  std::shared_ptr<facebook::react::RuntimeScheduler> m_runtimeScheduler;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/{JSDispatcherWriter.cpp → CallInvokerWriter.cpp}

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 #include "pch.h"
-#include "JSDispatcherWriter.h"
+#include "CallInvokerWriter.h"
 #include <JSI/JSIDynamic.h>
 #include <crash/verifyElseCrash.h>
 
@@ -25,106 +25,108 @@ struct JSNoopWriter : winrt::implements<JSNoopWriter, IJSValueWriter> {
 };
 
 //===========================================================================
-// JSDispatcherWriter implementation
+// CallInvokerWriter implementation
 //===========================================================================
 
-JSDispatcherWriter::JSDispatcherWriter(
-    IReactDispatcher const &jsDispatcher,
+CallInvokerWriter::CallInvokerWriter(
+    const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker,
     std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept
-    : m_jsDispatcher(jsDispatcher), m_jsiRuntimeHolder(std::move(jsiRuntimeHolder)) {}
+    : m_callInvoker(jsInvoker), m_jsiRuntimeHolder(std::move(jsiRuntimeHolder)) {}
 
-JSDispatcherWriter::~JSDispatcherWriter() {
+CallInvokerWriter::~CallInvokerWriter() {
   if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
     jsiRuntimeHolder->allowRelease();
   }
 }
 
-void JSDispatcherWriter::WithResultArgs(
+void CallInvokerWriter::WithResultArgs(
     Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
         handler) noexcept {
-  if (m_jsDispatcher.HasThreadAccess()) {
-    VerifyElseCrash(!m_dynamicWriter);
-    if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
-      const facebook::jsi::Value *args{nullptr};
-      size_t argCount{0};
-      m_jsiWriter->AccessResultAsArgs(args, argCount);
-      handler(jsiRuntimeHolder->Runtime(), args, argCount);
-      m_jsiWriter = nullptr;
-    }
-  } else {
-    VerifyElseCrash(!m_jsiWriter);
-    folly::dynamic dynValue = m_dynamicWriter->TakeValue();
-    VerifyElseCrash(dynValue.isArray());
-    m_jsDispatcher.Post(
-        [handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder, self = get_strong()]() {
-          if (auto jsiRuntimeHolder = weakJsiRuntimeHolder.lock()) {
-            std::vector<facebook::jsi::Value> args;
-            args.reserve(dynValue.size());
-            auto &runtime = jsiRuntimeHolder->Runtime();
-            for (auto const &item : dynValue) {
-              args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
-            }
-            handler(runtime, args.data(), args.size());
-          }
-        });
-  }
+  /*
+    if (m_jsDispatcher.HasThreadAccess()) {
+      VerifyElseCrash(!m_dynamicWriter);
+      if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
+        const facebook::jsi::Value *args{nullptr};
+        size_t argCount{0};
+        m_jsiWriter->AccessResultAsArgs(args, argCount);
+        handler(jsiRuntimeHolder->Runtime(), args, argCount);
+        m_jsiWriter = nullptr;
+      }
+    } else {
+  */
+  VerifyElseCrash(!m_jsiWriter);
+  folly::dynamic dynValue = m_dynamicWriter->TakeValue();
+  VerifyElseCrash(dynValue.isArray());
+  m_callInvoker->invokeAsync(
+      [handler, dynValue = std::move(dynValue), weakJsiRuntimeHolder = m_jsiRuntimeHolder, self = get_strong()](
+          facebook::jsi::Runtime &runtime) {
+        std::vector<facebook::jsi::Value> args;
+        args.reserve(dynValue.size());
+        for (auto const &item : dynValue) {
+          args.emplace_back(facebook::jsi::valueFromDynamic(runtime, item));
+        }
+        handler(runtime, args.data(), args.size());
+      });
+  //}
 }
 
-void JSDispatcherWriter::WriteNull() noexcept {
+void CallInvokerWriter::WriteNull() noexcept {
   GetWriter().WriteNull();
 }
 
-void JSDispatcherWriter::WriteBoolean(bool value) noexcept {
+void CallInvokerWriter::WriteBoolean(bool value) noexcept {
   GetWriter().WriteBoolean(value);
 }
 
-void JSDispatcherWriter::WriteInt64(int64_t value) noexcept {
+void CallInvokerWriter::WriteInt64(int64_t value) noexcept {
   GetWriter().WriteInt64(value);
 }
 
-void JSDispatcherWriter::WriteDouble(double value) noexcept {
+void CallInvokerWriter::WriteDouble(double value) noexcept {
   GetWriter().WriteDouble(value);
 }
 
-void JSDispatcherWriter::WriteString(const winrt::hstring &value) noexcept {
+void CallInvokerWriter::WriteString(const winrt::hstring &value) noexcept {
   GetWriter().WriteString(value);
 }
 
-void JSDispatcherWriter::WriteObjectBegin() noexcept {
+void CallInvokerWriter::WriteObjectBegin() noexcept {
   GetWriter().WriteObjectBegin();
 }
 
-void JSDispatcherWriter::WritePropertyName(const winrt::hstring &name) noexcept {
+void CallInvokerWriter::WritePropertyName(const winrt::hstring &name) noexcept {
   GetWriter().WritePropertyName(name);
 }
 
-void JSDispatcherWriter::WriteObjectEnd() noexcept {
+void CallInvokerWriter::WriteObjectEnd() noexcept {
   GetWriter().WriteObjectEnd();
 }
 
-void JSDispatcherWriter::WriteArrayBegin() noexcept {
+void CallInvokerWriter::WriteArrayBegin() noexcept {
   GetWriter().WriteArrayBegin();
 }
 
-void JSDispatcherWriter::WriteArrayEnd() noexcept {
+void CallInvokerWriter::WriteArrayEnd() noexcept {
   GetWriter().WriteArrayEnd();
 }
 
-IJSValueWriter JSDispatcherWriter::GetWriter() noexcept {
+IJSValueWriter CallInvokerWriter::GetWriter() noexcept {
   if (!m_writer) {
-    if (m_jsDispatcher.HasThreadAccess()) {
-      if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
-        m_jsiWriter = winrt::make_self<JsiWriter>(jsiRuntimeHolder->Runtime());
-        m_writer = m_jsiWriter.as<IJSValueWriter>();
-      } else {
-        m_writer = winrt::make<JSNoopWriter>();
-      }
-    } else {
-      m_dynamicWriter = winrt::make_self<DynamicWriter>();
-      m_writer = m_dynamicWriter.as<IJSValueWriter>();
-    }
+    /*
+        if (m_jsDispatcher.HasThreadAccess()) {
+          if (auto jsiRuntimeHolder = m_jsiRuntimeHolder.lock()) {
+            m_jsiWriter = winrt::make_self<JsiWriter>(jsiRuntimeHolder->Runtime());
+            m_writer = m_jsiWriter.as<IJSValueWriter>();
+          } else {
+            m_writer = winrt::make<JSNoopWriter>();
+          }
+        } else {
+         */
+    m_dynamicWriter = winrt::make_self<DynamicWriter>();
+    m_writer = m_dynamicWriter.as<IJSValueWriter>();
+    //}
   }
-  Debug(VerifyElseCrash(m_dynamicWriter != nullptr || m_jsDispatcher.HasThreadAccess()));
+  Debug(VerifyElseCrash(m_dynamicWriter != nullptr /* || m_jsDispatcher.HasThreadAccess()*/));
   return m_writer;
 }
 

package/Microsoft.ReactNative/{JSDispatcherWriter.h → CallInvokerWriter.h}

@@ -3,6 +3,7 @@
 #pragma once
 
 #include <JSI/LongLivedJsiValue.h>
+#include <ReactCommon/CallInvoker.h>
 #include <functional/functor.h>
 #include "DynamicWriter.h"
 #include "JsiWriter.h"
@@ -10,13 +11,13 @@
 
 namespace winrt::Microsoft::ReactNative {
 
-// IJSValueWriter to ensure that JsiWriter is always used from JSDispatcher.
-// In case if writing is done outside of JSDispatcher, it uses DynamicWriter to create
-// folly::dynamic which then is written to JsiWriter in JSDispatcher.
-struct JSDispatcherWriter : winrt::implements<JSDispatcherWriter, IJSValueWriter> {
-  ~JSDispatcherWriter();
-  JSDispatcherWriter(
-      IReactDispatcher const &jsDispatcher,
+// IJSValueWriter to ensure that JsiWriter is always used from a RuntimeExecutor.
+// In case if writing is done outside of RuntimeExecutor, it uses DynamicWriter to create
+// folly::dynamic which then is written to JsiWriter in RuntimeExecutor.
+struct CallInvokerWriter : winrt::implements<CallInvokerWriter, IJSValueWriter> {
+  ~CallInvokerWriter();
+  CallInvokerWriter(
+      const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker,
       std::weak_ptr<LongLivedJsiRuntime> jsiRuntimeHolder) noexcept;
   void WithResultArgs(Mso::Functor<void(facebook::jsi::Runtime &rt, facebook::jsi::Value const *args, size_t argCount)>
                           handler) noexcept;
@@ -37,7 +38,7 @@ struct JSDispatcherWriter : winrt::implements<JSDispatcherWriter, IJSValueWriter
   IJSValueWriter GetWriter() noexcept;
 
  private:
-  IReactDispatcher m_jsDispatcher;
+  const std::shared_ptr<facebook::react::CallInvoker> m_callInvoker;
   std::weak_ptr<LongLivedJsiRuntime> m_jsiRuntimeHolder;
   winrt::com_ptr<DynamicWriter> m_dynamicWriter;
   winrt::com_ptr<JsiWriter> m_jsiWriter;

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

@@ -0,0 +1,100 @@
+#include "pch.h"
+#include "CompositionAnnotationProvider.h"
+#include <Fabric/ComponentView.h>
+#include <Unicode.h>
+#include "RootComponentView.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionAnnotationProvider::CompositionAnnotationProvider(
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+    CompositionDynamicAutomationProvider *parentProvider) noexcept
+    : m_view{componentView} {
+  m_parentProvider.copy_from(parentProvider);
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_AnnotationTypeId(int *retVal) {
+  if (retVal == 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;
+
+  if (props->accessibilityAnnotation.value().typeID.empty()) {
+    return E_FAIL;
+  }
+  *retVal = static_cast<int>(GetAnnotationTypeId(props->accessibilityAnnotation.value().typeID));
+  return S_OK;
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_AnnotationTypeName(BSTR *retVal) {
+  if (retVal == 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;
+
+  if (props->accessibilityAnnotation.value().typeName.empty()) {
+    return E_FAIL;
+  }
+  auto typeName = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAnnotation.value().typeName);
+  *retVal = SysAllocString(typeName.c_str());
+  return S_OK;
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_Author(BSTR *retVal) {
+  if (retVal == 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;
+
+  if (props->accessibilityAnnotation.value().author.empty()) {
+    return E_FAIL;
+  }
+  auto author = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAnnotation.value().author);
+  *retVal = SysAllocString(author.c_str());
+  return S_OK;
+}
+HRESULT __stdcall CompositionAnnotationProvider::get_DateTime(BSTR *retVal) {
+  if (retVal == 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;
+
+  if (props->accessibilityAnnotation.value().dateTime.empty()) {
+    return E_FAIL;
+  }
+  auto dateTime = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityAnnotation.value().dateTime);
+  *retVal = SysAllocString(dateTime.c_str());
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionAnnotationProvider::get_Target(IRawElementProviderSimple **retVal) {
+  // no-opt
+  return E_NOTIMPL;
+}
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#include <UIAutomation.h>
+#include <inspectable.h>
+#include <uiautomationcore.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+class CompositionAnnotationProvider : public winrt::implements<CompositionAnnotationProvider, IAnnotationProvider> {
+ public:
+  CompositionAnnotationProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+
+  // inherited via IAnnotationProvider
+  virtual HRESULT __stdcall get_AnnotationTypeId(int *retVal) override;
+  virtual HRESULT __stdcall get_AnnotationTypeName(BSTR *retVal) override;
+  virtual HRESULT __stdcall get_Author(BSTR *retVal) override;
+  virtual HRESULT __stdcall get_DateTime(BSTR *retVal) override;
+  virtual HRESULT __stdcall get_Target(IRawElementProviderSimple **retVal) override;
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<IAnnotationProvider> m_annotationProvider;
+  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -1,6 +1,7 @@
 #include "pch.h"
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.h>
+#include <Fabric/Composition/CompositionAnnotationProvider.h>
 #include <Fabric/Composition/CompositionTextRangeProvider.h>
 #include <Fabric/Composition/ParagraphComponentView.h>
 #include <Fabric/Composition/ScrollViewComponentView.h>
@@ -36,6 +37,12 @@ CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
                          strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), this)
                          .try_as<ITextProvider2>();
   }
+
+  if (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>()) {
+    m_annotationProvider = winrt::make<CompositionAnnotationProvider>(
+                               strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), this)
+                               .try_as<IAnnotationProvider>();
+  }
 }
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
@@ -282,6 +289,11 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
       strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>()) {
     m_textProvider.as<IUnknown>().copy_to(pRetVal);
   }
+  if (patternId == UIA_AnnotationPatternId &&
+      strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>() &&
+      accessibilityAnnotationHasValue(props->accessibilityAnnotation)) {
+    m_annotationProvider.as<IUnknown>().copy_to(pRetVal);
+  }
 
   return S_OK;
 }

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

@@ -101,6 +101,7 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
  private:
   ::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/CompositionUIService.cpp

@@ -25,8 +25,6 @@ void CompositionUIService::SetCompositor(
       CompositionContextPropertyId(),
       winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::CreateContext(
           compositor));
-  // Default to using Bridgeless mode when using fabric
-  winrt::Microsoft::ReactNative::implementation::QuirkSettings::SetIsBridgeless(properties, !!compositor);
 }
 
 winrt::Microsoft::UI::Composition::Compositor CompositionUIService::GetCompositor(

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

@@ -231,7 +231,6 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
 
     m_popUp = winrt::Microsoft::UI::Content::DesktopPopupSiteBridge::Create(
         portal.Parent()
-            .Parent()
             .as<winrt::Microsoft::ReactNative::Composition::ComponentView>()
             .Root()
             .ReactNativeIsland()

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

@@ -973,6 +973,10 @@ void WindowsTextInputComponentView::onLostFocus(
     LRESULT lresult;
     DrawBlock db(*this);
     m_textServices->TxSendMessage(WM_KILLFOCUS, 0, 0, &lresult);
+    if (windowsTextInputProps().selectTextOnFocus) {
+      LRESULT res;
+      m_textServices->TxSendMessage(EM_SETSEL, static_cast<WPARAM>(-1), static_cast<WPARAM>(-1), &res);
+    }
   }
   m_caretVisual.IsVisible(false);
 
@@ -1001,6 +1005,9 @@ void WindowsTextInputComponentView::onGotFocus(
 
     if (windowsTextInputProps().clearTextOnFocus) {
       m_textServices->TxSetText(L"");
+    } else if (windowsTextInputProps().selectTextOnFocus) {
+      LRESULT res;
+      m_textServices->TxSendMessage(EM_SETSEL, static_cast<WPARAM>(0), static_cast<WPARAM>(-1), &res);
     }
   }
 }

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

@@ -189,6 +189,64 @@ long GetLiveSetting(const std::string &liveRegion) noexcept {
   return LiveSetting::Off;
 }
 
+long GetAnnotationTypeId(const std::string &annotationType) noexcept {
+  if (annotationType == "Author") {
+    return AnnotationType_Author;
+  } else if (annotationType == "CircularReferenceError") {
+    return AnnotationType_CircularReferenceError;
+  } else if (annotationType == "Comment") {
+    return AnnotationType_Comment;
+  } else if (annotationType == "ConflictingChange") {
+    return AnnotationType_ConflictingChange;
+  } else if (annotationType == "DataValidationError") {
+    return AnnotationType_DataValidationError;
+  } else if (annotationType == "DeletionChange") {
+    return AnnotationType_DeletionChange;
+  } else if (annotationType == "EditingLockedChange") {
+    return AnnotationType_EditingLockedChange;
+  } else if (annotationType == "Endnote") {
+    return AnnotationType_Endnote;
+  } else if (annotationType == "ExternalChange") {
+    return AnnotationType_ExternalChange;
+  } else if (annotationType == "Footer") {
+    return AnnotationType_Footer;
+  } else if (annotationType == "Footnote") {
+    return AnnotationType_Footnote;
+  } else if (annotationType == "FormatChange") {
+    return AnnotationType_FormatChange;
+  } else if (annotationType == "FormulaError") {
+    return AnnotationType_FormulaError;
+  } else if (annotationType == "GrammarError") {
+    return AnnotationType_GrammarError;
+  } else if (annotationType == "Header") {
+    return AnnotationType_Header;
+  } else if (annotationType == "Highlighted") {
+    return AnnotationType_Highlighted;
+  } else if (annotationType == "InsertionChange") {
+    return AnnotationType_InsertionChange;
+  } else if (annotationType == "Mathematics") {
+    return AnnotationType_Mathematics;
+  } else if (annotationType == "MoveChange") {
+    return AnnotationType_MoveChange;
+  } else if (annotationType == "SpellingError") {
+    return AnnotationType_SpellingError;
+  } else if (annotationType == "TrackChanges") {
+    return AnnotationType_TrackChanges;
+  } else if (annotationType == "AdvanceProofingIssue") {
+    return AnnotationType_AdvancedProofingIssue;
+  } else if (annotationType == "UnsyncedChange") {
+    return AnnotationType_UnsyncedChange;
+  }
+  return AnnotationType_Unknown;
+}
+
+bool accessibilityAnnotationHasValue(
+    const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept {
+  return annotation.has_value() &&
+      !(annotation.value().typeID.empty() && annotation.value().typeName.empty() && annotation.value().author.empty() &&
+        annotation.value().dateTime.empty() && annotation.value().target.empty());
+}
+
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept {
   auto strongView = view.view();
 

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

@@ -33,6 +33,11 @@ void UpdateUiaProperty(
 
 long GetLiveSetting(const std::string &liveRegion) noexcept;
 
+long GetAnnotationTypeId(const std::string &annotationType) noexcept;
+
+bool accessibilityAnnotationHasValue(
+    const std::optional<facebook::react::AccessibilityAnnotation> &annotation) noexcept;
+
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
 
 ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -19,7 +19,6 @@
 #include <JSI/jsi.h>
 #include <ReactCommon/RuntimeExecutor.h>
 #include <SchedulerSettings.h>
-#include <SynchronousEventBeat.h>
 #include <UI.Xaml.Controls.h>
 #include <react/components/rnwcore/ComponentDescriptors.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>