react-native-windows 0.74.1 → 0.74.2

package/Libraries/Components/Touchable/TouchableBounce.js

@@ -209,6 +209,7 @@ class TouchableBounce extends React.Component<Props, State> {
 
   componentWillUnmount(): void {
     this.state.pressability.reset();
+    this.state.scale.resetAnimation();
   }
 }
 

package/Libraries/Components/Touchable/TouchableOpacity.js

@@ -320,6 +320,7 @@ class TouchableOpacity extends React.Component<Props, State> {
 
   componentWillUnmount(): void {
     this.state.pressability.reset();
+    this.state.anim.resetAnimation();
   }
 }
 

package/Libraries/Components/Touchable/TouchableOpacity.windows.js

@@ -335,6 +335,7 @@ class TouchableOpacity extends React.Component<Props, State> {
 
   componentWillUnmount(): void {
     this.state.pressability.reset();
+    this.state.anim.resetAnimation();
   }
 }
 

package/Libraries/Core/ReactNativeVersion.js

@@ -16,7 +16,7 @@ const version: $ReadOnly<{
 }> = {
   major: 0,
   minor: 74,
-  patch: 0,
+  patch: 1,
   prerelease: null,
 };
 

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

@@ -1966,6 +1966,12 @@ winrt::Microsoft::UI::Composition::ICompositionSurface MicrosoftCompositionConte
   surface.try_as(s);
   return s ? s->Inner() : nullptr;
 }
+
+winrt::Microsoft::ReactNative::Composition::Experimental::IBrush MicrosoftCompositionContextHelper::WrapBrush(
+    const winrt::Microsoft::UI::Composition::CompositionBrush &brush) noexcept {
+  return winrt::make<::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompBrush>(brush);
+}
+
 #endif
 
 } // namespace winrt::Microsoft::ReactNative::Composition::Experimental::implementation

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

@@ -45,6 +45,8 @@ struct MicrosoftCompositionContextHelper : MicrosoftCompositionContextHelperT<Mi
   static winrt::Microsoft::UI::Composition::DropShadow InnerDropShadow(IDropShadow shadow) noexcept;
   static winrt::Microsoft::UI::Composition::CompositionBrush InnerBrush(IBrush brush) noexcept;
   static winrt::Microsoft::UI::Composition::ICompositionSurface InnerSurface(IDrawingSurfaceBrush surface) noexcept;
+
+  static IBrush WrapBrush(const winrt::Microsoft::UI::Composition::CompositionBrush &brush) noexcept;
 };
 #endif
 

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

@@ -39,9 +39,9 @@ void ImageComponentView::WindowsImageResponseObserver::didReceiveProgress(float
 
 void ImageComponentView::WindowsImageResponseObserver::didReceiveImage(
     facebook::react::ImageResponse const &imageResponse) const {
-  auto sharedwicbmp = std::static_pointer_cast<winrt::com_ptr<IWICBitmap>>(imageResponse.getImage());
+  auto imageResponseImage = std::static_pointer_cast<ImageResponseImage>(imageResponse.getImage());
   m_image->m_reactContext.UIDispatcher().Post(
-      [wicbmp = *sharedwicbmp, image = m_image]() { image->didReceiveImage(wicbmp); });
+      [imageResponseImage, image = m_image]() { image->didReceiveImage(imageResponseImage); });
 }
 
 void ImageComponentView::WindowsImageResponseObserver::didReceiveFailure() const {
@@ -83,7 +83,7 @@ void ImageComponentView::ImageLoadStart() noexcept {
   }
 }
 
-void ImageComponentView::didReceiveImage(const winrt::com_ptr<IWICBitmap> &wicbmp) noexcept {
+void ImageComponentView::didReceiveImage(const std::shared_ptr<ImageResponseImage> &imageResponseImage) noexcept {
   // TODO check for recycled?
 
   auto imageEventEmitter = std::static_pointer_cast<facebook::react::ImageEventEmitter const>(m_eventEmitter);
@@ -99,7 +99,7 @@ void ImageComponentView::didReceiveImage(const winrt::com_ptr<IWICBitmap> &wicbm
   assert(uiDispatcher.HasThreadAccess());
 #endif
 
-  m_wicbmp = wicbmp;
+  m_imageResponseImage = imageResponseImage;
   ensureDrawingSurface();
 }
 
@@ -198,7 +198,8 @@ void ImageComponentView::updateLayoutMetrics(
 }
 
 void ImageComponentView::OnRenderingDeviceLost() noexcept {
-  DrawImage();
+  m_drawingSurface = nullptr;
+  ensureDrawingSurface();
 }
 
 bool ImageComponentView::themeEffectsImage() const noexcept {
@@ -207,7 +208,8 @@ bool ImageComponentView::themeEffectsImage() const noexcept {
 
 void ImageComponentView::onThemeChanged() noexcept {
   if (themeEffectsImage()) {
-    DrawImage();
+    m_drawingSurface = nullptr;
+    ensureDrawingSurface();
   }
   Super::onThemeChanged();
 }
@@ -215,10 +217,17 @@ void ImageComponentView::onThemeChanged() noexcept {
 void ImageComponentView::ensureDrawingSurface() noexcept {
   assert(m_reactContext.UIDispatcher().HasThreadAccess());
 
-  UINT width, height;
-  winrt::check_hresult(m_wicbmp->GetSize(&width, &height));
+  if (!m_imageResponseImage) {
+    m_visual.Brush(nullptr);
+    return;
+  }
+
+  UINT width = 0, height = 0;
+  if (m_imageResponseImage->m_wicbmp) {
+    winrt::check_hresult(m_imageResponseImage->m_wicbmp->GetSize(&width, &height));
+  }
 
-  if (!m_drawingSurface && m_wicbmp) {
+  if (!m_drawingSurface && m_imageResponseImage->m_wicbmp) {
     winrt::Windows::Foundation::Size drawingSurfaceSize{static_cast<float>(width), static_cast<float>(height)};
 
     const auto imageProps = std::static_pointer_cast<const facebook::react::ImageProps>(m_props);
@@ -273,6 +282,8 @@ void ImageComponentView::ensureDrawingSurface() noexcept {
     }
 
     m_visual.Brush(m_drawingSurface);
+  } else if (m_imageResponseImage->m_brushFactory) {
+    m_visual.Brush(m_imageResponseImage->m_brushFactory(m_reactContext.Handle(), m_compContext));
   }
 }
 
@@ -286,7 +297,7 @@ void ImageComponentView::DrawImage() noexcept {
     return;
   }
 
-  if (!m_wicbmp) {
+  if (!m_imageResponseImage->m_wicbmp) {
     return;
   }
 
@@ -295,7 +306,8 @@ void ImageComponentView::DrawImage() noexcept {
   ::Microsoft::ReactNative::Composition::AutoDrawDrawingSurface autoDraw(m_drawingSurface, 1.0f, &offset);
   if (auto d2dDeviceContext = autoDraw.GetRenderTarget()) {
     winrt::com_ptr<ID2D1Bitmap1> bitmap;
-    winrt::check_hresult(d2dDeviceContext->CreateBitmapFromWicBitmap(m_wicbmp.get(), nullptr, bitmap.put()));
+    winrt::check_hresult(
+        d2dDeviceContext->CreateBitmapFromWicBitmap(m_imageResponseImage->m_wicbmp.get(), nullptr, bitmap.put()));
 
     d2dDeviceContext->Clear(D2D1::ColorF(D2D1::ColorF::Black, 0.0f));
     if (m_props->backgroundColor) {
@@ -311,7 +323,8 @@ void ImageComponentView::DrawImage() noexcept {
     if (useEffects) {
       winrt::com_ptr<ID2D1Effect> bitmapEffects;
       winrt::check_hresult(d2dDeviceContext->CreateEffect(CLSID_D2D1BitmapSource, bitmapEffects.put()));
-      winrt::check_hresult(bitmapEffects->SetValue(D2D1_BITMAPSOURCE_PROP_WIC_BITMAP_SOURCE, m_wicbmp.get()));
+      winrt::check_hresult(
+          bitmapEffects->SetValue(D2D1_BITMAPSOURCE_PROP_WIC_BITMAP_SOURCE, m_imageResponseImage->m_wicbmp.get()));
 
       if (imageProps->blurRadius > 0) {
         winrt::com_ptr<ID2D1Effect> gaussianBlurEffect;
@@ -360,7 +373,7 @@ void ImageComponentView::DrawImage() noexcept {
       }
     } else {
       UINT width, height;
-      winrt::check_hresult(m_wicbmp->GetSize(&width, &height));
+      winrt::check_hresult(m_imageResponseImage->m_wicbmp->GetSize(&width, &height));
 
       D2D1_RECT_F rect = D2D1::RectF(
           static_cast<float>(offset.x),

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

@@ -14,6 +14,7 @@
 #include <winrt/Windows.UI.Composition.h>
 #include "CompositionHelpers.h"
 #include "CompositionViewComponentView.h"
+#include "ImageResponseImage.h"
 
 #pragma warning(push)
 #pragma warning(disable : 4244 4305)
@@ -83,7 +84,7 @@ struct ImageComponentView : ImageComponentViewT<ImageComponentView, ComponentVie
 
   void ImageLoadStart() noexcept;
   void ImageLoaded() noexcept;
-  void didReceiveImage(const winrt::com_ptr<IWICBitmap> &wicbmp) noexcept;
+  void didReceiveImage(const std::shared_ptr<ImageResponseImage> &wicbmp) noexcept;
   void didReceiveFailureFromObserver() noexcept;
   void setStateAndResubscribeImageResponseObserver(
       facebook::react::ImageShadowNode::ConcreteState::Shared const &state) noexcept;
@@ -93,7 +94,7 @@ struct ImageComponentView : ImageComponentViewT<ImageComponentView, ComponentVie
 
   winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual m_visual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IDrawingSurfaceBrush m_drawingSurface;
-  winrt::com_ptr<IWICBitmap> m_wicbmp;
+  std::shared_ptr<ImageResponseImage> m_imageResponseImage;
   std::shared_ptr<WindowsImageResponseObserver> m_imageResponseObserver;
   facebook::react::ImageShadowNode::ConcreteState::Shared m_state;
 };

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

@@ -0,0 +1,17 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <wincodec.h>
+#include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
+
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
+
+struct ImageResponseImage {
+  winrt::com_ptr<IWICBitmap> m_wicbmp;
+  winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory m_brushFactory{nullptr};
+};
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "UriImageManager.h"
+
+#include "Composition.ImageSource.g.h"
+#include "Composition.UriImageManager.g.cpp"
+#include <ReactPropertyBag.h>
+
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
+
+struct ImageSource : ImageSourceT<ImageSource> {
+  ImageSource(const facebook::react::ImageSource &source)
+      : m_size({source.size.width, source.size.height}),
+        m_scale(source.scale),
+        m_uri(::Microsoft::ReactNative::UriTryCreate(winrt::to_hstring(source.uri))) {}
+
+  winrt::Windows::Foundation::Uri Uri() noexcept {
+    return m_uri;
+  }
+
+  winrt::Windows::Foundation::Size Size() noexcept {
+    return m_size;
+  }
+
+  float Scale() noexcept {
+    return m_scale;
+  }
+
+ private:
+  const winrt::Windows::Foundation::Uri m_uri;
+  const winrt::Windows::Foundation::Size m_size;
+  const float m_scale;
+};
+
+winrt::Microsoft::ReactNative::Composition::ImageSource MakeImageSource(
+    const facebook::react::ImageSource &source) noexcept {
+  return winrt::make<ImageSource>(source);
+}
+
+static const ReactPropertyId<ReactNonAbiValue<winrt::com_ptr<UriImageManager>>> &UriImageManagerPropertyId() noexcept {
+  static const ReactPropertyId<ReactNonAbiValue<winrt::com_ptr<UriImageManager>>> prop{
+      L"ReactNative", L"UriImageManager"};
+  return prop;
+}
+
+winrt::com_ptr<UriImageManager> UriImageManager::GetOrCreate(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept {
+  auto uriImageManager =
+      winrt::Microsoft::ReactNative::ReactPropertyBag(properties).GetOrCreate(UriImageManagerPropertyId(), []() {
+        return winrt::make_self<UriImageManager>();
+      });
+  return uriImageManager.Value();
+}
+
+void UriImageManager::AddUriImageProvider(
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &properties,
+    const IUriImageProvider &provider) {
+  if (!provider)
+    winrt::throw_hresult(E_INVALIDARG);
+  GetOrCreate(winrt::Microsoft::ReactNative::ReactPropertyBag(properties))->m_providers.push_back(provider);
+}
+
+IUriImageProvider UriImageManager::TryGetUriImageProvider(
+    const IReactContext &context,
+    winrt::Microsoft::ReactNative::Composition::ImageSource &source) noexcept {
+  auto uri = source.Uri();
+  if (!uri) {
+    return nullptr;
+  }
+
+  for (auto &provider : m_providers) {
+    if (provider.CanLoadImageUri(context, source.Uri())) {
+      return provider;
+    }
+  }
+
+  return nullptr;
+}
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+#include "Composition.UriImageManager.g.h"
+
+#include <ReactPropertyBag.h>
+#include <Utils/ImageUtils.h>
+#include <react/renderer/imagemanager/primitives.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
+
+struct UriImageManager : UriImageManagerT<UriImageManager> {
+  UriImageManager() = default;
+
+  static void AddUriImageProvider(
+      const winrt::Microsoft::ReactNative::IReactPropertyBag &properties,
+      const IUriImageProvider &provider);
+
+  static winrt::com_ptr<UriImageManager> GetOrCreate(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept;
+
+  IUriImageProvider TryGetUriImageProvider(
+      const IReactContext &context,
+      winrt::Microsoft::ReactNative::Composition::ImageSource &source) noexcept;
+
+ private:
+  std::vector<IUriImageProvider> m_providers;
+};
+
+winrt::Microsoft::ReactNative::Composition::ImageSource MakeImageSource(
+    const facebook::react::ImageSource &source) noexcept;
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation
+
+namespace winrt::Microsoft::ReactNative::Composition::factory_implementation {
+struct UriImageManager : UriImageManagerT<UriImageManager, implementation::UriImageManager> {};
+} // namespace winrt::Microsoft::ReactNative::Composition::factory_implementation

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

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "UriImageManager.h"
+
+#include "Composition.UriImageManager.g.cpp"
+
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
+
+void UriImageManager::AddUriImageProvider(
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &,
+    const IUriImageProvider &) {}
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -330,6 +330,9 @@ void FabricUIManager::initiateTransaction(facebook::react::MountingCoordinator::
 }
 
 void FabricUIManager::schedulerDidFinishTransaction(
+    const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {}
+
+void FabricUIManager::schedulerShouldRenderTransactions(
     const facebook::react::MountingCoordinator::Shared &mountingCoordinator) {
   // Should cache this locally
 

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -78,6 +78,8 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
   std::unordered_map<facebook::react::SurfaceId, SurfaceInfo> m_surfaceRegistry;
 
   // Inherited via SchedulerDelegate
+  virtual void schedulerShouldRenderTransactions(
+      const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
   virtual void schedulerDidFinishTransaction(
       const facebook::react::MountingCoordinator::Shared &mountingCoordinator) override;
   virtual void schedulerDidRequestPreliminaryViewAllocation(

package/Microsoft.ReactNative/Fabric/ImageManager.cpp

@@ -9,8 +9,9 @@
 namespace facebook {
 namespace react {
 
-ImageManager::ImageManager(ContextContainer::Shared const &) {
-  self_ = new Microsoft::ReactNative::WindowsImageManager();
+ImageManager::ImageManager(ContextContainer::Shared const &contextContainer) {
+  auto reactContext = *contextContainer->find<winrt::Microsoft::ReactNative::ReactContext>("MSRN.ReactContext");
+  self_ = new Microsoft::ReactNative::WindowsImageManager(reactContext);
 }
 
 ImageManager::~ImageManager() {

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -5,7 +5,11 @@
 
 #include "WindowsImageManager.h"
 
+#include <Fabric/Composition/CompositionContextHelper.h>
+#include <Fabric/Composition/ImageResponseImage.h>
+#include <Fabric/Composition/UriImageManager.h>
 #include <Utils/ImageUtils.h>
+#include <functional/functor.h>
 #include <shcore.h>
 #include <wincodec.h>
 
@@ -13,7 +17,11 @@ extern "C" HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT SDKVersion, IWICIma
 
 namespace Microsoft::ReactNative {
 
-WindowsImageManager::WindowsImageManager() {}
+WindowsImageManager::WindowsImageManager(winrt::Microsoft::ReactNative::ReactContext reactContext)
+    : m_reactContext(reactContext) {
+  m_uriImageManager = winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager::GetOrCreate(
+      reactContext.Properties());
+}
 
 winrt::com_ptr<IWICBitmapSource> wicBitmapSourceFromStream(
     const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept {
@@ -39,19 +47,12 @@ winrt::com_ptr<IWICBitmapSource> wicBitmapSourceFromStream(
   return decodedFrame;
 }
 
-void generateBitmap(
-    std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator> weakObserverCoordinator,
+std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage> generateBitmap(
     const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept {
-  auto observerCoordinator = weakObserverCoordinator.lock();
-  if (!observerCoordinator) {
-    return;
-  }
-
   winrt::com_ptr<IWICBitmapSource> decodedFrame = wicBitmapSourceFromStream(results);
 
   if (!decodedFrame) {
-    observerCoordinator->nativeImageResponseFailed();
-    return;
+    return nullptr;
   }
 
   winrt::com_ptr<IWICImagingFactory> imagingFactory;
@@ -70,32 +71,18 @@ void generateBitmap(
   winrt::com_ptr<IWICBitmap> wicbmp;
   winrt::check_hresult(imagingFactory->CreateBitmapFromSource(converter.get(), WICBitmapCacheOnLoad, wicbmp.put()));
 
-  // ImageResponse saves a shared_ptr<void> for its data, so we need to wrap the com_ptr in a shared_ptr...
-  auto sharedwicbmp = std::make_shared<winrt::com_ptr<IWICBitmap>>(wicbmp);
-
-  observerCoordinator->nativeImageResponseComplete(facebook::react::ImageResponse(sharedwicbmp, nullptr /*metadata*/));
+  auto image = std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
+  image->m_wicbmp = wicbmp;
+  return image;
 }
 
-facebook::react::ImageRequest WindowsImageManager::requestImage(
-    const facebook::react::ImageSource &imageSource,
-    facebook::react::SurfaceId surfaceId) const {
-  auto imageRequest = facebook::react::ImageRequest(imageSource, nullptr, {});
-
-  auto weakObserverCoordinator = (std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator>)
-                                     imageRequest.getSharedObserverCoordinator();
-
-  ReactImageSource source;
-  source.uri = imageSource.uri;
-  source.height = imageSource.size.height;
-  source.width = imageSource.size.width;
-  source.sourceType = ImageSourceType::Download;
-
-  auto task = GetImageStreamAsync(source);
-
-  // TODO progress? - Can we register for progress off the download task?
-  // observerCoordinator->nativeImageResponseProgress((float)progress / (float)total);
-
-  task.Completed([weakObserverCoordinator](auto asyncOp, auto status) {
+template <typename T>
+void ProcessImageRequestTask(
+    std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator> &weakObserverCoordinator,
+    const winrt::Windows::Foundation::IAsyncOperation<T> &task,
+    Mso::Functor<std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>(
+        const T &result)> &&onSuccess) {
+  task.Completed([weakObserverCoordinator, onSuccess = std::move(onSuccess)](auto asyncOp, auto status) {
     auto observerCoordinator = weakObserverCoordinator.lock();
     if (!observerCoordinator) {
       return;
@@ -103,7 +90,12 @@ facebook::react::ImageRequest WindowsImageManager::requestImage(
 
     switch (status) {
       case winrt::Windows::Foundation::AsyncStatus::Completed: {
-        generateBitmap(weakObserverCoordinator, asyncOp.GetResults());
+        auto imageResponseImage = onSuccess(asyncOp.GetResults());
+        if (imageResponseImage)
+          observerCoordinator->nativeImageResponseComplete(
+              facebook::react::ImageResponse(imageResponseImage, nullptr /*metadata*/));
+        else
+          observerCoordinator->nativeImageResponseFailed();
         break;
       }
       case winrt::Windows::Foundation::AsyncStatus::Canceled: {
@@ -118,6 +110,81 @@ facebook::react::ImageRequest WindowsImageManager::requestImage(
       }
     }
   });
+}
+
+facebook::react::ImageRequest WindowsImageManager::requestImage(
+    const facebook::react::ImageSource &imageSource,
+    facebook::react::SurfaceId surfaceId) const {
+  auto imageRequest = facebook::react::ImageRequest(imageSource, nullptr, {});
+
+  auto weakObserverCoordinator = (std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator>)
+                                     imageRequest.getSharedObserverCoordinator();
+
+  auto rnImageSource = winrt::Microsoft::ReactNative::Composition::implementation::MakeImageSource(imageSource);
+  auto provider = m_uriImageManager->TryGetUriImageProvider(m_reactContext.Handle(), rnImageSource);
+
+  if (auto bProvider = provider.try_as<winrt::Microsoft::ReactNative::Composition::IUriBrushProvider>()) {
+    ProcessImageRequestTask<winrt::Microsoft::ReactNative::Composition::UriBrushFactory>(
+        weakObserverCoordinator,
+        bProvider.GetSourceAsync(m_reactContext.Handle(), rnImageSource),
+        [](const winrt::Microsoft::ReactNative::Composition::UriBrushFactory &factory) noexcept {
+          auto image =
+              std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
+
+          // Wrap the UriBrushFactory to provide the internal CompositionContext types
+          image->m_brushFactory =
+              [factory](
+                  const winrt::Microsoft::ReactNative::IReactContext &context,
+                  const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext
+                      &compositionContext) {
+                auto compositor = winrt::Microsoft::ReactNative::Composition::Experimental::
+                    MicrosoftCompositionContextHelper::InnerCompositor(compositionContext);
+                auto brush = factory(context, compositor);
+                return winrt::Microsoft::ReactNative::Composition::Experimental::implementation::
+                    MicrosoftCompositionContextHelper::WrapBrush(brush);
+              };
+          return image;
+        });
+
+    return imageRequest;
+  }
+
+  if (auto brushProvider =
+          provider.try_as<winrt::Microsoft::ReactNative::Composition::Experimental::IUriBrushProvider>()) {
+    ProcessImageRequestTask<winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory>(
+        weakObserverCoordinator,
+        brushProvider.GetSourceAsync(m_reactContext.Handle(), rnImageSource),
+        [](const winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory &factory) noexcept {
+          auto image =
+              std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
+          image->m_brushFactory = factory;
+          return image;
+        });
+
+    return imageRequest;
+  };
+
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> task;
+  if (auto imageStreamProvider =
+          provider.try_as<winrt::Microsoft::ReactNative::Composition::IUriImageStreamProvider>()) {
+    task = imageStreamProvider.GetSourceAsync(m_reactContext.Handle(), rnImageSource);
+  } else {
+    ReactImageSource source;
+    source.uri = imageSource.uri;
+    source.height = imageSource.size.height;
+    source.width = imageSource.size.width;
+    source.sourceType = ImageSourceType::Download;
+
+    task = GetImageStreamAsync(source);
+  }
+
+  // TODO progress? - Can we register for progress off the download task?
+  // observerCoordinator->nativeImageResponseProgress((float)progress / (float)total);
+
+  ProcessImageRequestTask<winrt::Windows::Storage::Streams::IRandomAccessStream>(
+      weakObserverCoordinator, task, [](const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) {
+        return generateBitmap(stream);
+      });
 
   return imageRequest;
 }

package/Microsoft.ReactNative/Fabric/WindowsImageManager.h

@@ -5,16 +5,21 @@
 
 #include <react/renderer/imagemanager/ImageRequest.h>
 
+#include <Fabric/Composition/UriImageManager.h>
 #include <ReactContext.h>
 
 namespace Microsoft::ReactNative {
 
 struct WindowsImageManager {
-  WindowsImageManager();
+  WindowsImageManager(winrt::Microsoft::ReactNative::ReactContext reactContext);
 
   facebook::react::ImageRequest requestImage(
       const facebook::react::ImageSource &imageSource,
       facebook::react::SurfaceId surfaceId) const;
+
+ private:
+  winrt::Microsoft::ReactNative::ReactContext m_reactContext;
+  winrt::com_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> m_uriImageManager;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/UriImageManager.idl

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import "IReactContext.idl";
+import "CompositionSwitcher.idl";
+
+#include "DocString.h"
+
+namespace Microsoft.ReactNative.Composition
+{
+  [default_interface]
+  [webhosthidden]
+  [experimental]
+  DOC_STRING(
+    "Provides information about an image source requested by the application.")
+  runtimeclass ImageSource
+  {
+    Windows.Foundation.Uri Uri { get; };
+    Windows.Foundation.Size Size { get; };
+    Single Scale { get; };
+  };
+
+
+  [webhosthidden]
+  [experimental]
+  interface IUriImageProvider
+  {
+    DOC_STRING(
+      "This should return true if this provider will provide an image for the provided uri.")
+    Boolean CanLoadImageUri(Microsoft.ReactNative.IReactContext context, Windows.Foundation.Uri uri);
+  }
+
+  [webhosthidden]
+  [experimental]
+    DOC_STRING(
+      "This allows applications to provide their own image caching / storage pipelines. Or to generate images on the fly based on uri.")
+  interface IUriImageStreamProvider requires IUriImageProvider
+  {
+    DOC_STRING(
+      "Returns a stream of an image file that can be decoded by Windows Imaging Component - https://learn.microsoft.com/en-us/windows/win32/api/_wic/ ")
+    Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream> GetSourceAsync(Microsoft.ReactNative.IReactContext context, ImageSource imageSource);
+  }
+
+ 
+  [webhosthidden]
+  [experimental]
+  delegate Microsoft.UI.Composition.CompositionBrush UriBrushFactory(Microsoft.ReactNative.IReactContext reactContext, Microsoft.UI.Composition.Compositor compositor);
+
+  [webhosthidden]
+  [experimental]
+  DOC_STRING(
+    "This allows applications to provide their own image rendering pipeline. Or to generate graphics on the fly based on uri.")
+  interface IUriBrushProvider requires IUriImageProvider
+  {
+  DOC_STRING(
+    "This allows applications to provide their own image rendering pipeline. Or to generate graphics on the fly based on uri.")
+    Windows.Foundation.IAsyncOperation<UriBrushFactory> GetSourceAsync(Microsoft.ReactNative.IReactContext context, Microsoft.ReactNative.Composition.ImageSource imageSource);
+  }
+
+  namespace Experimental {
+
+  [webhosthidden]
+  [experimental]
+  delegate Microsoft.ReactNative.Composition.Experimental.IBrush UriBrushFactory(Microsoft.ReactNative.IReactContext reactContext, Microsoft.ReactNative.Composition.Experimental.ICompositionContext compositionContext);
+
+  [webhosthidden]
+  [experimental]
+  DOC_STRING(
+    "This allows applications to provide their own image rendering pipeline. Or to generate graphics on the fly based on uri.")
+  interface IUriBrushProvider requires Microsoft.ReactNative.Composition.IUriImageProvider
+  {
+    Windows.Foundation.IAsyncOperation<UriBrushFactory> GetSourceAsync(Microsoft.ReactNative.IReactContext context, Microsoft.ReactNative.Composition.ImageSource imageSource);
+  }
+  }
+
+  [default_interface]
+  [webhosthidden]
+  [experimental]
+  DOC_STRING(
+    "Ability to load images using custom Uri protocol handlers.  The provider should implement @IUriImageStreamProvider or @Experimental.IUriBrushProvider")
+  runtimeclass UriImageManager
+  {
+    static void AddUriImageProvider(Microsoft.ReactNative.IReactPropertyBag properties, IUriImageProvider provider);
+  }
+} // namespace Microsoft.ReactNative.Composition

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.74.1</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.74.2</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>74</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>1</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>2</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>7fd1f4439e2e1f109d4d2b20a97073f14bcbf504</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>b422f06e2b5ac1bd5fb7cffbc9f247024452120a</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Shared.vcxitems

@@ -84,6 +84,16 @@
       <DependentUpon>$(ReactNativeWindowsDir)Microsoft.ReactNative\CompositionUIService.idl</DependentUpon>
       <SubType>Code</SubType>
     </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\UriImageManager.cpp">
+      <ExcludedFromBuild Condition="'$(UseFabric)' != 'true'">true</ExcludedFromBuild>
+      <DependentUpon>$(ReactNativeWindowsDir)Microsoft.ReactNative\UriImageManager.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\UriImageManager_emptyimpl.cpp">
+      <ExcludedFromBuild Condition="'$(UseFabric)' == 'true' OR '$(IncludeFabricInterface)' != 'true'">true</ExcludedFromBuild>
+      <DependentUpon>$(ReactNativeWindowsDir)Microsoft.ReactNative\UriImageManager.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\CompositionViewComponentView.cpp">
       <ExcludedFromBuild Condition="'$(UseFabric)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>
@@ -639,6 +649,7 @@
     <Midl Condition="'$(UseFabric)' == 'true' OR '$(IncludeFabricInterface)' == 'true'" Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\IReactPackageBuilderFabric.idl" />
     <Midl Condition="'$(UseFabric)' == 'true' OR '$(IncludeFabricInterface)' == 'true'" Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\IReactViewComponentBuilder.idl" />
     <Midl Condition="'$(UseFabric)' == 'true' OR '$(IncludeFabricInterface)' == 'true'" Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\Theme.idl" />
+    <Midl Condition="'$(UseFabric)' == 'true' OR '$(IncludeFabricInterface)' == 'true'" Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\UriImageManager.idl" />
     <Midl Condition="'$(UseFabric)' == 'true' OR '$(IncludeFabricInterface)' == 'true'" Include="$(ReactNativeWindowsDir)Microsoft.ReactNative\ViewProps.idl" />
   </ItemGroup>
   <ItemGroup>

package/codegen/NativeReactNativeFeatureFlagsSpec.g.h

@@ -17,15 +17,17 @@ namespace Microsoft::ReactNativeSpecs {
 struct ReactNativeFeatureFlagsSpec : winrt::Microsoft::ReactNative::TurboModuleSpec {
   static constexpr auto methods = std::tuple{
       SyncMethod<bool() noexcept>{0, L"commonTestFlag"},
-      SyncMethod<bool() noexcept>{1, L"enableBackgroundExecutor"},
-      SyncMethod<bool() noexcept>{2, L"useModernRuntimeScheduler"},
-      SyncMethod<bool() noexcept>{3, L"enableMicrotasks"},
-      SyncMethod<bool() noexcept>{4, L"batchRenderingUpdatesInEventLoop"},
-      SyncMethod<bool() noexcept>{5, L"enableSpannableBuildingUnification"},
-      SyncMethod<bool() noexcept>{6, L"enableCustomDrawOrderFabric"},
-      SyncMethod<bool() noexcept>{7, L"enableFixForClippedSubviewsCrash"},
-      SyncMethod<bool() noexcept>{8, L"inspectorEnableCxxInspectorPackagerConnection"},
-      SyncMethod<bool() noexcept>{9, L"inspectorEnableModernCDPRegistry"},
+      SyncMethod<bool() noexcept>{1, L"androidEnablePendingFabricTransactions"},
+      SyncMethod<bool() noexcept>{2, L"batchRenderingUpdatesInEventLoop"},
+      SyncMethod<bool() noexcept>{3, L"destroyFabricSurfacesInReactInstanceManager"},
+      SyncMethod<bool() noexcept>{4, L"enableBackgroundExecutor"},
+      SyncMethod<bool() noexcept>{5, L"useModernRuntimeScheduler"},
+      SyncMethod<bool() noexcept>{6, L"enableMicrotasks"},
+      SyncMethod<bool() noexcept>{7, L"enableSpannableBuildingUnification"},
+      SyncMethod<bool() noexcept>{8, L"enableCustomDrawOrderFabric"},
+      SyncMethod<bool() noexcept>{9, L"enableFixForClippedSubviewsCrash"},
+      SyncMethod<bool() noexcept>{10, L"inspectorEnableCxxInspectorPackagerConnection"},
+      SyncMethod<bool() noexcept>{11, L"inspectorEnableModernCDPRegistry"},
   };
 
   template <class TModule>
@@ -39,46 +41,56 @@ struct ReactNativeFeatureFlagsSpec : winrt::Microsoft::ReactNative::TurboModuleS
           "    REACT_SYNC_METHOD(commonTestFlag) static bool commonTestFlag() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
           1,
+          "androidEnablePendingFabricTransactions",
+          "    REACT_SYNC_METHOD(androidEnablePendingFabricTransactions) bool androidEnablePendingFabricTransactions() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(androidEnablePendingFabricTransactions) static bool androidEnablePendingFabricTransactions() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          2,
+          "batchRenderingUpdatesInEventLoop",
+          "    REACT_SYNC_METHOD(batchRenderingUpdatesInEventLoop) bool batchRenderingUpdatesInEventLoop() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(batchRenderingUpdatesInEventLoop) static bool batchRenderingUpdatesInEventLoop() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          3,
+          "destroyFabricSurfacesInReactInstanceManager",
+          "    REACT_SYNC_METHOD(destroyFabricSurfacesInReactInstanceManager) bool destroyFabricSurfacesInReactInstanceManager() noexcept { /* implementation */ }\n"
+          "    REACT_SYNC_METHOD(destroyFabricSurfacesInReactInstanceManager) static bool destroyFabricSurfacesInReactInstanceManager() noexcept { /* implementation */ }\n");
+    REACT_SHOW_METHOD_SPEC_ERRORS(
+          4,
           "enableBackgroundExecutor",
           "    REACT_SYNC_METHOD(enableBackgroundExecutor) bool enableBackgroundExecutor() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(enableBackgroundExecutor) static bool enableBackgroundExecutor() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          2,
+          5,
           "useModernRuntimeScheduler",
           "    REACT_SYNC_METHOD(useModernRuntimeScheduler) bool useModernRuntimeScheduler() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(useModernRuntimeScheduler) static bool useModernRuntimeScheduler() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          3,
+          6,
           "enableMicrotasks",
           "    REACT_SYNC_METHOD(enableMicrotasks) bool enableMicrotasks() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(enableMicrotasks) static bool enableMicrotasks() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          4,
-          "batchRenderingUpdatesInEventLoop",
-          "    REACT_SYNC_METHOD(batchRenderingUpdatesInEventLoop) bool batchRenderingUpdatesInEventLoop() noexcept { /* implementation */ }\n"
-          "    REACT_SYNC_METHOD(batchRenderingUpdatesInEventLoop) static bool batchRenderingUpdatesInEventLoop() noexcept { /* implementation */ }\n");
-    REACT_SHOW_METHOD_SPEC_ERRORS(
-          5,
+          7,
           "enableSpannableBuildingUnification",
           "    REACT_SYNC_METHOD(enableSpannableBuildingUnification) bool enableSpannableBuildingUnification() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(enableSpannableBuildingUnification) static bool enableSpannableBuildingUnification() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          6,
+          8,
           "enableCustomDrawOrderFabric",
           "    REACT_SYNC_METHOD(enableCustomDrawOrderFabric) bool enableCustomDrawOrderFabric() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(enableCustomDrawOrderFabric) static bool enableCustomDrawOrderFabric() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          7,
+          9,
           "enableFixForClippedSubviewsCrash",
           "    REACT_SYNC_METHOD(enableFixForClippedSubviewsCrash) bool enableFixForClippedSubviewsCrash() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(enableFixForClippedSubviewsCrash) static bool enableFixForClippedSubviewsCrash() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          8,
+          10,
           "inspectorEnableCxxInspectorPackagerConnection",
           "    REACT_SYNC_METHOD(inspectorEnableCxxInspectorPackagerConnection) bool inspectorEnableCxxInspectorPackagerConnection() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(inspectorEnableCxxInspectorPackagerConnection) static bool inspectorEnableCxxInspectorPackagerConnection() noexcept { /* implementation */ }\n");
     REACT_SHOW_METHOD_SPEC_ERRORS(
-          9,
+          11,
           "inspectorEnableModernCDPRegistry",
           "    REACT_SYNC_METHOD(inspectorEnableModernCDPRegistry) bool inspectorEnableModernCDPRegistry() noexcept { /* implementation */ }\n"
           "    REACT_SYNC_METHOD(inspectorEnableModernCDPRegistry) static bool inspectorEnableModernCDPRegistry() noexcept { /* implementation */ }\n");

package/codegen/rnwcoreJSI-generated.cpp

@@ -16,6 +16,21 @@ static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_commonT
     rt
   );
 }
+static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_androidEnablePendingFabricTransactions(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeReactNativeFeatureFlagsCxxSpecJSI *>(&turboModule)->androidEnablePendingFabricTransactions(
+    rt
+  );
+}
+static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_batchRenderingUpdatesInEventLoop(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeReactNativeFeatureFlagsCxxSpecJSI *>(&turboModule)->batchRenderingUpdatesInEventLoop(
+    rt
+  );
+}
+static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_destroyFabricSurfacesInReactInstanceManager(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeReactNativeFeatureFlagsCxxSpecJSI *>(&turboModule)->destroyFabricSurfacesInReactInstanceManager(
+    rt
+  );
+}
 static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableBackgroundExecutor(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<NativeReactNativeFeatureFlagsCxxSpecJSI *>(&turboModule)->enableBackgroundExecutor(
     rt
@@ -31,11 +46,6 @@ static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableM
     rt
   );
 }
-static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_batchRenderingUpdatesInEventLoop(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
-  return static_cast<NativeReactNativeFeatureFlagsCxxSpecJSI *>(&turboModule)->batchRenderingUpdatesInEventLoop(
-    rt
-  );
-}
 static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableSpannableBuildingUnification(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
   return static_cast<NativeReactNativeFeatureFlagsCxxSpecJSI *>(&turboModule)->enableSpannableBuildingUnification(
     rt
@@ -65,10 +75,12 @@ static jsi::Value __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_inspect
 NativeReactNativeFeatureFlagsCxxSpecJSI::NativeReactNativeFeatureFlagsCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("NativeReactNativeFeatureFlagsCxx", jsInvoker) {
   methodMap_["commonTestFlag"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_commonTestFlag};
+  methodMap_["androidEnablePendingFabricTransactions"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_androidEnablePendingFabricTransactions};
+  methodMap_["batchRenderingUpdatesInEventLoop"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_batchRenderingUpdatesInEventLoop};
+  methodMap_["destroyFabricSurfacesInReactInstanceManager"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_destroyFabricSurfacesInReactInstanceManager};
   methodMap_["enableBackgroundExecutor"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableBackgroundExecutor};
   methodMap_["useModernRuntimeScheduler"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_useModernRuntimeScheduler};
   methodMap_["enableMicrotasks"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableMicrotasks};
-  methodMap_["batchRenderingUpdatesInEventLoop"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_batchRenderingUpdatesInEventLoop};
   methodMap_["enableSpannableBuildingUnification"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableSpannableBuildingUnification};
   methodMap_["enableCustomDrawOrderFabric"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableCustomDrawOrderFabric};
   methodMap_["enableFixForClippedSubviewsCrash"] = MethodMetadata {0, __hostFunction_NativeReactNativeFeatureFlagsCxxSpecJSI_enableFixForClippedSubviewsCrash};

package/codegen/rnwcoreJSI.h

@@ -21,10 +21,12 @@ protected:
 
 public:
   virtual bool commonTestFlag(jsi::Runtime &rt) = 0;
+  virtual bool androidEnablePendingFabricTransactions(jsi::Runtime &rt) = 0;
+  virtual bool batchRenderingUpdatesInEventLoop(jsi::Runtime &rt) = 0;
+  virtual bool destroyFabricSurfacesInReactInstanceManager(jsi::Runtime &rt) = 0;
   virtual bool enableBackgroundExecutor(jsi::Runtime &rt) = 0;
   virtual bool useModernRuntimeScheduler(jsi::Runtime &rt) = 0;
   virtual bool enableMicrotasks(jsi::Runtime &rt) = 0;
-  virtual bool batchRenderingUpdatesInEventLoop(jsi::Runtime &rt) = 0;
   virtual bool enableSpannableBuildingUnification(jsi::Runtime &rt) = 0;
   virtual bool enableCustomDrawOrderFabric(jsi::Runtime &rt) = 0;
   virtual bool enableFixForClippedSubviewsCrash(jsi::Runtime &rt) = 0;
@@ -61,6 +63,30 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::commonTestFlag, jsInvoker_, instance_);
     }
+    bool androidEnablePendingFabricTransactions(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::androidEnablePendingFabricTransactions) == 1,
+          "Expected androidEnablePendingFabricTransactions(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::androidEnablePendingFabricTransactions, jsInvoker_, instance_);
+    }
+    bool batchRenderingUpdatesInEventLoop(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::batchRenderingUpdatesInEventLoop) == 1,
+          "Expected batchRenderingUpdatesInEventLoop(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::batchRenderingUpdatesInEventLoop, jsInvoker_, instance_);
+    }
+    bool destroyFabricSurfacesInReactInstanceManager(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::destroyFabricSurfacesInReactInstanceManager) == 1,
+          "Expected destroyFabricSurfacesInReactInstanceManager(...) to have 1 parameters");
+
+      return bridging::callFromJs<bool>(
+          rt, &T::destroyFabricSurfacesInReactInstanceManager, jsInvoker_, instance_);
+    }
     bool enableBackgroundExecutor(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::enableBackgroundExecutor) == 1,
@@ -85,14 +111,6 @@ private:
       return bridging::callFromJs<bool>(
           rt, &T::enableMicrotasks, jsInvoker_, instance_);
     }
-    bool batchRenderingUpdatesInEventLoop(jsi::Runtime &rt) override {
-      static_assert(
-          bridging::getParameterCount(&T::batchRenderingUpdatesInEventLoop) == 1,
-          "Expected batchRenderingUpdatesInEventLoop(...) to have 1 parameters");
-
-      return bridging::callFromJs<bool>(
-          rt, &T::batchRenderingUpdatesInEventLoop, jsInvoker_, instance_);
-    }
     bool enableSpannableBuildingUnification(jsi::Runtime &rt) override {
       static_assert(
           bridging::getParameterCount(&T::enableSpannableBuildingUnification) == 1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.74.1",
+  "version": "0.74.2",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -23,18 +23,18 @@
   "dependencies": {
     "@babel/runtime": "^7.0.0",
     "@jest/create-cache-key-function": "^29.6.3",
-    "@react-native-community/cli": "13.6.4",
-    "@react-native-community/cli-platform-android": "13.6.4",
-    "@react-native-community/cli-platform-ios": "13.6.4",
+    "@react-native-community/cli": "13.6.6",
+    "@react-native-community/cli-platform-android": "13.6.6",
+    "@react-native-community/cli-platform-ios": "13.6.6",
     "@react-native-windows/cli": "0.74.0",
     "@react-native/assets": "1.0.0",
-    "@react-native/assets-registry": "0.74.81",
-    "@react-native/codegen": "0.74.81",
-    "@react-native/community-cli-plugin": "0.74.81",
-    "@react-native/gradle-plugin": "0.74.81",
-    "@react-native/js-polyfills": "0.74.81",
-    "@react-native/normalize-colors": "0.74.81",
-    "@react-native/virtualized-lists": "0.74.81",
+    "@react-native/assets-registry": "0.74.83",
+    "@react-native/codegen": "0.74.83",
+    "@react-native/community-cli-plugin": "0.74.83",
+    "@react-native/gradle-plugin": "0.74.83",
+    "@react-native/js-polyfills": "0.74.83",
+    "@react-native/normalize-colors": "0.74.83",
+    "@react-native/virtualized-lists": "0.74.83",
     "abort-controller": "^3.0.0",
     "anser": "^1.4.9",
     "ansi-regex": "^5.0.0",
@@ -65,7 +65,7 @@
   },
   "devDependencies": {
     "@react-native-windows/codegen": "0.74.0",
-    "@react-native/metro-config": "0.74.81",
+    "@react-native/metro-config": "0.74.83",
     "@rnw-scripts/babel-react-native-config": "0.0.0",
     "@rnw-scripts/eslint-config": "1.2.9",
     "@rnw-scripts/jest-out-of-tree-snapshot-resolver": "^1.1.13",
@@ -81,7 +81,7 @@
     "just-scripts": "^1.3.3",
     "prettier": "2.8.8",
     "react": "18.2.0",
-    "react-native": "0.74.0",
+    "react-native": "0.74.1",
     "react-native-platform-override": "^1.9.25",
     "react-refresh": "^0.14.0",
     "typescript": "5.0.4"

package/src/private/featureflags/NativeReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<8509d5ee87efb5aa8da7efcd2085d0a2>>
+ * @generated SignedSource<<8f82962343a5146622f36c2de071ff6a>>
  * @flow strict-local
  */
 
@@ -24,10 +24,12 @@ import * as TurboModuleRegistry from '../../../Libraries/TurboModule/TurboModule
 
 export interface Spec extends TurboModule {
   +commonTestFlag?: () => boolean;
+  +androidEnablePendingFabricTransactions?: () => boolean;
+  +batchRenderingUpdatesInEventLoop?: () => boolean;
+  +destroyFabricSurfacesInReactInstanceManager?: () => boolean;
   +enableBackgroundExecutor?: () => boolean;
   +useModernRuntimeScheduler?: () => boolean;
   +enableMicrotasks?: () => boolean;
-  +batchRenderingUpdatesInEventLoop?: () => boolean;
   +enableSpannableBuildingUnification?: () => boolean;
   +enableCustomDrawOrderFabric?: () => boolean;
   +enableFixForClippedSubviewsCrash?: () => boolean;

package/src/private/featureflags/ReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<7c83d5613c3be517efe48378e6356e79>>
+ * @generated SignedSource<<b7ebc6e4360a4b7733335f283300a4bb>>
  * @flow strict-local
  */
 
@@ -41,10 +41,12 @@ export type ReactNativeFeatureFlagsJsOnlyOverrides = Partial<ReactNativeFeatureF
 export type ReactNativeFeatureFlags = {
   ...ReactNativeFeatureFlagsJsOnly,
   commonTestFlag: Getter<boolean>,
+  androidEnablePendingFabricTransactions: Getter<boolean>,
+  batchRenderingUpdatesInEventLoop: Getter<boolean>,
+  destroyFabricSurfacesInReactInstanceManager: Getter<boolean>,
   enableBackgroundExecutor: Getter<boolean>,
   useModernRuntimeScheduler: Getter<boolean>,
   enableMicrotasks: Getter<boolean>,
-  batchRenderingUpdatesInEventLoop: Getter<boolean>,
   enableSpannableBuildingUnification: Getter<boolean>,
   enableCustomDrawOrderFabric: Getter<boolean>,
   enableFixForClippedSubviewsCrash: Getter<boolean>,
@@ -96,6 +98,18 @@ export const shouldUseRemoveClippedSubviewsAsDefaultOnIOS: Getter<boolean> = cre
  * Common flag for testing. Do NOT modify.
  */
 export const commonTestFlag: Getter<boolean> = createNativeFlagGetter('commonTestFlag', false);
+/**
+ * To be used with batchRenderingUpdatesInEventLoop. When enbled, the Android mounting layer will concatenate pending transactions to ensure they're applied atomatically
+ */
+export const androidEnablePendingFabricTransactions: Getter<boolean> = createNativeFlagGetter('androidEnablePendingFabricTransactions', false);
+/**
+ * When enabled, the RuntimeScheduler processing the event loop will batch all rendering updates and dispatch them together at the end of each iteration of the loop.
+ */
+export const batchRenderingUpdatesInEventLoop: Getter<boolean> = createNativeFlagGetter('batchRenderingUpdatesInEventLoop', false);
+/**
+ * When enabled, ReactInstanceManager will clean up Fabric surfaces on destroy().
+ */
+export const destroyFabricSurfacesInReactInstanceManager: Getter<boolean> = createNativeFlagGetter('destroyFabricSurfacesInReactInstanceManager', false);
 /**
  * Enables the use of a background executor to compute layout and commit updates on Fabric (this system is deprecated and should not be used).
  */
@@ -108,10 +122,6 @@ export const useModernRuntimeScheduler: Getter<boolean> = createNativeFlagGetter
  * Enables the use of microtasks in Hermes (scheduling) and RuntimeScheduler (execution).
  */
 export const enableMicrotasks: Getter<boolean> = createNativeFlagGetter('enableMicrotasks', false);
-/**
- * When enabled, the RuntimeScheduler processing the event loop will batch all rendering updates and dispatch them together at the end of each iteration of the loop.
- */
-export const batchRenderingUpdatesInEventLoop: Getter<boolean> = createNativeFlagGetter('batchRenderingUpdatesInEventLoop', false);
 /**
  * Uses new, deduplicated logic for constructing Android Spannables from text fragments
  */