react-native-windows 0.80.0 → 0.80.5

package/Directory.Build.props

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

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

@@ -0,0 +1,169 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "DebuggerUIIsland.h"
+
+#include <AutoDraw.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/textlayoutmanager/WindowsTextLayoutManager.h>
+#include <winrt/Microsoft.UI.Composition.h>
+#include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Microsoft.UI.Input.h>
+#include "CompositionContextHelper.h"
+#include "TextDrawing.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+constexpr float debuggerUIFontSize = 10.0f;
+constexpr float debuggerTextMargin = 4.0f;
+
+DebuggerUIIsland::DebuggerUIIsland(
+    const winrt::Microsoft::UI::Composition::Compositor &compositor,
+    winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
+    winrt::Microsoft::ReactNative::Composition::Theme theme) noexcept
+    : m_compositor(compositor), m_compContext(compContext), m_theme(theme) {
+  m_backgroundVisual = m_compositor.CreateSpriteVisual();
+  m_backgroundVisual.RelativeSizeAdjustment({1.0f, 1.0f});
+
+  auto backgroundBrush = m_compositor.CreateColorBrush({100, 0, 0, 0});
+  m_backgroundVisual.Brush(backgroundBrush);
+
+  m_TextVisual = m_compositor.CreateSpriteVisual();
+  m_TextVisual.IsPixelSnappingEnabled(true);
+
+  m_backgroundVisual.Children().InsertAtTop(m_TextVisual);
+}
+
+DebuggerUIIsland::~DebuggerUIIsland() noexcept {
+  m_island.StateChanged(m_islandStateChangedToken);
+}
+
+void DebuggerUIIsland::Redraw() noexcept {
+  if (!m_island)
+    return;
+
+  if (m_island.ActualSize().x == 0 || m_island.ActualSize().y == 0)
+    return;
+
+  auto scaleFactor = m_island.Environment().DisplayScale();
+
+  auto attributedString = facebook::react::AttributedString{};
+  auto fragment = facebook::react::AttributedString::Fragment{};
+  fragment.string = m_message;
+  fragment.textAttributes.fontSize = debuggerUIFontSize;
+  attributedString.appendFragment(std::move(fragment));
+
+  // Resume Icon
+  auto iconFragment = facebook::react::AttributedString::Fragment{};
+  iconFragment.string = " \uF08F";
+  iconFragment.textAttributes.fontFamily = "Segoe Fluent Icons";
+  iconFragment.textAttributes.fontSize = debuggerUIFontSize;
+  attributedString.appendFragment(std::move(iconFragment));
+
+  auto attributedStringBox = facebook::react::AttributedStringBox{attributedString};
+
+  facebook::react::LayoutConstraints constraints;
+  constraints.maximumSize.width = std::max(0.0f, m_island.ActualSize().x - debuggerTextMargin * 2 * scaleFactor);
+  constraints.maximumSize.height = std::max(0.0f, m_island.ActualSize().y - debuggerTextMargin * 2 * scaleFactor);
+
+  auto textAttributes = facebook::react::TextAttributes{};
+  textAttributes.foregroundColor = facebook::react::blackColor();
+
+  winrt::com_ptr<::IDWriteTextLayout> textLayout;
+  facebook::react::WindowsTextLayoutManager::GetTextLayout(attributedStringBox, {}, constraints, textLayout);
+
+  DWRITE_TEXT_METRICS tm;
+  textLayout->GetMetrics(&tm);
+
+  winrt::Windows::Foundation::Size surfaceSize = {
+      std::ceilf(std::min(constraints.maximumSize.width, tm.width + debuggerTextMargin * 2 * scaleFactor)),
+      std::ceilf(std::min(constraints.maximumSize.height, tm.height + debuggerTextMargin * 2 * scaleFactor))};
+  auto drawingSurface = m_compContext.CreateDrawingSurfaceBrush(
+      surfaceSize,
+      winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized,
+      winrt::Windows::Graphics::DirectX::DirectXAlphaMode::Premultiplied);
+
+  POINT offset;
+  {
+    ::Microsoft::ReactNative::Composition::AutoDrawDrawingSurface autoDraw(drawingSurface, scaleFactor, &offset);
+    if (auto d2dDeviceContext = autoDraw.GetRenderTarget()) {
+      d2dDeviceContext->Clear(D2D1::ColorF{1.0f, 1.0f, 0.76f, 1.0f});
+
+      auto theme = winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::Theme>(m_theme);
+
+      Composition::RenderText(
+          *d2dDeviceContext,
+          *textLayout,
+          attributedStringBox.getValue(),
+          textAttributes,
+          {static_cast<float>(offset.x + std::floorf(debuggerTextMargin * scaleFactor)),
+           static_cast<float>(offset.y + std::floorf(debuggerTextMargin * scaleFactor))},
+          scaleFactor,
+          *theme);
+    }
+
+    drawingSurface.HorizontalAlignmentRatio(0.0f);
+    drawingSurface.Stretch(winrt::Microsoft::ReactNative::Composition::Experimental::CompositionStretch::None);
+
+    m_TextVisual.Brush(winrt::Microsoft::ReactNative::Composition::Experimental::implementation::
+                           MicrosoftCompositionContextHelper::InnerBrush(drawingSurface));
+    m_TextVisual.Size({surfaceSize.Width, surfaceSize.Height});
+
+    m_debuggerHitRect = {
+        m_island.ActualSize().x / 2 - tm.width / 2 + debuggerTextMargin * scaleFactor,
+        debuggerTextMargin * scaleFactor,
+        surfaceSize.Width,
+        surfaceSize.Height};
+
+    m_TextVisual.Offset({m_debuggerHitRect.X, m_debuggerHitRect.Y, 0.0f});
+  }
+}
+
+void DebuggerUIIsland::Message(std::string &&value) noexcept {
+  m_message = value;
+  Redraw();
+}
+
+winrt::Microsoft::UI::Content::ContentIsland DebuggerUIIsland::Island() noexcept {
+  if (!m_island) {
+    m_island = winrt::Microsoft::UI::Content::ContentIsland::Create(m_backgroundVisual);
+
+    m_islandStateChangedToken =
+        m_island.StateChanged([weakThis = weak_from_this()](
+                                  winrt::Microsoft::UI::Content::ContentIsland const &island,
+                                  winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
+          if (auto pThis = weakThis.lock()) {
+            if (args.DidRasterizationScaleChange() || args.DidActualSizeChange()) {
+              pThis->Redraw();
+            }
+          }
+        });
+
+    auto pointerSource = winrt::Microsoft::UI::Input::InputPointerSource::GetForIsland(m_island);
+
+    m_islandPointerUpToken =
+        pointerSource.PointerReleased([weakThis = weak_from_this()](
+                                          winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                          winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+          if (auto pThis = weakThis.lock()) {
+            auto position = args.CurrentPoint().Position();
+            if (position.X >= pThis->m_debuggerHitRect.X && position.Y >= pThis->m_debuggerHitRect.Y &&
+                position.X <= pThis->m_debuggerHitRect.X + pThis->m_debuggerHitRect.Width &&
+                position.Y <= pThis->m_debuggerHitRect.Y + pThis->m_debuggerHitRect.Height) {
+              pThis->m_resumedEvent(nullptr, nullptr);
+            }
+          }
+        });
+  }
+  return m_island;
+}
+
+winrt::event_token DebuggerUIIsland::Resumed(
+    winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable> const &handler) noexcept {
+  return m_resumedEvent.add(handler);
+}
+void DebuggerUIIsland::Resumed(winrt::event_token const &token) noexcept {
+  m_resumedEvent.remove(token);
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+
+#include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+struct DebuggerUIIsland : std::enable_shared_from_this<DebuggerUIIsland> {
+  DebuggerUIIsland(
+      const winrt::Microsoft::UI::Composition::Compositor &compositor,
+      winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
+      winrt::Microsoft::ReactNative::Composition::Theme theme) noexcept;
+  ~DebuggerUIIsland() noexcept;
+  winrt::Microsoft::UI::Content::ContentIsland Island() noexcept;
+
+  void Message(std::string &&value) noexcept;
+
+  winrt::event_token Resumed(
+      winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable> const &handler) noexcept;
+  void Resumed(winrt::event_token const &token) noexcept;
+
+ private:
+  void Redraw() noexcept;
+
+  winrt::event_token m_islandStateChangedToken;
+  winrt::event_token m_islandPointerUpToken;
+
+  winrt::Microsoft::UI::Composition::SpriteVisual m_backgroundVisual{nullptr};
+  winrt::Microsoft::UI::Composition::SpriteVisual m_TextVisual{nullptr};
+  winrt::Windows::Foundation::Rect m_debuggerHitRect{0, 0, 0, 0};
+  winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
+  std::string m_message;
+
+  winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>> m_resumedEvent;
+  winrt::Microsoft::UI::Composition::Compositor m_compositor{nullptr};
+  winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext m_compContext{nullptr};
+  winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -103,9 +103,9 @@ void DebuggingOverlayComponentView::HandleCommand(
       auto rootVisual = root->OuterVisual();
 
       while (m_activeOverlays != 0) {
+        --m_activeOverlays;
         auto visual = rootVisual.GetAt(root->overlayIndex() + m_activeOverlays);
         rootVisual.Remove(visual);
-        --m_activeOverlays;
       }
     }
     return;

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

@@ -35,26 +35,44 @@ struct ModalHostState
 struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::Foundation::IInspectable>,
                        ::Microsoft::ReactNativeSpecs::BaseModalHostView<ModalHostView> {
   ~ModalHostView() {
-    if (m_reactNativeIsland) {
-      m_reactNativeIsland.Island().Close();
-    }
+    if (m_popUp) {
+      // Unregister closing event handler
+      if (m_appWindow && m_appWindowClosingToken) {
+        m_appWindow.Closing(m_appWindowClosingToken);
+        m_appWindowClosingToken.value = 0;
+      }
 
-    // Add AppWindow closing token cleanup
-    if (m_appWindow && m_appWindowClosingToken) {
-      m_appWindow.Closing(m_appWindowClosingToken);
-      m_appWindowClosingToken.value = 0;
-    }
+      // Reset topWindowID before destroying
+      if (m_prevWindowID) {
+        winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
+            m_reactContext.Properties().Handle(), m_prevWindowID);
+        m_prevWindowID = 0;
+      }
 
-    if (m_popUp) {
-      if (m_departFocusToken && !m_popUp.IsClosed()) {
-        // WASDK BUG: InputFocusNavigationHost::GetForSiteBridge fails on a DesktopPopupSiteBridge
-        // https://github.com/microsoft/react-native-windows/issues/14604
-        /*
-        auto navHost =
-        winrt::Microsoft::UI::Input::InputFocusNavigationHost::GetForSiteBridge(m_popUp.as<winrt::Microsoft::UI::Content::IContentSiteBridge>());
-        navHost.DepartFocusRequested(m_departFocusToken);
-        */
+      // Close island
+      if (m_reactNativeIsland) {
+        m_reactNativeIsland.Island().Close();
+        m_reactNativeIsland = nullptr;
+      }
+
+      // Hide popup
+      if (m_popUp.IsVisible()) {
+        m_popUp.Hide();
+      }
+
+      // Destroy AppWindow this automatically resumes parent window to receive inputs
+      if (m_appWindow) {
+        m_appWindow.Destroy();
+        m_appWindow = nullptr;
+      }
+
+      // Bring parent window to foreground
+      if (m_parentHwnd) {
+        SetForegroundWindow(m_parentHwnd);
+        SetFocus(m_parentHwnd);
       }
+
+      // Close bridge
       m_popUp.Close();
       m_popUp = nullptr;
     }
@@ -88,7 +106,7 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
         QueueShow(view);
       } else {
         m_visible = false;
-        CloseWindow();
+        HideWindow();
       }
     }
 
@@ -219,31 +237,33 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
     }
   }
 
-  void CloseWindow() noexcept {
-    // enable input to parent before closing the modal window, so focus can return back to the parent window
-    EnableWindow(m_parentHwnd, true);
+  /*
+  HideWindow called on visible=false
+  unmounts the modal window using onDismiss event
+  */
+  void HideWindow() noexcept {
+    // Hide popup
     if (m_popUp) {
       m_popUp.Hide();
     }
 
-    // Unregister closing event handler
-    if (m_appWindow && m_appWindowClosingToken) {
-      m_appWindow.Closing(m_appWindowClosingToken);
-      m_appWindowClosingToken.value = 0;
+    // Restore message routing to parent
+    if (m_prevWindowID) {
+      winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
+          m_reactContext.Properties().Handle(), m_prevWindowID);
     }
 
-    // dispatch onDismiss event
+    // Bring parent window to foreground
+    if (m_parentHwnd) {
+      SetForegroundWindow(m_parentHwnd);
+      SetFocus(m_parentHwnd);
+    }
+
+    // Dispatch onDismiss event
     if (auto eventEmitter = EventEmitter()) {
       ::Microsoft::ReactNativeSpecs::ModalHostViewEventEmitter::OnDismiss eventArgs;
       eventEmitter->onDismiss(eventArgs);
     }
-
-    // reset the topWindowID
-    if (m_prevWindowID) {
-      winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
-          m_reactContext.Properties().Handle(), m_prevWindowID);
-      m_prevWindowID = 0;
-    }
   }
 
   // creates a new modal window
@@ -279,9 +299,16 @@ struct ModalHostView : public winrt::implements<ModalHostView, winrt::Windows::F
       overlappedPresenter.IsModal(true);
       overlappedPresenter.SetBorderAndTitleBar(true, true);
 
+      // modal should only have close button
+      overlappedPresenter.IsMinimizable(false);
+      overlappedPresenter.IsMaximizable(false);
+
       // Apply the presenter to the window
       m_appWindow.SetPresenter(overlappedPresenter);
 
+      // Hide the title bar icon
+      m_appWindow.TitleBar().IconShowOptions(winrt::Microsoft::UI::Windowing::IconShowOptions::HideIconAndSystemMenu);
+
       // Set initial title using the stored local props
       if (m_localProps && m_localProps->title.has_value()) {
         winrt::hstring titleValue = winrt::to_hstring(m_localProps->title.value());

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

@@ -284,6 +284,7 @@ void ReactNativeIsland::UpdateRootVisualSize() noexcept {
     m_rootVisual.Size({m_size.Width * m_scaleFactor, m_size.Height * m_scaleFactor});
 
   UpdateLoadingVisualSize();
+  UpdateDebuggerVisualSize();
 }
 
 void ReactNativeIsland::UpdateLoadingVisualSize() noexcept {
@@ -300,6 +301,13 @@ void ReactNativeIsland::UpdateLoadingVisualSize() noexcept {
   }
 }
 
+void ReactNativeIsland::UpdateDebuggerVisualSize() noexcept {
+  if (!m_debuggerChildSiteLink)
+    return;
+
+  m_debuggerChildSiteLink.ActualSize(m_size);
+}
+
 float ReactNativeIsland::ScaleFactor() noexcept {
   return m_scaleFactor;
 }
@@ -484,6 +492,20 @@ void ReactNativeIsland::InitRootView(
   m_CompositionEventHandler = std::make_shared<::Microsoft::ReactNative::CompositionEventHandler>(m_context, *this);
   m_CompositionEventHandler->Initialize();
 
+  ::Microsoft::ReactNative::DebuggerNotifications::SubscribeShowDebuggerPausedOverlay(
+      m_context.Notifications().Handle(),
+      m_context.UIDispatcher().Handle(),
+      [weakThis = get_weak()](std::string message, std::function<void()> onResume) {
+        if (auto strongThis = weakThis.get()) {
+          strongThis->ShowDebuggerUI(message, onResume);
+        }
+      },
+      [weakThis = get_weak()]() {
+        if (auto strongThis = weakThis.get()) {
+          strongThis->HideDebuggerUI();
+        }
+      });
+
   UpdateRootViewInternal();
 
   m_isInitialized = true;
@@ -746,7 +768,10 @@ void ReactNativeIsland::ShowInstanceLoading() noexcept {
   NotifySizeChanged();
   UpdateLoadingVisualSize();
 
-  InternalRootVisual().InsertAt(m_loadingVisual, m_hasRenderedVisual ? 1 : 0);
+  // ShowDebuggerUI(); // TEMP
+
+  InternalRootVisual().InsertAt(
+      m_loadingVisual, m_hasRenderedVisual ? (m_debuggerVisual ? 2 : 1) : (m_debuggerVisual ? 1 : 0));
 }
 
 void ReactNativeIsland::InitTextScaleMultiplier() noexcept {
@@ -767,6 +792,48 @@ void ReactNativeIsland::InitTextScaleMultiplier() noexcept {
       });
 }
 
+void ReactNativeIsland::ShowDebuggerUI(std::string message, const std::function<void()> &onResume) noexcept {
+  if (!m_debuggerVisual) {
+    auto compContext =
+        winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
+            m_context.Properties().Handle());
+    m_debuggerVisual = compContext.CreateSpriteVisual();
+
+    m_debuggerChildSiteLink = winrt::Microsoft::UI::Content::ChildSiteLink::Create(
+        Island(),
+        winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::InnerVisual(
+            m_debuggerVisual)
+            .as<winrt::Microsoft::UI::Composition::ContainerVisual>());
+
+    m_debuggerUIIsland = std::make_shared<DebuggerUIIsland>(m_compositor, compContext, Theme());
+    m_debuggerUIIsland->Message(std::string(message));
+    m_debuggerVisual.RelativeSizeWithOffset({0.0f, 0.0f}, {1.0f, 1.0f});
+
+    m_debuggerUIIsland->Resumed(
+        [wkThis = get_weak(), onResume](
+            const winrt::Windows::Foundation::IInspectable &, const winrt::Windows::Foundation::IInspectable &) {
+          if (auto pThis = wkThis.get()) {
+            // pThis->HideDebuggerUI();
+            onResume();
+          }
+        });
+
+    InternalRootVisual().InsertAt(m_debuggerVisual, m_hasRenderedVisual ? 1 : 0);
+    m_debuggerUIIsland->Island().IsHitTestVisibleWhenTransparent(false);
+    m_debuggerChildSiteLink.Connect(m_debuggerUIIsland->Island());
+  }
+
+  m_debuggerVisual.IsVisible(true);
+
+  UpdateRootVisualSize();
+}
+
+void ReactNativeIsland::HideDebuggerUI() noexcept {
+  if (m_debuggerVisual) {
+    m_debuggerVisual.IsVisible(false);
+  }
+}
+
 winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
     const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
     const winrt::Windows::Foundation::Point &viewportOffset) const {

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

@@ -7,11 +7,14 @@
 #include <FocusNavigationResult.g.h>
 
 #include <ReactContext.h>
+#include <ReactHost/DebuggerNotifications.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
 #include <winrt/Microsoft.ReactNative.h>
+#include <winrt/Microsoft.UI.Content.h>
 #include <winrt/Windows.UI.ViewManagement.h>
 #include "CompositionEventHandler.h"
+#include "DebuggerUIIsland.h"
 #include "PortalComponentView.h"
 #include "ReactHost/React.h"
 
@@ -181,6 +184,9 @@ struct ReactNativeIsland
   std::shared_ptr<::Microsoft::ReactNative::CompositionEventHandler> m_CompositionEventHandler;
   winrt::Microsoft::ReactNative::Composition::Experimental::IVisual m_rootVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual m_loadingVisual{nullptr};
+  winrt::Microsoft::UI::Content::ChildSiteLink m_debuggerChildSiteLink{nullptr};
+  std::shared_ptr<DebuggerUIIsland> m_debuggerUIIsland;
+  winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual m_debuggerVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IActivityVisual m_loadingActivityVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::ICustomResourceLoader m_resources{nullptr};
   winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
@@ -196,8 +202,11 @@ struct ReactNativeIsland
   void ShowInstanceLoaded() noexcept;
   void ShowInstanceError() noexcept;
   void ShowInstanceLoading() noexcept;
+  void ShowDebuggerUI(std::string message, const std::function<void()> &onResume) noexcept;
+  void HideDebuggerUI() noexcept;
   void UpdateRootVisualSize() noexcept;
   void UpdateLoadingVisualSize() noexcept;
+  void UpdateDebuggerVisualSize() noexcept;
   Composition::Experimental::IDrawingSurfaceBrush CreateLoadingVisualBrush() noexcept;
   void ApplyConstraints(
       const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraintsIn,

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

@@ -7,7 +7,6 @@
 #include "TextDrawing.h"
 
 #include <AutoDraw.h>
-#include <Fabric/platform/react/renderer/graphics/PlatformColorUtils.h>
 #include <Utils/ValueUtils.h>
 #include <unicode.h>
 #include <windows.ui.composition.interop.h>
@@ -36,27 +35,11 @@ void RenderText(
   // to cache and reuse a brush across all text elements instead, taking care to recreate
   // it in the event of device removed.
   winrt::com_ptr<ID2D1SolidColorBrush> brush;
-
-  // Check if we should use theme-aware default color instead of hardcoded black
-  bool useDefaultColor = false;
   if (textAttributes.foregroundColor) {
-    auto &color = *textAttributes.foregroundColor;
-    // If it's black (or very dark) without explicit PlatformColor, use theme-aware color
-    if (color.m_platformColor.empty() && color.m_color.R <= 10 && color.m_color.G <= 10 && color.m_color.B <= 10) {
-      useDefaultColor = true;
-    }
-  } else {
-    useDefaultColor = true;
-  }
-
-  if (useDefaultColor) {
-    // Use theme-aware TextFillColorPrimary which adapts to light/dark mode
-    auto d2dColor = theme.D2DPlatformColor("TextFillColorPrimary");
-    winrt::check_hresult(deviceContext.CreateSolidColorBrush(d2dColor, brush.put()));
-  } else {
-    // User set explicit color or PlatformColor - use it
     auto color = theme.D2DColor(*textAttributes.foregroundColor);
     winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, brush.put()));
+  } else {
+    winrt::check_hresult(deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), brush.put()));
   }
 
   if (textAttributes.textDecorationLineType) {
@@ -89,27 +72,12 @@ void RenderText(
             (fragment.textAttributes.foregroundColor != textAttributes.foregroundColor) ||
         !isnan(fragment.textAttributes.opacity)) {
       winrt::com_ptr<ID2D1SolidColorBrush> fragmentBrush;
-
-      // Check if we should use theme-aware default color for this fragment
-      bool useFragmentDefaultColor = false;
       if (fragment.textAttributes.foregroundColor) {
-        auto &color = *fragment.textAttributes.foregroundColor;
-        // If it's black (or very dark) without explicit PlatformColor, use theme-aware color
-        if (color.m_platformColor.empty() && color.m_color.R <= 10 && color.m_color.G <= 10 && color.m_color.B <= 10) {
-          useFragmentDefaultColor = true;
-        }
-      } else {
-        useFragmentDefaultColor = true;
-      }
-
-      if (useFragmentDefaultColor) {
-        // Use theme-aware TextFillColorPrimary which adapts to light/dark mode
-        auto d2dColor = theme.D2DPlatformColor("TextFillColorPrimary");
-        winrt::check_hresult(deviceContext.CreateSolidColorBrush(d2dColor, fragmentBrush.put()));
-      } else {
-        // User set explicit color or PlatformColor - use it
         auto color = theme.D2DColor(*fragment.textAttributes.foregroundColor);
         winrt::check_hresult(deviceContext.CreateSolidColorBrush(color, fragmentBrush.put()));
+      } else {
+        winrt::check_hresult(
+            deviceContext.CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black, 1.0f), fragmentBrush.put()));
       }
 
       if (fragment.textAttributes.textDecorationLineType) {

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

@@ -291,9 +291,11 @@ ImageResponseOrImageErrorInfo ImageFailedResponse::ResolveImage() {
   if (imageOrError.errorInfo->error.empty()) {
     imageOrError.errorInfo->error = "Failed to load image.";
   }
-  for (auto &&[header, value] : m_responseHeaders) {
-    imageOrError.errorInfo->httpResponseHeaders.push_back(
-        std::make_pair<std::string, std::string>(winrt::to_string(header), winrt::to_string(value)));
+  if (m_responseHeaders) {
+    for (auto &&[header, value] : m_responseHeaders) {
+      imageOrError.errorInfo->httpResponseHeaders.push_back(
+          std::make_pair<std::string, std::string>(winrt::to_string(header), winrt::to_string(value)));
+    }
   }
   return imageOrError;
 }

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -167,6 +167,9 @@ void FabricUIManager::setProps(facebook::react::SurfaceId surfaceId, const folly
 }
 
 void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept {
+  if (surfaceId == -1) {
+    return;
+  }
   visit(surfaceId, [&](const facebook::react::SurfaceHandler &surfaceHandler) {
     surfaceHandler.stop();
     m_scheduler->unregisterSurface(surfaceHandler);
@@ -176,7 +179,9 @@ void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept
     std::unique_lock lock(m_handlerMutex);
 
     auto iterator = m_handlerRegistry.find(surfaceId);
-    m_handlerRegistry.erase(iterator);
+    if (iterator != m_handlerRegistry.end()) {
+      m_handlerRegistry.erase(iterator);
+    }
   }
 
   auto &rootDescriptor = m_registry.componentViewDescriptorWithTag(surfaceId);

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -10,6 +10,7 @@
 #include <Fabric/Composition/ImageResponseImage.h>
 #include <Fabric/Composition/UriImageManager.h>
 #include <Networking/NetworkPropertyIds.h>
+#include <Utils/CppWinrtLessExceptions.h>
 #include <Utils/ImageUtils.h>
 #include <fmt/format.h>
 #include <functional/functor.h>
@@ -131,7 +132,19 @@ WindowsImageManager::GetImageRandomAccessStreamAsync(
     request.Content(bodyContent);
   }
 
-  winrt::Windows::Web::Http::HttpResponseMessage response(co_await m_httpClient.SendRequestAsync(request));
+  auto asyncOp = m_httpClient.SendRequestAsync(request);
+  co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
+      winrt::Windows::Web::Http::HttpResponseMessage,
+      winrt::Windows::Web::Http::HttpProgress>>{asyncOp};
+
+  if (asyncOp.Status() == winrt::Windows::Foundation::AsyncStatus::Error ||
+      asyncOp.Status() == winrt::Windows::Foundation::AsyncStatus::Canceled) {
+    auto errorMessage = FormatHResultError(winrt::hresult_error(asyncOp.ErrorCode()));
+    co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(
+        winrt::to_hstring("Network request failed: " + errorMessage));
+  }
+
+  winrt::Windows::Web::Http::HttpResponseMessage response = asyncOp.GetResults();
 
   if (!response.IsSuccessStatusCode()) {
     co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(

package/Microsoft.ReactNative/Fabric/platform/react/renderer/graphics/PlatformColorUtils.cpp

@@ -189,21 +189,4 @@ SharedColor GetTextInputPlaceholderColor(bool isFocused, const winrt::Windows::U
   }
 }
 
-SharedColor GetDefaultTextColor() {
-  // In high contrast mode, always use system WindowText for accessibility
-  auto accessibilitySettings{winrt::Windows::UI::ViewManagement::AccessibilitySettings()};
-  if (accessibilitySettings.HighContrast()) {
-    auto uiSettings{winrt::Windows::UI::ViewManagement::UISettings()};
-    auto windowText = uiSettings.UIElementColor(winrt::Windows::UI::ViewManagement::UIElementType::WindowText);
-    return hostPlatformColorFromRGBA(windowText.R, windowText.G, windowText.B, windowText.A);
-  }
-
-  // Use Windows 11 design system semantic color TextFillColorPrimary
-  // This automatically adapts to light/dark mode themes:
-  // - Light mode: rgba(0, 0, 0, 0.894) - nearly black for good contrast
-  // - Dark mode: rgba(255, 255, 255, 1.0) - white for readability
-  auto color = ResolvePlatformColor({"TextFillColorPrimary"});
-  return hostPlatformColorFromRGBA(color.R, color.G, color.B, color.A);
-}
-
 } // namespace facebook::react