react-native-windows 0.74.10 → 0.74.11

package/Libraries/Components/TextInput/TextInput.js

@@ -1135,12 +1135,14 @@ function InternalTextInput(props: Props): React.Node {
         };
 
   const [mostRecentEventCount, setMostRecentEventCount] = useState<number>(0);
-
   const [lastNativeText, setLastNativeText] = useState<?Stringish>(props.value);
   const [lastNativeSelectionState, setLastNativeSelection] = useState<{|
-    selection: ?Selection,
+    selection: Selection,
     mostRecentEventCount: number,
-  |}>({selection, mostRecentEventCount});
+  |}>({
+    selection: {start: -1, end: -1},
+    mostRecentEventCount: mostRecentEventCount,
+  });
 
   const lastNativeSelection = lastNativeSelectionState.selection;
 
@@ -1498,6 +1500,7 @@ function InternalTextInput(props: Props): React.Node {
         onSelectionChange={_onSelectionChange}
         onSelectionChangeShouldSetResponder={emptyFunctionThatReturnsTrue}
         selection={selection}
+        selectionColor={selectionColor}
         style={StyleSheet.compose(
           useMultilineDefaultStyle ? styles.multilineDefault : null,
           style,

package/Libraries/Components/TextInput/TextInput.windows.js

@@ -1212,12 +1212,14 @@ function InternalTextInput(props: Props): React.Node {
         };
 
   const [mostRecentEventCount, setMostRecentEventCount] = useState<number>(0);
-
   const [lastNativeText, setLastNativeText] = useState<?Stringish>(props.value);
   const [lastNativeSelectionState, setLastNativeSelection] = useState<{|
-    selection: ?Selection,
+    selection: Selection,
     mostRecentEventCount: number,
-  |}>({selection, mostRecentEventCount});
+  |}>({
+    selection: {start: -1, end: -1},
+    mostRecentEventCount: mostRecentEventCount,
+  });
 
   const lastNativeSelection = lastNativeSelectionState.selection;
 
@@ -1649,6 +1651,7 @@ function InternalTextInput(props: Props): React.Node {
         onSelectionChange={_onSelectionChange}
         onSelectionChangeShouldSetResponder={emptyFunctionThatReturnsTrue}
         selection={selection}
+        selectionColor={selectionColor}
         style={StyleSheet.compose(
           useMultilineDefaultStyle ? styles.multilineDefault : null,
           style,

package/Libraries/Core/ReactNativeVersion.js

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

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

@@ -602,6 +602,8 @@ void SetBorderLayerPropertiesCommon(
     facebook::react::BorderStyle borderStyle) {
   layer.Offset({anchorOffset.x, anchorOffset.y, 0}, {anchorPoint.x, anchorPoint.y, 0});
   layer.RelativeSizeWithOffset(size, relativeSizeAdjustment);
+  layer.as<::Microsoft::ReactNative::Composition::Experimental::IVisualInterop>()->SetClippingPath(nullptr);
+
   if ((textureRect.right - textureRect.left) <= 0 || (textureRect.bottom - textureRect.top) <= 0)
     return;
 
@@ -703,7 +705,8 @@ void SetBorderLayerProperties(
     // if (VisualVersion::IsUseWinCompClippingRegionEnabled())
     {
       layer.Offset({anchorOffset.x, anchorOffset.y, 0}, {anchorPoint.x, anchorPoint.y, 0});
-      layer.Size({textureRect.right - textureRect.left, textureRect.bottom - textureRect.top});
+      layer.RelativeSizeWithOffset(
+          {textureRect.right - textureRect.left, textureRect.bottom - textureRect.top}, {0.0f, 0.0f});
 
       layer.Brush(theme->Brush(*borderColor));
 

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

@@ -83,6 +83,16 @@ void ParagraphComponentView::updateState(
   m_textLayout = nullptr;
 }
 
+void ParagraphComponentView::updateLayoutMetrics(
+    facebook::react::LayoutMetrics const &layoutMetrics,
+    facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept {
+  Super::updateLayoutMetrics(layoutMetrics, oldLayoutMetrics);
+
+  if (layoutMetrics.pointScaleFactor != oldLayoutMetrics.pointScaleFactor) {
+    m_textLayout = nullptr;
+  }
+}
+
 void ParagraphComponentView::FinalizeUpdates(
     winrt::Microsoft::ReactNative::ComponentViewUpdateMask updateMask) noexcept {
   ensureVisual();

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

@@ -34,6 +34,9 @@ struct ParagraphComponentView : ParagraphComponentViewT<ParagraphComponentView,
   void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
       override;
   void updateEventEmitter(facebook::react::EventEmitter::Shared const &eventEmitter) noexcept override;
+  void updateLayoutMetrics(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
   void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
       override;
   void FinalizeUpdates(winrt::Microsoft::ReactNative::ComponentViewUpdateMask updateMask) noexcept override;

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

@@ -125,6 +125,15 @@ inline Mso::Future<void> CompositionReactViewInstance::PostInUIQueue(TAction &&a
   return promise.AsFuture();
 }
 
+void ApplyConstraints(
+    const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraintsIn,
+    facebook::react::LayoutConstraints &layoutConstraintsOut) noexcept {
+  layoutConstraintsOut.minimumSize = {layoutConstraintsIn.MinimumSize.Width, layoutConstraintsIn.MinimumSize.Height};
+  layoutConstraintsOut.maximumSize = {layoutConstraintsIn.MaximumSize.Width, layoutConstraintsIn.MaximumSize.Height};
+  layoutConstraintsOut.layoutDirection =
+      static_cast<facebook::react::LayoutDirection>(layoutConstraintsIn.LayoutDirection);
+}
+
 ReactNativeIsland::ReactNativeIsland() noexcept {}
 
 #ifdef USE_WINUI3
@@ -136,6 +145,7 @@ ReactNativeIsland::~ReactNativeIsland() noexcept {
 #ifdef USE_WINUI3
   if (m_island && m_island.IsConnected()) {
     m_island.AutomationProviderRequested(m_islandAutomationProviderRequestedToken);
+    m_island.StateChanged(m_islandStateChangedToken);
   }
 #endif
 
@@ -251,6 +261,7 @@ void ReactNativeIsland::ScaleFactor(float value) noexcept {
       rootView.Scale({invScale, invScale, invScale});
     }
     UpdateRootVisualSize();
+    Arrange(m_layoutConstraints, m_viewportOffset);
   }
 }
 
@@ -471,10 +482,14 @@ void ReactNativeIsland::ShowInstanceLoaded() noexcept {
       initProps = folly::dynamic::object();
     }
     initProps["concurrentRoot"] = true;
+
+    facebook::react::LayoutConstraints fbLayoutConstraints;
+    ApplyConstraints(m_layoutConstraints, fbLayoutConstraints);
+
     uiManager->startSurface(
         *this,
         static_cast<facebook::react::SurfaceId>(m_rootTag),
-        m_layoutConstraints,
+        fbLayoutConstraints,
         to_string(m_reactViewOptions.ComponentName()),
         initProps);
 
@@ -491,16 +506,21 @@ facebook::react::AttributedStringBox CreateLoadingAttributedString() noexcept {
   return facebook::react::AttributedStringBox{attributedString};
 }
 
-facebook::react::Size MeasureLoading(const facebook::react::LayoutConstraints &layoutConstraints, float scaleFactor) {
+facebook::react::Size MeasureLoading(
+    const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
+    float scaleFactor) {
+  facebook::react::LayoutConstraints fbLayoutConstraints;
+  ApplyConstraints(layoutConstraints, fbLayoutConstraints);
+
   auto attributedStringBox = CreateLoadingAttributedString();
   winrt::com_ptr<::IDWriteTextLayout> textLayout;
   facebook::react::TextLayoutManager::GetTextLayout(
-      attributedStringBox, {} /*paragraphAttributes*/, layoutConstraints, textLayout);
+      attributedStringBox, {} /*paragraphAttributes*/, fbLayoutConstraints, textLayout);
 
   DWRITE_TEXT_METRICS tm;
   textLayout->GetMetrics(&tm);
 
-  return layoutConstraints.clamp(
+  return fbLayoutConstraints.clamp(
       {loadingActivityHorizontalOffset * scaleFactor + tm.width, loadingBarHeight * scaleFactor});
 }
 
@@ -625,15 +645,6 @@ void ReactNativeIsland::ShowInstanceLoading() noexcept {
   InternalRootVisual().InsertAt(m_loadingVisual, m_hasRenderedVisual ? 1 : 0);
 }
 
-void ApplyConstraints(
-    const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraintsIn,
-    facebook::react::LayoutConstraints &layoutConstraintsOut) noexcept {
-  layoutConstraintsOut.minimumSize = {layoutConstraintsIn.MinimumSize.Width, layoutConstraintsIn.MinimumSize.Height};
-  layoutConstraintsOut.maximumSize = {layoutConstraintsIn.MaximumSize.Width, layoutConstraintsIn.MaximumSize.Height};
-  layoutConstraintsOut.layoutDirection =
-      static_cast<facebook::react::LayoutDirection>(layoutConstraintsIn.LayoutDirection);
-}
-
 winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
     const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
     const winrt::Windows::Foundation::Point &viewportOffset) const noexcept {
@@ -654,7 +665,7 @@ winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
       size = fabricuiManager->measureSurface(static_cast<facebook::react::SurfaceId>(m_rootTag), constraints, context);
     }
   } else if (m_loadingVisual) {
-    size = MeasureLoading(constraints, m_scaleFactor);
+    size = MeasureLoading(layoutConstraints, m_scaleFactor);
   }
 
   auto clampedSize = constraints.clamp(size);
@@ -664,7 +675,10 @@ winrt::Windows::Foundation::Size ReactNativeIsland::Measure(
 void ReactNativeIsland::Arrange(
     const winrt::Microsoft::ReactNative::LayoutConstraints &layoutConstraints,
     const winrt::Windows::Foundation::Point &viewportOffset) noexcept {
-  ApplyConstraints(layoutConstraints, m_layoutConstraints);
+  m_layoutConstraints = layoutConstraints;
+  m_viewportOffset = viewportOffset;
+  facebook::react::LayoutConstraints fbLayoutConstraints;
+  ApplyConstraints(layoutConstraints, fbLayoutConstraints);
 
   if (m_isInitialized && m_rootTag != -1) {
     if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
@@ -675,11 +689,11 @@ void ReactNativeIsland::Arrange(
       context.viewportOffset = {viewportOffset.X, viewportOffset.Y};
 
       fabricuiManager->constraintSurfaceLayout(
-          static_cast<facebook::react::SurfaceId>(m_rootTag), m_layoutConstraints, context);
+          static_cast<facebook::react::SurfaceId>(m_rootTag), fbLayoutConstraints, context);
     }
   } else if (m_loadingVisual) {
     // TODO: Resize to align loading
-    auto s = m_layoutConstraints.clamp(MeasureLoading(m_layoutConstraints, m_scaleFactor));
+    auto s = fbLayoutConstraints.clamp(MeasureLoading(layoutConstraints, m_scaleFactor));
     NotifySizeChanged();
   }
 }
@@ -729,6 +743,17 @@ winrt::Microsoft::UI::Content::ContentIsland ReactNativeIsland::Island() {
         pThis->m_island = nullptr;
       }
     });
+
+    m_islandStateChangedToken =
+        m_island.StateChanged([weakThis = get_weak()](
+                                  winrt::Microsoft::UI::Content::ContentIsland const &island,
+                                  winrt::Microsoft::UI::Content::ContentIslandStateChangedEventArgs const &args) {
+          if (auto pThis = weakThis.get()) {
+            if (args.DidRasterizationScaleChange()) {
+              pThis->ScaleFactor(island.RasterizationScale());
+            }
+          }
+        });
   }
   return m_island;
 }

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

@@ -125,6 +125,7 @@ struct ReactNativeIsland
   winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};
   winrt::event_token m_islandFrameworkClosedToken;
   winrt::event_token m_islandAutomationProviderRequestedToken;
+  winrt::event_token m_islandStateChangedToken;
 #endif
 
   HWND m_hwnd{0};
@@ -147,7 +148,8 @@ struct ReactNativeIsland
   winrt::Microsoft::ReactNative::Composition::ICustomResourceLoader m_resources{nullptr};
   winrt::Microsoft::ReactNative::Composition::Theme m_theme{nullptr};
   winrt::Microsoft::ReactNative::Composition::Theme::ThemeChanged_revoker m_themeChangedRevoker;
-  facebook::react::LayoutConstraints m_layoutConstraints;
+  winrt::Microsoft::ReactNative::LayoutConstraints m_layoutConstraints;
+  winrt::Windows::Foundation::Point m_viewportOffset{0, 0};
   winrt::event<winrt::Windows::Foundation::EventHandler<winrt::Microsoft::ReactNative::RootViewSizeChangedEventArgs>>
       m_sizeChangedEvent;
 

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -87,6 +87,11 @@ WindowsImageManager::GetImageRandomAccessStreamAsync(ReactImageSource source) co
     }
 
     winrt::Windows::Storage::StorageFile file(co_await getFileSync);
+
+    if (!file) {
+      co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(L"Failed to get file.");
+    }
+
     co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(co_await file.OpenReadAsync());
   }
 

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.74.10</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.74.11</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>74</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>10</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>11</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>189a294fa10f14c96bc992d492145026eed77c32</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>71a102ac500541f38b7b8bf3b919c5cc8f3494a6</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/algorithm/CalculateLayout.cpp

@@ -2120,6 +2120,7 @@ bool calculateLayoutInternal(
 
   const bool needToVisitNode =
       (node->isDirty() && layout->generationCount != generationCount) ||
+      layout->configVersion != node->getConfig()->getVersion() || // [Windows]
       layout->lastOwnerDirection != ownerDirection;
 
   if (needToVisitNode) {
@@ -2235,6 +2236,7 @@ bool calculateLayoutInternal(
         reason);
 
     layout->lastOwnerDirection = ownerDirection;
+    layout->configVersion = node->getConfig()->getVersion(); // [Windows]
 
     if (cachedResults == nullptr) {
       layoutMarkerData.maxMeasureCache = std::max(

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/config/Config.cpp

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <yoga/config/Config.h>
+#include <yoga/debug/Log.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+bool configUpdateInvalidatesLayout(
+    const Config& oldConfig,
+    const Config& newConfig) {
+  return oldConfig.getErrata() != newConfig.getErrata() ||
+      oldConfig.getEnabledExperiments() != newConfig.getEnabledExperiments() ||
+      oldConfig.getPointScaleFactor() != newConfig.getPointScaleFactor() ||
+      oldConfig.useWebDefaults() != newConfig.useWebDefaults();
+}
+
+Config::Config(YGLogger logger) : cloneNodeCallback_{nullptr} {
+  setLogger(logger);
+}
+
+void Config::setUseWebDefaults(bool useWebDefaults) {
+  useWebDefaults_ = useWebDefaults;
+}
+
+bool Config::useWebDefaults() const {
+  return useWebDefaults_;
+}
+
+void Config::setExperimentalFeatureEnabled(
+    ExperimentalFeature feature,
+    bool enabled) {
+  if (isExperimentalFeatureEnabled(feature) != enabled) {
+    experimentalFeatures_.set(static_cast<size_t>(feature), enabled);
+    version_++;
+  }
+}
+
+bool Config::isExperimentalFeatureEnabled(ExperimentalFeature feature) const {
+  return experimentalFeatures_.test(static_cast<size_t>(feature));
+}
+
+ExperimentalFeatureSet Config::getEnabledExperiments() const {
+  return experimentalFeatures_;
+}
+
+void Config::setErrata(Errata errata) {
+  if (errata_ != errata) {
+    errata_ = errata;
+    version_++;
+  }
+}
+
+void Config::addErrata(Errata errata) {
+  if (!hasErrata(errata)) {
+    errata_ |= errata;
+    version_++;
+  }
+}
+
+void Config::removeErrata(Errata errata) {
+  if (hasErrata(errata)) {
+    errata_ &= (~errata);
+    version_++;
+  }
+}
+
+Errata Config::getErrata() const {
+  return errata_;
+}
+
+bool Config::hasErrata(Errata errata) const {
+  return (errata_ & errata) != Errata::None;
+}
+
+void Config::setPointScaleFactor(float pointScaleFactor) {
+  if (pointScaleFactor_ != pointScaleFactor) {
+    pointScaleFactor_ = pointScaleFactor;
+    version_++;
+  }
+}
+
+float Config::getPointScaleFactor() const {
+  return pointScaleFactor_;
+}
+
+void Config::setContext(void* context) {
+  context_ = context;
+}
+
+void* Config::getContext() const {
+  return context_;
+}
+
+// [Windows #13409]
+uint32_t Config::getVersion() const noexcept {
+  return version_;
+}
+
+void Config::setLogger(YGLogger logger) {
+  logger_ = logger;
+}
+
+void Config::log(
+    const yoga::Node* node,
+    LogLevel logLevel,
+    const char* format,
+    va_list args) const {
+  logger_(this, node, unscopedEnum(logLevel), format, args);
+}
+
+void Config::setCloneNodeCallback(YGCloneNodeFunc cloneNode) {
+  cloneNodeCallback_ = cloneNode;
+}
+
+YGNodeRef Config::cloneNode(
+    YGNodeConstRef node,
+    YGNodeConstRef owner,
+    size_t childIndex) const {
+  YGNodeRef clone = nullptr;
+  if (cloneNodeCallback_ != nullptr) {
+    clone = cloneNodeCallback_(node, owner, childIndex);
+  }
+  if (clone == nullptr) {
+    clone = YGNodeClone(node);
+  }
+  return clone;
+}
+
+/*static*/ const Config& Config::getDefault() {
+  static Config config{getDefaultLogger()};
+  return config;
+}
+
+} // namespace facebook::yoga

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/config/Config.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <bitset>
+
+#include <yoga/Yoga.h>
+#include <yoga/enums/Errata.h>
+#include <yoga/enums/ExperimentalFeature.h>
+#include <yoga/enums/LogLevel.h>
+
+// Tag struct used to form the opaque YGConfigRef for the public C API
+struct YGConfig {};
+
+namespace facebook::yoga {
+
+class Config;
+class Node;
+
+using ExperimentalFeatureSet = std::bitset<ordinalCount<ExperimentalFeature>()>;
+
+// Whether moving a node from an old to new config should dirty previously
+// calculated layout results.
+bool configUpdateInvalidatesLayout(
+    const Config& oldConfig,
+    const Config& newConfig);
+
+class YG_EXPORT Config : public ::YGConfig {
+ public:
+  Config(YGLogger logger);
+
+  void setUseWebDefaults(bool useWebDefaults);
+  bool useWebDefaults() const;
+
+  void setExperimentalFeatureEnabled(ExperimentalFeature feature, bool enabled);
+  bool isExperimentalFeatureEnabled(ExperimentalFeature feature) const;
+  ExperimentalFeatureSet getEnabledExperiments() const;
+
+  void setErrata(Errata errata);
+  void addErrata(Errata errata);
+  void removeErrata(Errata errata);
+  Errata getErrata() const;
+  bool hasErrata(Errata errata) const;
+
+  void setPointScaleFactor(float pointScaleFactor);
+  float getPointScaleFactor() const;
+
+  void setContext(void* context);
+  void* getContext() const;
+
+  uint32_t getVersion() const noexcept; // [Windows #13409]
+
+  void setLogger(YGLogger logger);
+  void log(
+      const yoga::Node* node,
+      LogLevel logLevel,
+      const char* format,
+      va_list args) const;
+
+  void setCloneNodeCallback(YGCloneNodeFunc cloneNode);
+  YGNodeRef
+  cloneNode(YGNodeConstRef node, YGNodeConstRef owner, size_t childIndex) const;
+
+  static const Config& getDefault();
+
+ private:
+  YGCloneNodeFunc cloneNodeCallback_;
+  YGLogger logger_;
+
+  bool useWebDefaults_ : 1 = false;
+
+  uint32_t version_ = 0; // [Windows #13409]
+  ExperimentalFeatureSet experimentalFeatures_{};
+  Errata errata_ = Errata::None;
+  float pointScaleFactor_ = 1.0f;
+  void* context_ = nullptr;
+};
+
+inline Config* resolveRef(const YGConfigRef ref) {
+  return static_cast<Config*>(ref);
+}
+
+inline const Config* resolveRef(const YGConfigConstRef ref) {
+  return static_cast<const Config*>(ref);
+}
+
+} // namespace facebook::yoga

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/node/LayoutResults.cpp

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <cmath>
+
+#include <yoga/node/LayoutResults.h>
+#include <yoga/numeric/Comparison.h>
+
+namespace facebook::yoga {
+
+bool LayoutResults::operator==(LayoutResults layout) const {
+  bool isEqual = yoga::inexactEquals(position_, layout.position_) &&
+      yoga::inexactEquals(dimensions_, layout.dimensions_) &&
+      yoga::inexactEquals(margin_, layout.margin_) &&
+      yoga::inexactEquals(border_, layout.border_) &&
+      yoga::inexactEquals(padding_, layout.padding_) &&
+      direction() == layout.direction() &&
+      hadOverflow() == layout.hadOverflow() &&
+      lastOwnerDirection == layout.lastOwnerDirection &&
+      configVersion == layout.configVersion && // [Windows #13409]
+      nextCachedMeasurementsIndex == layout.nextCachedMeasurementsIndex &&
+      cachedLayout == layout.cachedLayout &&
+      computedFlexBasis == layout.computedFlexBasis;
+
+  for (uint32_t i = 0; i < LayoutResults::MaxCachedMeasurements && isEqual;
+       ++i) {
+    isEqual = isEqual && cachedMeasurements[i] == layout.cachedMeasurements[i];
+  }
+
+  if (!yoga::isUndefined(measuredDimensions_[0]) ||
+      !yoga::isUndefined(layout.measuredDimensions_[0])) {
+    isEqual =
+        isEqual && (measuredDimensions_[0] == layout.measuredDimensions_[0]);
+  }
+  if (!yoga::isUndefined(measuredDimensions_[1]) ||
+      !yoga::isUndefined(layout.measuredDimensions_[1])) {
+    isEqual =
+        isEqual && (measuredDimensions_[1] == layout.measuredDimensions_[1]);
+  }
+
+  return isEqual;
+}
+
+} // namespace facebook::yoga

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/node/LayoutResults.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <array>
+
+#include <yoga/debug/AssertFatal.h>
+#include <yoga/enums/Dimension.h>
+#include <yoga/enums/Direction.h>
+#include <yoga/enums/Edge.h>
+#include <yoga/enums/PhysicalEdge.h>
+#include <yoga/node/CachedMeasurement.h>
+#include <yoga/numeric/FloatOptional.h>
+
+namespace facebook::yoga {
+
+struct LayoutResults {
+  // This value was chosen based on empirical data:
+  // 98% of analyzed layouts require less than 8 entries.
+  static constexpr int32_t MaxCachedMeasurements = 8;
+
+  uint32_t computedFlexBasisGeneration = 0;
+  FloatOptional computedFlexBasis = {};
+
+  // Instead of recomputing the entire layout every single time, we cache some
+  // information to break early when nothing changed
+  uint32_t generationCount = 0;
+  uint32_t configVersion = 0; // [Windows #13409]
+  Direction lastOwnerDirection = Direction::Inherit;
+
+  uint32_t nextCachedMeasurementsIndex = 0;
+  std::array<CachedMeasurement, MaxCachedMeasurements> cachedMeasurements = {};
+
+  CachedMeasurement cachedLayout{};
+
+  Direction direction() const {
+    return direction_;
+  }
+
+  void setDirection(Direction direction) {
+    direction_ = direction;
+  }
+
+  bool hadOverflow() const {
+    return hadOverflow_;
+  }
+
+  void setHadOverflow(bool hadOverflow) {
+    hadOverflow_ = hadOverflow;
+  }
+
+  float dimension(Dimension axis) const {
+    return dimensions_[yoga::to_underlying(axis)];
+  }
+
+  void setDimension(Dimension axis, float dimension) {
+    dimensions_[yoga::to_underlying(axis)] = dimension;
+  }
+
+  float measuredDimension(Dimension axis) const {
+    return measuredDimensions_[yoga::to_underlying(axis)];
+  }
+
+  void setMeasuredDimension(Dimension axis, float dimension) {
+    measuredDimensions_[yoga::to_underlying(axis)] = dimension;
+  }
+
+  float position(PhysicalEdge physicalEdge) const {
+    return position_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setPosition(PhysicalEdge physicalEdge, float dimension) {
+    position_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  float margin(PhysicalEdge physicalEdge) const {
+    return margin_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setMargin(PhysicalEdge physicalEdge, float dimension) {
+    margin_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  float border(PhysicalEdge physicalEdge) const {
+    return border_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setBorder(PhysicalEdge physicalEdge, float dimension) {
+    border_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  float padding(PhysicalEdge physicalEdge) const {
+    return padding_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setPadding(PhysicalEdge physicalEdge, float dimension) {
+    padding_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  bool operator==(LayoutResults layout) const;
+  bool operator!=(LayoutResults layout) const {
+    return !(*this == layout);
+  }
+
+ private:
+  Direction direction_ : bitCount<Direction>() = Direction::Inherit;
+  bool hadOverflow_ : 1 = false;
+
+  std::array<float, 2> dimensions_ = {{YGUndefined, YGUndefined}};
+  std::array<float, 2> measuredDimensions_ = {{YGUndefined, YGUndefined}};
+  std::array<float, 4> position_ = {};
+  std::array<float, 4> margin_ = {};
+  std::array<float, 4> border_ = {};
+  std::array<float, 4> padding_ = {};
+};
+
+} // namespace facebook::yoga

package/ReactCommon/TEMP_UntilReactCommonUpdate/yoga/yoga/node/Node.cpp

@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <algorithm>
+#include <cstddef>
+#include <iostream>
+
+#include <yoga/debug/AssertFatal.h>
+#include <yoga/node/Node.h>
+#include <yoga/numeric/Comparison.h>
+
+namespace facebook::yoga {
+
+Node::Node() : Node{&Config::getDefault()} {}
+
+Node::Node(const yoga::Config* config) : config_{config} {
+  yoga::assertFatal(
+      config != nullptr, "Attempting to construct Node with null config");
+
+  if (config->useWebDefaults()) {
+    useWebDefaults();
+  }
+}
+
+Node::Node(Node&& node) {
+  hasNewLayout_ = node.hasNewLayout_;
+  isReferenceBaseline_ = node.isReferenceBaseline_;
+  isDirty_ = node.isDirty_;
+  alwaysFormsContainingBlock_ = node.alwaysFormsContainingBlock_;
+  nodeType_ = node.nodeType_;
+  context_ = node.context_;
+  measureFunc_ = node.measureFunc_;
+  baselineFunc_ = node.baselineFunc_;
+  dirtiedFunc_ = node.dirtiedFunc_;
+  style_ = node.style_;
+  layout_ = node.layout_;
+  lineIndex_ = node.lineIndex_;
+  owner_ = node.owner_;
+  children_ = std::move(node.children_);
+  config_ = node.config_;
+  resolvedDimensions_ = node.resolvedDimensions_;
+  for (auto c : children_) {
+    c->setOwner(this);
+  }
+}
+
+YGSize Node::measure(
+    float width,
+    MeasureMode widthMode,
+    float height,
+    MeasureMode heightMode) {
+  return measureFunc_(
+      this, width, unscopedEnum(widthMode), height, unscopedEnum(heightMode));
+}
+
+float Node::baseline(float width, float height) const {
+  return baselineFunc_(this, width, height);
+}
+
+float Node::dimensionWithMargin(
+    const FlexDirection axis,
+    const float widthSize) {
+  return getLayout().measuredDimension(dimension(axis)) +
+      style_.computeMarginForAxis(axis, widthSize);
+}
+
+bool Node::isLayoutDimensionDefined(const FlexDirection axis) {
+  const float value = getLayout().measuredDimension(dimension(axis));
+  return yoga::isDefined(value) && value >= 0.0f;
+}
+
+// Setters
+
+void Node::setMeasureFunc(YGMeasureFunc measureFunc) {
+  if (measureFunc == nullptr) {
+    // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
+    // places in Litho
+    setNodeType(NodeType::Default);
+  } else {
+    yoga::assertFatalWithNode(
+        this,
+        children_.size() == 0,
+        "Cannot set measure function: Nodes with measure functions cannot have "
+        "children.");
+    // TODO: t18095186 Move nodeType to opt-in function and mark appropriate
+    // places in Litho
+    setNodeType(NodeType::Text);
+  }
+
+  measureFunc_ = measureFunc;
+}
+
+void Node::replaceChild(Node* child, size_t index) {
+  children_[index] = child;
+}
+
+void Node::replaceChild(Node* oldChild, Node* newChild) {
+  std::replace(children_.begin(), children_.end(), oldChild, newChild);
+}
+
+void Node::insertChild(Node* child, size_t index) {
+  children_.insert(children_.begin() + static_cast<ptrdiff_t>(index), child);
+}
+
+void Node::setConfig(yoga::Config* config) {
+  yoga::assertFatal(
+      config != nullptr, "Attempting to set a null config on a Node");
+  yoga::assertFatalWithConfig(
+      config,
+      config->useWebDefaults() == config_->useWebDefaults(),
+      "UseWebDefaults may not be changed after constructing a Node");
+
+  if (yoga::configUpdateInvalidatesLayout(*config_, *config)) {
+    markDirtyAndPropagate();
+    layout_.configVersion = 0; // [Windows #13409]
+  } else { // [Windows #13409]
+    // If the config is functionally the same, then align the configVersion so
+    // that we can reuse the layout cache
+    layout_.configVersion = config->getVersion(); // [Windows #13409]
+  }
+  config_ = config;
+}
+
+void Node::setDirty(bool isDirty) {
+  if (isDirty == isDirty_) {
+    return;
+  }
+  isDirty_ = isDirty;
+  if (isDirty && dirtiedFunc_) {
+    dirtiedFunc_(this);
+  }
+}
+
+bool Node::removeChild(Node* child) {
+  std::vector<Node*>::iterator p =
+      std::find(children_.begin(), children_.end(), child);
+  if (p != children_.end()) {
+    children_.erase(p);
+    return true;
+  }
+  return false;
+}
+
+void Node::removeChild(size_t index) {
+  children_.erase(children_.begin() + static_cast<ptrdiff_t>(index));
+}
+
+void Node::setLayoutDirection(Direction direction) {
+  layout_.setDirection(direction);
+}
+
+void Node::setLayoutMargin(float margin, PhysicalEdge edge) {
+  layout_.setMargin(edge, margin);
+}
+
+void Node::setLayoutBorder(float border, PhysicalEdge edge) {
+  layout_.setBorder(edge, border);
+}
+
+void Node::setLayoutPadding(float padding, PhysicalEdge edge) {
+  layout_.setPadding(edge, padding);
+}
+
+void Node::setLayoutLastOwnerDirection(Direction direction) {
+  layout_.lastOwnerDirection = direction;
+}
+
+void Node::setLayoutComputedFlexBasis(const FloatOptional computedFlexBasis) {
+  layout_.computedFlexBasis = computedFlexBasis;
+}
+
+void Node::setLayoutPosition(float position, PhysicalEdge edge) {
+  layout_.setPosition(edge, position);
+}
+
+void Node::setLayoutComputedFlexBasisGeneration(
+    uint32_t computedFlexBasisGeneration) {
+  layout_.computedFlexBasisGeneration = computedFlexBasisGeneration;
+}
+
+void Node::setLayoutMeasuredDimension(
+    float measuredDimension,
+    Dimension dimension) {
+  layout_.setMeasuredDimension(dimension, measuredDimension);
+}
+
+void Node::setLayoutHadOverflow(bool hadOverflow) {
+  layout_.setHadOverflow(hadOverflow);
+}
+
+void Node::setLayoutDimension(float LengthValue, Dimension dimension) {
+  layout_.setDimension(dimension, LengthValue);
+}
+
+// If both left and right are defined, then use left. Otherwise return +left or
+// -right depending on which is defined. Ignore statically positioned nodes as
+// insets do not apply to them.
+float Node::relativePosition(
+    FlexDirection axis,
+    Direction direction,
+    float axisSize) const {
+  if (style_.positionType() == PositionType::Static) {
+    return 0;
+  }
+  if (style_.isInlineStartPositionDefined(axis, direction)) {
+    return style_.computeInlineStartPosition(axis, direction, axisSize);
+  }
+
+  return -1 * style_.computeInlineEndPosition(axis, direction, axisSize);
+}
+
+void Node::setPosition(
+    const Direction direction,
+    const float mainSize,
+    const float crossSize,
+    const float ownerWidth) {
+  /* Root nodes should be always layouted as LTR, so we don't return negative
+   * values. */
+  const Direction directionRespectingRoot =
+      owner_ != nullptr ? direction : Direction::LTR;
+  const FlexDirection mainAxis =
+      yoga::resolveDirection(style_.flexDirection(), directionRespectingRoot);
+  const FlexDirection crossAxis =
+      yoga::resolveCrossDirection(mainAxis, directionRespectingRoot);
+
+  // In the case of position static these are just 0. See:
+  // https://www.w3.org/TR/css-position-3/#valdef-position-static
+  const float relativePositionMain =
+      relativePosition(mainAxis, directionRespectingRoot, mainSize);
+  const float relativePositionCross =
+      relativePosition(crossAxis, directionRespectingRoot, crossSize);
+
+  const auto mainAxisLeadingEdge = inlineStartEdge(mainAxis, direction);
+  const auto mainAxisTrailingEdge = inlineEndEdge(mainAxis, direction);
+  const auto crossAxisLeadingEdge = inlineStartEdge(crossAxis, direction);
+  const auto crossAxisTrailingEdge = inlineEndEdge(crossAxis, direction);
+
+  setLayoutPosition(
+      (style_.computeInlineStartMargin(mainAxis, direction, ownerWidth) +
+       relativePositionMain),
+      mainAxisLeadingEdge);
+  setLayoutPosition(
+      (style_.computeInlineEndMargin(mainAxis, direction, ownerWidth) +
+       relativePositionMain),
+      mainAxisTrailingEdge);
+  setLayoutPosition(
+      (style_.computeInlineStartMargin(crossAxis, direction, ownerWidth) +
+       relativePositionCross),
+      crossAxisLeadingEdge);
+  setLayoutPosition(
+      (style_.computeInlineEndMargin(crossAxis, direction, ownerWidth) +
+       relativePositionCross),
+      crossAxisTrailingEdge);
+}
+
+Style::Length Node::resolveFlexBasisPtr() const {
+  Style::Length flexBasis = style_.flexBasis();
+  if (flexBasis.unit() != Unit::Auto && flexBasis.unit() != Unit::Undefined) {
+    return flexBasis;
+  }
+  if (style_.flex().isDefined() && style_.flex().unwrap() > 0.0f) {
+    return config_->useWebDefaults() ? value::ofAuto() : value::points(0);
+  }
+  return value::ofAuto();
+}
+
+void Node::resolveDimension() {
+  for (auto dim : {Dimension::Width, Dimension::Height}) {
+    if (style_.maxDimension(dim).isDefined() &&
+        yoga::inexactEquals(
+            style_.maxDimension(dim), style_.minDimension(dim))) {
+      resolvedDimensions_[yoga::to_underlying(dim)] = style_.maxDimension(dim);
+    } else {
+      resolvedDimensions_[yoga::to_underlying(dim)] = style_.dimension(dim);
+    }
+  }
+}
+
+Direction Node::resolveDirection(const Direction ownerDirection) {
+  if (style_.direction() == Direction::Inherit) {
+    return ownerDirection != Direction::Inherit ? ownerDirection
+                                                : Direction::LTR;
+  } else {
+    return style_.direction();
+  }
+}
+
+void Node::clearChildren() {
+  children_.clear();
+  children_.shrink_to_fit();
+}
+
+// Other Methods
+
+void Node::cloneChildrenIfNeeded() {
+  size_t i = 0;
+  for (Node*& child : children_) {
+    if (child->getOwner() != this) {
+      child = resolveRef(config_->cloneNode(child, this, i));
+      child->setOwner(this);
+    }
+    i += 1;
+  }
+}
+
+void Node::markDirtyAndPropagate() {
+  if (!isDirty_) {
+    setDirty(true);
+    setLayoutComputedFlexBasis(FloatOptional());
+    if (owner_) {
+      owner_->markDirtyAndPropagate();
+    }
+  }
+}
+
+float Node::resolveFlexGrow() const {
+  // Root nodes flexGrow should always be 0
+  if (owner_ == nullptr) {
+    return 0.0;
+  }
+  if (style_.flexGrow().isDefined()) {
+    return style_.flexGrow().unwrap();
+  }
+  if (style_.flex().isDefined() && style_.flex().unwrap() > 0.0f) {
+    return style_.flex().unwrap();
+  }
+  return Style::DefaultFlexGrow;
+}
+
+float Node::resolveFlexShrink() const {
+  if (owner_ == nullptr) {
+    return 0.0;
+  }
+  if (style_.flexShrink().isDefined()) {
+    return style_.flexShrink().unwrap();
+  }
+  if (!config_->useWebDefaults() && style_.flex().isDefined() &&
+      style_.flex().unwrap() < 0.0f) {
+    return -style_.flex().unwrap();
+  }
+  return config_->useWebDefaults() ? Style::WebDefaultFlexShrink
+                                   : Style::DefaultFlexShrink;
+}
+
+bool Node::isNodeFlexible() {
+  return (
+      (style_.positionType() != PositionType::Absolute) &&
+      (resolveFlexGrow() != 0 || resolveFlexShrink() != 0));
+}
+
+void Node::reset() {
+  yoga::assertFatalWithNode(
+      this,
+      children_.size() == 0,
+      "Cannot reset a node which still has children attached");
+  yoga::assertFatalWithNode(
+      this, owner_ == nullptr, "Cannot reset a node still attached to a owner");
+
+  *this = Node{getConfig()};
+}
+
+} // namespace facebook::yoga

package/Scripts/Tfs/Layout-MSRN-Headers.ps1

@@ -49,12 +49,12 @@ Copy-Item -Force -Recurse -Path $ReactWindowsRoot\codegen -Destination $TargetRo
 Copy-Item -Force -Recurse -Path $ReactCommonOverrideRoot\* -Destination $ReactNativeRoot\ReactCommon\
 
 # Microsoft.ReactNative.CXX project JSI files
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\jsi\jsi\decorator.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\jsi\jsi\instrumentation.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\jsi\jsi\jsi.cpp -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\jsi\jsi\jsi.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\jsi\jsi\jsi-inl.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
-Copy-Item -Force -Path $ReactNativeRoot\ReactCommon\jsi\jsi\threadsafe.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
+Copy-Item -Force -Path $NodeApiJsiRoot\jsi\jsi\decorator.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
+Copy-Item -Force -Path $NodeApiJsiRoot\jsi\jsi\instrumentation.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
+Copy-Item -Force -Path $NodeApiJsiRoot\jsi\jsi\jsi.cpp -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
+Copy-Item -Force -Path $NodeApiJsiRoot\jsi\jsi\jsi.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
+Copy-Item -Force -Path $NodeApiJsiRoot\jsi\jsi\jsi-inl.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
+Copy-Item -Force -Path $NodeApiJsiRoot\jsi\jsi\threadsafe.h -Destination $TargetRoot\Microsoft.ReactNative.Cxx\jsi\
 
 # Microsoft.ReactNative.CXX project Node-API files
 New-Item $TargetRoot\Microsoft.ReactNative.Cxx\node-api -ItemType Directory -Force

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.74.10",
+  "version": "0.74.11",
   "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.6",
-    "@react-native-community/cli-platform-android": "13.6.6",
-    "@react-native-community/cli-platform-ios": "13.6.6",
+    "@react-native-community/cli": "13.6.9",
+    "@react-native-community/cli-platform-android": "13.6.9",
+    "@react-native-community/cli-platform-ios": "13.6.9",
     "@react-native-windows/cli": "0.74.1",
     "@react-native/assets": "1.0.0",
-    "@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",
+    "@react-native/assets-registry": "0.74.85",
+    "@react-native/codegen": "0.74.85",
+    "@react-native/community-cli-plugin": "0.74.85",
+    "@react-native/gradle-plugin": "0.74.85",
+    "@react-native/js-polyfills": "0.74.85",
+    "@react-native/normalize-colors": "0.74.85",
+    "@react-native/virtualized-lists": "0.74.85",
     "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.1",
-    "@react-native/metro-config": "0.74.83",
+    "@react-native/metro-config": "0.74.85",
     "@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.1",
+    "react-native": "0.74.3",
     "react-native-platform-override": "^1.9.25",
     "react-refresh": "^0.14.0",
     "typescript": "5.0.4"