react-native-windows 0.74.1 → 0.74.3

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::Get(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;
+  std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> m_uriImageManager;
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/IReactPackageBuilderFabric.idl

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import "IReactViewComponentBuilder.idl";
+import "UriImageManager.idl";
 
 #include "DocString.h"
 
@@ -18,6 +19,10 @@ namespace Microsoft.ReactNative
   {
     DOC_STRING("Registers a custom native view component.")
     void AddViewComponent(String componentName, ReactViewComponentProvider componentProvider);
+
+    DOC_STRING(
+      "Ability to load images using custom Uri protocol handlers. The provider should implement @Composition.IUriImageStreamProvider or @Composition.Experimental.IUriBrushProvider.")
+    void AddUriImageProvider(Microsoft.ReactNative.Composition.IUriImageProvider provider);
   };
 
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/ReactHost/React.h

@@ -32,6 +32,10 @@
 #include <ViewManagerProvider.h>
 #include <winrt/Microsoft.ReactNative.h>
 
+#ifdef USE_FABRIC
+#include <Fabric/Composition/UriImageManager.h>
+#endif
+
 namespace Mso::React {
 
 // Forward declarations
@@ -182,6 +186,9 @@ struct ReactOptions {
   std::shared_ptr<NativeModuleProvider2> ModuleProvider;
   std::shared_ptr<ViewManagerProvider2> ViewManagerProvider;
   std::shared_ptr<winrt::Microsoft::ReactNative::TurboModulesProvider> TurboModuleProvider;
+#ifdef USE_FABRIC
+  std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> UriImageManager;
+#endif
 
   //! Identity of the SDX. Must uniquely describe the SDX across the installed product.
   std::string Identity;

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -52,6 +52,7 @@
 #include "Unicode.h"
 
 #ifdef USE_FABRIC
+#include <Fabric/Composition/UriImageManager.h>
 #include <Fabric/FabricUIManagerModule.h>
 #include <Fabric/ReactNativeConfigProperties.h>
 #include <Fabric/WindowsComponentDescriptorRegistry.h>
@@ -570,6 +571,8 @@ void ReactInstanceWin::InitializeBridgeless() noexcept {
           });
 
   InitDevMenu();
+  winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager::Install(
+      ReactPropertyBag(m_reactContext->Properties()), m_options.UriImageManager);
 
   m_uiQueue->Post([this, weakThis = Mso::WeakPtr{this}]() noexcept {
     // Objects that must be created on the UI thread
@@ -726,6 +729,10 @@ void ReactInstanceWin::InitializeWithBridge() noexcept {
 #endif
 
   InitDevMenu();
+#ifdef USE_FABRIC
+  winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager::Install(
+      ReactPropertyBag(m_reactContext->Properties()), m_options.UriImageManager);
+#endif
 
   m_uiQueue->Post([this, weakThis = Mso::WeakPtr{this}]() noexcept {
     // Objects that must be created on the UI thread

package/Microsoft.ReactNative/ReactNativeHost.cpp

@@ -16,6 +16,7 @@
 
 #ifdef USE_FABRIC
 #include <Fabric/WindowsComponentDescriptorRegistry.h>
+#include <ReactPackageBuilder.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #endif
 
@@ -93,6 +94,8 @@ IAsyncAction ReactNativeHost::ReloadInstance() noexcept {
   auto turboModulesProvider = std::make_shared<TurboModulesProvider>();
 
 #ifdef USE_FABRIC
+  auto uriImageManager =
+      std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager>();
   auto componentregistry = std::make_shared<::Microsoft::ReactNative::WindowsComponentDescriptorRegistry>();
   auto componentDescriptorRegistry = std::make_shared<facebook::react::ComponentDescriptorProviderRegistry>();
 
@@ -108,6 +111,7 @@ IAsyncAction ReactNativeHost::ReloadInstance() noexcept {
       turboModulesProvider,
 #ifdef USE_FABRIC
       componentregistry,
+      uriImageManager,
 #endif
       m_instanceSettings.UseWebDebugger());
 
@@ -164,6 +168,10 @@ IAsyncAction ReactNativeHost::ReloadInstance() noexcept {
 #endif
   reactOptions.TurboModuleProvider = turboModulesProvider;
 
+#ifdef USE_FABRIC
+  reactOptions.UriImageManager = uriImageManager;
+#endif
+
   reactOptions.OnInstanceCreated = [](Mso::CntPtr<Mso::React::IReactContext> &&context) {
     auto notifications = context->Notifications();
     ReactInstanceSettings::RaiseInstanceCreated(

package/Microsoft.ReactNative/ReactPackageBuilder.cpp

@@ -22,6 +22,7 @@ ReactPackageBuilder::ReactPackageBuilder(
     std::shared_ptr<TurboModulesProvider> const &turboModulesProvider,
 #ifdef USE_FABRIC
     std::shared_ptr<::Microsoft::ReactNative::WindowsComponentDescriptorRegistry> const &componentRegistry,
+    std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> const &uriImageManager,
 #endif
     bool isWebDebugging) noexcept
     : m_modulesProvider{modulesProvider},
@@ -31,6 +32,7 @@ ReactPackageBuilder::ReactPackageBuilder(
       m_turboModulesProvider{turboModulesProvider},
 #ifdef USE_FABRIC
       m_componentRegistry{componentRegistry},
+      m_uriImageManager{uriImageManager},
 #endif
 
       m_isWebDebugging{isWebDebugging} {
@@ -63,5 +65,11 @@ void ReactPackageBuilder::AddViewComponent(
     ReactViewComponentProvider const &viewComponentProvider) noexcept {
   m_componentRegistry->Add(componentName, viewComponentProvider);
 }
+
+void ReactPackageBuilder::AddUriImageProvider(
+    const winrt::Microsoft::ReactNative::Composition::IUriImageProvider &provider) noexcept {
+  m_uriImageManager->AddUriImageProvider(provider);
+}
+
 #endif
 } // namespace winrt::Microsoft::ReactNative

package/Microsoft.ReactNative/ReactPackageBuilder.h

@@ -9,7 +9,9 @@
 #endif
 #include "winrt/Microsoft.ReactNative.h"
 #ifdef USE_FABRIC
+#include <Fabric/Composition/UriImageManager.h>
 #include <Fabric/WindowsComponentDescriptorRegistry.h>
+#include "winrt/Microsoft.ReactNative.Composition.h"
 #endif
 
 namespace winrt::Microsoft::ReactNative {
@@ -30,6 +32,8 @@ struct ReactPackageBuilder : winrt::implements<
       std::shared_ptr<TurboModulesProvider> const &turboModulesProvider,
 #ifdef USE_FABRIC
       std::shared_ptr<::Microsoft::ReactNative::WindowsComponentDescriptorRegistry> const &componentRegistry,
+      std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> const
+          &uriImageManager,
 #endif
       bool isWebDebugging) noexcept;
 
@@ -43,6 +47,7 @@ struct ReactPackageBuilder : winrt::implements<
 #ifdef USE_FABRIC
   // IReactPackageBuilderFabric
   void AddViewComponent(winrt::hstring componentName, ReactViewComponentProvider const &viewComponentProvider) noexcept;
+  void AddUriImageProvider(const winrt::Microsoft::ReactNative::Composition::IUriImageProvider &provider) noexcept;
 #endif // USE_FABRIC
 
  private:
@@ -54,6 +59,7 @@ struct ReactPackageBuilder : winrt::implements<
 
 #ifdef USE_FABRIC
   std::shared_ptr<::Microsoft::ReactNative::WindowsComponentDescriptorRegistry> m_componentRegistry;
+  std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> m_uriImageManager;
 #endif
 
   const bool m_isWebDebugging;

package/Microsoft.ReactNative/UriImageManager.idl

@@ -0,0 +1,75 @@
+// 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);
+  }
+  }
+} // namespace Microsoft.ReactNative.Composition

package/Microsoft.ReactNative.Cxx/AutoDraw.h

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+#include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
 #include <winrt/Microsoft.ReactNative.Composition.h>
 
 #include <CompositionSwitcher.Experimental.interop.h>

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.3</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>74</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>1</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>3</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>7fd1f4439e2e1f109d4d2b20a97073f14bcbf504</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>6e935c2cf39436706361e0e612454fafe20f6d66</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Shared.vcxitems

@@ -84,6 +84,11 @@
       <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\CompositionViewComponentView.cpp">
       <ExcludedFromBuild Condition="'$(UseFabric)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>
@@ -639,6 +644,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};