@depup/react-native 0.85.0-depup.1 → 0.86.2-depup.0

package/ReactCommon/react/performance/timeline/tests/PerformanceEntryTest.cpp

@@ -0,0 +1,62 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <algorithm>
+#include <type_traits>
+#include <vector>
+
+#include "../PerformanceEntry.h"
+
+using namespace facebook::react;
+
+// Verify that PerformanceEntrySorter::operator() is const-qualified.
+// Without const, std::stable_sort may fail to compile on toolchains where
+// the comparator is passed through a const-qualified code path (e.g.
+// libc++ __insertion_sort on NDK 19.x), causing SIGSEGV at runtime on
+// others. See T263807207.
+TEST(PerformanceEntry, SorterOperatorIsConst) {
+  static_assert(
+      std::is_invocable_v<
+          const PerformanceEntrySorter,
+          const PerformanceEntry&,
+          const PerformanceEntry&>,
+      "PerformanceEntrySorter::operator() must be const-qualified");
+}
+
+TEST(PerformanceEntry, SortEntriesByStartTimeThenDuration) {
+  auto t0 = HighResTimeStamp::now();
+  auto t1 = t0 + HighResDuration::fromMilliseconds(1);
+  auto t2 = t0 + HighResDuration::fromMilliseconds(2);
+
+  std::vector<PerformanceEntry> entries = {
+      PerformanceMark{{.name = "c", .startTime = t2}},
+      PerformanceMark{{.name = "a", .startTime = t0}},
+      PerformanceMeasure{
+          {.name = "b",
+           .startTime = t0,
+           .duration = HighResDuration::fromMilliseconds(5)}},
+      PerformanceMark{
+          {.name = "d", .startTime = t1, .duration = HighResDuration::zero()}},
+  };
+
+  std::stable_sort(entries.begin(), entries.end(), PerformanceEntrySorter{});
+
+  // Entries with same startTime are ordered by duration (ascending).
+  // "a" (t0, dur=0) < "b" (t0, dur=5) < "d" (t1, dur=0) < "c" (t2, dur=0)
+  ASSERT_EQ(4, entries.size());
+
+  auto getName = [](const PerformanceEntry& e) {
+    return std::visit([](const auto& x) { return x.name; }, e);
+  };
+
+  EXPECT_EQ("a", getName(entries[0]));
+  EXPECT_EQ("b", getName(entries[1]));
+  EXPECT_EQ("d", getName(entries[2]));
+  EXPECT_EQ("c", getName(entries[3]));
+}

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -499,15 +499,23 @@ void NativeAnimatedNodesManager::handleAnimatedEvent(
     }
   }
 
-  if (foundAtLeastOneDriver && !isEventAnimationInProgress_) {
-    // There is an animation driver handling this event and
-    // event driven animation has not been started yet.
-    isEventAnimationInProgress_ = true;
-    // Some platforms (e.g. iOS) have UI tick listener disable
-    // when there are no active animations. Calling
-    // `startRenderCallbackIfNeeded` will call platform specific code to
-    // register UI tick listener.
-    startRenderCallbackIfNeeded(false);
+  if (foundAtLeastOneDriver) {
+    // Process event-driven animation updates synchronously, matching the
+    // behavior of the Java NativeAnimatedNodesManager which calls
+    // updateNodes() for every event. Without this, only the first event
+    // in a scroll sequence is processed synchronously — subsequent events
+    // just store the updated value and defer graph traversal + prop commit
+    // to the next choreographer frame, introducing 1-frame latency.
+    if (!isEventAnimationInProgress_) {
+      // There is an animation driver handling this event and
+      // event driven animation has not been started yet.
+      isEventAnimationInProgress_ = true;
+      // Some platforms (e.g. iOS) have UI tick listener disable
+      // when there are no active animations. Calling
+      // `startRenderCallbackIfNeeded` will call platform specific code to
+      // register UI tick listener.
+      startRenderCallbackIfNeeded(false);
+    }
     // Calling startOnRenderCallback_ will register a UI tick listener.
     // The UI ticker listener will not be called until the next frame.
     // That's why, in case this is called from the UI thread, we need to
@@ -515,7 +523,10 @@ void NativeAnimatedNodesManager::handleAnimatedEvent(
     // frames.
     if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
       if (auto animationBackend = animationBackend_.lock()) {
-        animationBackend->trigger();
+        animationBackend->pushAnimationMutations(
+            [this](AnimationTimestamp timestamp) -> AnimationMutations {
+              return pullAnimationMutations(timestamp);
+            });
       }
     } else {
       onRender();
@@ -552,9 +563,13 @@ void NativeAnimatedNodesManager::startRenderCallbackIfNeeded(bool isAsync) {
 
   if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
     if (auto animationBackend = animationBackend_.lock()) {
-      animationBackendCallbackId_ =
-          animationBackend->start([this](AnimationTimestamp timestamp) {
-            return pullAnimationMutations(timestamp);
+      auto weak = weak_from_this();
+      animationBackendCallbackId_ = animationBackend->start(
+          [weak](AnimationTimestamp timestamp) -> AnimationMutations {
+            if (auto self = weak.lock()) {
+              return self->pullAnimationMutations(timestamp);
+            }
+            return {};
           });
     }
 

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.h

@@ -51,7 +51,7 @@ using AnimationEndCallback = AsyncCallback<EndResult>;
 template <>
 struct Bridging<EndResult> : NativeAnimatedTurboModuleEndResultBridging<EndResult> {};
 
-class NativeAnimatedNodesManager {
+class NativeAnimatedNodesManager : public std::enable_shared_from_this<NativeAnimatedNodesManager> {
  public:
   using DirectManipulationCallback = std::function<void(Tag, const folly::dynamic &)>;
   using FabricCommitCallback = std::function<void(std::unordered_map<Tag, folly::dynamic> &)>;

package/ReactCommon/react/renderer/animated/internal/primitives.h

@@ -11,6 +11,6 @@
 namespace facebook::react::animated {
 // Indicates that the animated node identifier is not defined.
 // It is safe to use 0 because JavaScript starts assigning identifiers from 1.
-// https://github.com/facebook/react-native/blob/main/packages/react-native/src/private/animated/NativeAnimatedHelper.js#L35
+// https://github.com/react/react-native/blob/main/packages/react-native/src/private/animated/NativeAnimatedHelper.js#L35
 constexpr static Tag undefinedAnimatedNodeIdentifier = 0;
 } // namespace facebook::react::animated

package/ReactCommon/react/renderer/animationbackend/AnimatedPropSerializer.cpp

@@ -530,6 +530,9 @@ void packMixBlendMode(
     case BlendMode::Luminosity:
       blendModeStr = "luminosity";
       break;
+    case BlendMode::PlusLighter:
+      blendModeStr = "plus-lighter";
+      break;
     default:
       throw std::runtime_error("Unknown blend mode");
   }

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.cpp

@@ -93,10 +93,17 @@ AnimatedPropsRegistry::getMap(SurfaceId surfaceId) {
 
 void AnimatedPropsRegistry::clear(SurfaceId surfaceId) {
   auto lock = std::lock_guard(mutex_);
+  if (auto it = surfaceContexts_.find(surfaceId);
+      it != surfaceContexts_.end()) {
+    auto& surfaceContext = it->second;
+    surfaceContext.families.clear();
+    surfaceContext.map.clear();
+  }
+}
 
-  auto& surfaceContext = surfaceContexts_[surfaceId];
-  surfaceContext.families.clear();
-  surfaceContext.map.clear();
+void AnimatedPropsRegistry::clearOnSurfaceStop(SurfaceId surfaceId) {
+  auto lock = std::lock_guard(mutex_);
+  surfaceContexts_.erase(surfaceId);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.h

@@ -39,6 +39,7 @@ class AnimatedPropsRegistry {
  public:
   void update(const std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates);
   void clear(SurfaceId surfaceId);
+  void clearOnSurfaceStop(SurfaceId surfaceId);
   std::pair<std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> &, SnapshotMap &> getMap(SurfaceId surfaceId);
 
  private:

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -24,10 +24,17 @@ static inline Props::Shared cloneProps(
       shadowNode.getSurfaceId(), *shadowNode.getContextContainer()};
   Props::Shared newProps;
   if (animatedProps.rawProps) {
-    newProps = shadowNode.getComponentDescriptor().cloneProps(
-        propsParserContext,
-        shadowNode.getProps(),
-        std::move(*animatedProps.rawProps));
+    if (ReactNativeFeatureFlags::enableFabricCommitBranching()) {
+      newProps = shadowNode.getComponentDescriptor().cloneProps(
+          propsParserContext,
+          shadowNode.getProps(),
+          std::move(*animatedProps.rawProps));
+    } else {
+      newProps = shadowNode.getComponentDescriptor().cloneProps(
+          propsParserContext,
+          shadowNode.getProps(),
+          RawProps(*animatedProps.rawProps));
+    }
   } else {
     newProps = shadowNode.getComponentDescriptor().cloneProps(
         propsParserContext, shadowNode.getProps(), {});
@@ -51,31 +58,27 @@ AnimationBackend::AnimationBackend(
   react_native_assert(uiManager_.expired() == false);
 }
 
-void AnimationBackend::onAnimationFrame(AnimationTimestamp timestamp) {
-  std::vector<CallbackWithId> callbacksCopy;
-  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
-  std::set<SurfaceId> asyncFlushSurfaces;
+void AnimationBackend::unpackMutations(
+    AnimationMutations& mutations,
+    std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates,
+    std::set<SurfaceId>& asyncFlushSurfaces) {
+  for (auto& mutation : mutations.batch) {
+    const auto family = mutation.family;
+    react_native_assert(family != nullptr);
 
-  {
-    std::lock_guard lock(mutex_);
-    callbacksCopy = callbacks;
+    auto& [families, updates, hasLayoutUpdates] =
+        surfaceUpdates[family->getSurfaceId()];
+    hasLayoutUpdates |= mutation.hasLayoutUpdates;
+    families.insert(family);
+    updates[mutation.tag] = std::move(mutation.props);
   }
 
-  for (auto& callbackWithId : callbacksCopy) {
-    auto mutations = callbackWithId.callback(timestamp);
-    asyncFlushSurfaces.merge(mutations.asyncFlushSurfaces);
-    for (auto& mutation : mutations.batch) {
-      const auto family = mutation.family;
-      react_native_assert(family != nullptr);
-
-      auto& [families, updates, hasLayoutUpdates] =
-          surfaceUpdates[family->getSurfaceId()];
-      hasLayoutUpdates |= mutation.hasLayoutUpdates;
-      families.insert(family);
-      updates[mutation.tag] = std::move(mutation.props);
-    }
-  }
+  asyncFlushSurfaces.merge(mutations.asyncFlushSurfaces);
+}
 
+void AnimationBackend::applySurfaceUpdates(
+    std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates,
+    const std::set<SurfaceId>& asyncFlushSurfaces) {
   animatedPropsRegistry_->update(surfaceUpdates);
 
   for (auto& [surfaceId, updates] : surfaceUpdates) {
@@ -89,6 +92,30 @@ void AnimationBackend::onAnimationFrame(AnimationTimestamp timestamp) {
   requestAsyncFlushForSurfaces(asyncFlushSurfaces);
 }
 
+void AnimationBackend::applyMutations(AnimationMutations mutations) {
+  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
+  std::set<SurfaceId> asyncFlushSurfaces;
+  unpackMutations(mutations, surfaceUpdates, asyncFlushSurfaces);
+  applySurfaceUpdates(surfaceUpdates, asyncFlushSurfaces);
+}
+
+void AnimationBackend::onAnimationFrame(AnimationTimestamp timestamp) {
+  std::vector<CallbackWithId> callbacksCopy;
+
+  {
+    std::lock_guard lock(mutex_);
+    callbacksCopy = callbacks;
+  }
+
+  std::unordered_map<SurfaceId, SurfaceUpdates> surfaceUpdates;
+  std::set<SurfaceId> asyncFlushSurfaces;
+  for (auto& callbackWithId : callbacksCopy) {
+    auto mutations = callbackWithId.callback(timestamp);
+    unpackMutations(mutations, surfaceUpdates, asyncFlushSurfaces);
+  }
+  applySurfaceUpdates(surfaceUpdates, asyncFlushSurfaces);
+}
+
 CallbackId AnimationBackend::start(const Callback& callback) {
   std::lock_guard lock(mutex_);
 
@@ -123,6 +150,12 @@ void AnimationBackend::trigger() {
   onAnimationFrame(std::chrono::steady_clock::now().time_since_epoch());
 }
 
+void AnimationBackend::pushAnimationMutations(const Callback& callback) {
+  auto timestamp = animationChoreographer_->now();
+  auto mutations = callback(timestamp);
+  applyMutations(std::move(mutations));
+}
+
 void AnimationBackend::commitUpdates(
     SurfaceId surfaceId,
     SurfaceUpdates& surfaceUpdates) {
@@ -224,6 +257,10 @@ void AnimationBackend::clearRegistry(SurfaceId surfaceId) {
   animatedPropsRegistry_->clear(surfaceId);
 }
 
+void AnimationBackend::clearRegistryOnSurfaceStop(SurfaceId surfaceId) {
+  animatedPropsRegistry_->clearOnSurfaceStop(surfaceId);
+}
+
 void AnimationBackend::registerJSInvoker(
     std::shared_ptr<CallInvoker> jsInvoker) {
   if (!jsInvoker_) {

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
-#include <folly/dynamic.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
@@ -56,14 +55,24 @@ class AnimationBackend : public UIManagerAnimationBackend {
   void synchronouslyUpdateProps(const std::unordered_map<Tag, AnimatedProps> &updates);
   void requestAsyncFlushForSurfaces(const std::set<SurfaceId> &surfaces);
   void clearRegistry(SurfaceId surfaceId) override;
+  void clearRegistryOnSurfaceStop(SurfaceId surfaceId) override;
   void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) override;
 
   void onAnimationFrame(AnimationTimestamp timestamp) override;
   void trigger() override;
+  void pushAnimationMutations(const Callback &callback) override;
   CallbackId start(const Callback &callback) override;
   void stop(CallbackId callbackId) override;
 
  private:
+  void unpackMutations(
+      AnimationMutations &mutations,
+      std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates,
+      std::set<SurfaceId> &asyncFlushSurfaces);
+  void applySurfaceUpdates(
+      std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates,
+      const std::set<SurfaceId> &asyncFlushSurfaces);
+  void applyMutations(AnimationMutations mutations);
   std::vector<CallbackWithId> callbacks;
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
   std::shared_ptr<AnimationChoreographer> animationChoreographer_;

package/ReactCommon/react/renderer/animationbackend/AnimationBackendCommitHook.h

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerCommitHook.h>

package/ReactCommon/react/renderer/animationbackend/AnimationChoreographer.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
+#include <react/timing/primitives.h>
 
 namespace facebook::react {
 
@@ -21,6 +22,10 @@ class AnimationChoreographer {
 
   virtual void resume() = 0;
   virtual void pause() = 0;
+  virtual AnimationTimestamp now() const
+  {
+    return HighResTimeStamp::now().toChronoSteadyClockTimePoint().time_since_epoch();
+  }
   void setAnimationBackend(std::weak_ptr<UIManagerAnimationBackend> animationBackend)
   {
     animationBackend_ = animationBackend;

package/ReactCommon/react/renderer/animations/LayoutAnimationDriver.cpp

@@ -74,6 +74,10 @@ void LayoutAnimationDriver::animationMutationsForFrame(
     }
   }
 
+  // Record boundary: animation-frame Updates above this point carry
+  // parentTag from before any structural changes and must execute first.
+  auto animationUpdatesEnd = mutationsList.size();
+
   // Clear out finished animations
   for (auto it = inflightAnimations_.begin();
        it != inflightAnimations_.end();) {
@@ -99,10 +103,11 @@ void LayoutAnimationDriver::animationMutationsForFrame(
     }
   }
 
-  // Final step: make sure that all operations execute in the proper order.
-  // REMOVE operations with highest indices must operate first.
+  // Sort only the final mutations from completed animations.
+  // Animation-frame Updates must stay before structural mutations because
+  // they reference views by their pre-structural-change parentTag.
   std::stable_sort(
-      mutationsList.begin(),
+      mutationsList.begin() + static_cast<ptrdiff_t>(animationUpdatesEnd),
       mutationsList.end(),
       &shouldFirstComeBeforeSecondMutation);
 }

package/ReactCommon/react/renderer/animations/tests/MutationComparatorTest.cpp

@@ -0,0 +1,273 @@
+/*
+ * 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 <vector>
+
+#include <gtest/gtest.h>
+
+#include <react/renderer/animations/utils.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+
+namespace facebook::react {
+
+namespace {
+
+ShadowView makeShadowView(Tag tag) {
+  ShadowView sv{};
+  sv.tag = tag;
+  return sv;
+}
+
+} // namespace
+
+// Verify strict weak ordering: irreflexivity
+// comp(a, a) must be false
+TEST(MutationComparatorTest, Irreflexivity) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  // Same-type mutations where the fallback path is exercised
+  auto update1 = ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update1, update1));
+
+  auto create1 = ShadowViewMutation::CreateMutation(sv1);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(create1, create1));
+
+  auto insert1 =
+      ShadowViewMutation::InsertMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(insert1, insert1));
+
+  auto remove1 =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(remove1, remove1));
+
+  auto del1 = ShadowViewMutation::DeleteMutation(sv1);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del1, del1));
+}
+
+// Verify strict weak ordering: asymmetry
+// If comp(a, b) then !comp(b, a)
+TEST(MutationComparatorTest, Asymmetry) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  // Two updates with same type but different parentTags (fallback path)
+  auto update1 = ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update2 = ShadowViewMutation::UpdateMutation(sv1, sv3, /*parentTag=*/20);
+
+  bool a_before_b = shouldFirstComeBeforeSecondMutation(update1, update2);
+  bool b_before_a = shouldFirstComeBeforeSecondMutation(update2, update1);
+
+  // Exactly one must be true (asymmetry)
+  EXPECT_NE(a_before_b, b_before_a);
+}
+
+// Verify strict weak ordering: transitivity
+// If comp(a, b) and comp(b, c) then comp(a, c)
+TEST(MutationComparatorTest, Transitivity) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  auto update1 = ShadowViewMutation::UpdateMutation(sv1, sv1, /*parentTag=*/10);
+  auto update2 = ShadowViewMutation::UpdateMutation(sv1, sv1, /*parentTag=*/20);
+  auto update3 = ShadowViewMutation::UpdateMutation(sv1, sv1, /*parentTag=*/30);
+
+  bool a_b = shouldFirstComeBeforeSecondMutation(update1, update2);
+  bool b_c = shouldFirstComeBeforeSecondMutation(update2, update3);
+  bool a_c = shouldFirstComeBeforeSecondMutation(update1, update3);
+
+  if (a_b && b_c) {
+    EXPECT_TRUE(a_c) << "Transitivity violated: a<b and b<c but not a<c";
+  }
+}
+
+// Verify type-based ordering rules
+TEST(MutationComparatorTest, TypeOrdering) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  auto create = ShadowViewMutation::CreateMutation(sv1);
+  auto insert =
+      ShadowViewMutation::InsertMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  auto remove =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  auto update = ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto del = ShadowViewMutation::DeleteMutation(sv1);
+
+  // Delete always comes last
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del, create));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del, insert));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del, remove));
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(create, del));
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(insert, del));
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove, del));
+
+  // Remove comes before Insert
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove, insert));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(insert, remove));
+
+  // Create comes before Insert
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(create, insert));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(insert, create));
+
+  // Remove comes before Update
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove, update));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update, remove));
+}
+
+// Verify removes on same parent are sorted by descending index
+TEST(MutationComparatorTest, RemovesSameParentDescendingIndex) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  auto remove_idx0 =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  auto remove_idx5 =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv2, /*index=*/5);
+
+  // Higher index should come first
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove_idx5, remove_idx0));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(remove_idx0, remove_idx5));
+}
+
+// Verify the deterministic fallback uses parentTag, then child tags
+TEST(MutationComparatorTest, DeterministicFallbackByParentTag) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  // Two updates with same type, different parentTags
+  auto update_p10 =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update_p20 =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/20);
+
+  // Lower parentTag comes first
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(update_p10, update_p20));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_p20, update_p10));
+}
+
+TEST(MutationComparatorTest, DeterministicFallbackByNewChildTag) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  // Same parentTag, different newChildShadowView tags
+  auto update_new2 =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update_new3 =
+      ShadowViewMutation::UpdateMutation(sv1, sv3, /*parentTag=*/10);
+
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(update_new2, update_new3));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_new3, update_new2));
+}
+
+TEST(MutationComparatorTest, DeterministicFallbackByOldChildTag) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  // Same parentTag, same newChildShadowView tag, different oldChildShadowView
+  // tags
+  auto update_old1 =
+      ShadowViewMutation::UpdateMutation(sv1, sv3, /*parentTag=*/10);
+  auto update_old2 =
+      ShadowViewMutation::UpdateMutation(sv2, sv3, /*parentTag=*/10);
+
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(update_old1, update_old2));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_old2, update_old1));
+}
+
+// Verify equal mutations return false (stability)
+TEST(MutationComparatorTest, EqualMutationsReturnFalse) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  auto update_a =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update_b =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+
+  // Two mutations with identical properties should return false (not less-than)
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_a, update_b));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_b, update_a));
+}
+
+// Verify std::stable_sort doesn't crash with the comparator
+// (the original bug was a SIGSEGV during sort)
+TEST(MutationComparatorTest, StableSortDoesNotCrash) {
+  ShadowViewMutation::List mutations;
+
+  // Build a list with various mutation types and properties
+  for (int parent = 0; parent < 5; parent++) {
+    for (int child = 0; child < 10; child++) {
+      auto sv_old = makeShadowView(child);
+      auto sv_new = makeShadowView(child + 100);
+
+      mutations.push_back(
+          ShadowViewMutation::UpdateMutation(
+              sv_old, sv_new, /*parentTag=*/parent));
+      mutations.push_back(
+          ShadowViewMutation::InsertMutation(
+              /*parentTag=*/parent, sv_new, /*index=*/child));
+      mutations.push_back(
+          ShadowViewMutation::RemoveMutation(
+              /*parentTag=*/parent, sv_old, /*index=*/child));
+    }
+  }
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeShadowView(999)));
+  mutations.push_back(ShadowViewMutation::DeleteMutation(makeShadowView(998)));
+
+  // This should not crash (the original bug was SIGSEGV here)
+  EXPECT_NO_FATAL_FAILURE(
+      std::stable_sort(
+          mutations.begin(),
+          mutations.end(),
+          &shouldFirstComeBeforeSecondMutation));
+
+  // Verify ordering invariants after sort
+  bool seen_delete = false;
+  for (const auto& m : mutations) {
+    if (m.type == ShadowViewMutation::Type::Delete) {
+      seen_delete = true;
+    } else if (seen_delete) {
+      FAIL() << "Non-delete mutation found after a delete mutation";
+    }
+  }
+}
+
+// Stress test: sort a large list of mutations with duplicates
+TEST(MutationComparatorTest, StableSortLargeListWithDuplicates) {
+  ShadowViewMutation::List mutations;
+
+  // Create many mutations with overlapping properties to stress the comparator
+  for (int i = 0; i < 200; i++) {
+    auto sv = makeShadowView(i % 10); // Deliberately create duplicates
+    auto sv2 = makeShadowView((i + 1) % 10);
+    int parent = i % 5;
+
+    mutations.push_back(ShadowViewMutation::UpdateMutation(sv, sv2, parent));
+    if (i % 3 == 0) {
+      mutations.push_back(
+          ShadowViewMutation::InsertMutation(parent, sv, i % 20));
+    }
+    if (i % 4 == 0) {
+      mutations.push_back(
+          ShadowViewMutation::RemoveMutation(parent, sv, i % 20));
+    }
+  }
+
+  EXPECT_NO_FATAL_FAILURE(
+      std::stable_sort(
+          mutations.begin(),
+          mutations.end(),
+          &shouldFirstComeBeforeSecondMutation));
+}
+
+} // namespace facebook::react