react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/ReactCommon/react/nativemodule/mutationobserver/NativeMutationObserver.h

@@ -7,7 +7,11 @@
 
 #pragma once
 
+#if __has_include("FBReactNativeSpecJSI.h") // CocoaPod headers on Apple
+#include "FBReactNativeSpecJSI.h"
+#else
 #include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#endif
 #include <react/renderer/bridging/bridging.h>
 #include <react/renderer/observers/mutation/MutationObserverManager.h>
 #include <react/renderer/uimanager/UIManager.h>

package/ReactCommon/react/nativemodule/mutationobserver/React-mutationobservernativemodule.podspec

@@ -0,0 +1,66 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we're presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+header_search_paths = [
+  "\"$(PODS_ROOT)/Headers/Private/Yoga\"",
+]
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/../../..\"" # this is needed to allow the module access its own files
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-mutationobservernativemodule"
+  s.version                = version
+  s.summary                = "React Native mutation observer native module"
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("*.{cpp,h}", "*.h")
+  s.header_dir             = "react/nativemodule/mutationobserver"
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
+                               "OTHER_CFLAGS" => "$(inherited)",
+                               "DEFINES_MODULE" => "YES" }
+
+  if ENV['USE_FRAMEWORKS']
+    s.module_name            = "mutationobservernativemodule"
+    s.header_mappings_dir  = "../.."
+  end
+
+  s.dependency "Yoga"
+  s.dependency "React-jsi"
+  s.dependency "React-jsiexecutor"
+  s.dependency "React-cxxreact"
+
+  depend_on_js_engine(s)
+  add_rn_third_party_dependencies(s)
+  add_rncore_dependency(s)
+
+  s.dependency "ReactCommon/turbomodule/core"
+
+  s.dependency "React-Fabric"
+  s.dependency "React-Fabric/bridging"
+  s.dependency "React-Fabric/observers/mutation"
+  s.dependency "React-featureflags"
+  add_dependency(s, "React-RCTFBReactNativeSpec")
+  add_dependency(s, "React-runtimeexecutor", :additional_framework_paths => ["platform/ios"])
+
+end

package/ReactCommon/react/nativemodule/viewtransition/CMakeLists.txt

@@ -0,0 +1,24 @@
+# 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.
+
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(${REACT_COMMON_DIR}/cmake-utils/react-native-flags.cmake)
+
+file(GLOB react_nativemodule_viewtransition_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(react_nativemodule_viewtransition OBJECT ${react_nativemodule_viewtransition_SRC})
+
+target_include_directories(react_nativemodule_viewtransition PUBLIC ${REACT_COMMON_DIR})
+
+target_link_libraries(react_nativemodule_viewtransition
+        react_codegen_rncore
+        react_cxxreact
+        react_renderer_bridging
+        react_renderer_core
+        react_renderer_uimanager
+)
+target_compile_reactnative_options(react_nativemodule_viewtransition PRIVATE)
+target_compile_options(react_nativemodule_viewtransition PRIVATE -Wpedantic)

package/ReactCommon/react/nativemodule/viewtransition/NativeViewTransition.cpp

@@ -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.
+ */
+
+#include "NativeViewTransition.h"
+
+#include <react/renderer/uimanager/UIManagerBinding.h>
+
+#ifdef RN_DISABLE_OSS_PLUGIN_HEADER
+#include "Plugins.h"
+#endif
+
+std::shared_ptr<facebook::react::TurboModule>
+NativeViewTransitionModuleProvider(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+  return std::make_shared<facebook::react::NativeViewTransition>(
+      std::move(jsInvoker));
+}
+
+namespace facebook::react {
+
+NativeViewTransition::NativeViewTransition(
+    std::shared_ptr<CallInvoker> jsInvoker)
+    : NativeViewTransitionCxxSpec(std::move(jsInvoker)) {}
+
+std::optional<jsi::Object> NativeViewTransition::getViewTransitionInstance(
+    jsi::Runtime& rt,
+    const std::string& name,
+    const std::string& pseudo) {
+  auto& uiManager = UIManagerBinding::getBinding(rt)->getUIManager();
+  auto* viewTransitionDelegate = uiManager.getViewTransitionDelegate();
+  if (viewTransitionDelegate == nullptr) {
+    return std::nullopt;
+  }
+
+  auto instance =
+      viewTransitionDelegate->getViewTransitionInstance(name, pseudo);
+  if (!instance) {
+    return std::nullopt;
+  }
+
+  auto result = jsi::Object(rt);
+  result.setProperty(rt, "x", instance->x);
+  result.setProperty(rt, "y", instance->y);
+  result.setProperty(rt, "width", instance->width);
+  result.setProperty(rt, "height", instance->height);
+  result.setProperty(rt, "nativeTag", static_cast<double>(instance->nativeTag));
+  return result;
+}
+
+jsi::Value NativeViewTransition::findPseudoElementShadowNodeByTag(
+    jsi::Runtime& rt,
+    double reactTag) {
+  auto& uiManager = UIManagerBinding::getBinding(rt)->getUIManager();
+  auto* viewTransitionDelegate = uiManager.getViewTransitionDelegate();
+  if (viewTransitionDelegate != nullptr) {
+    auto shadowNode = viewTransitionDelegate->findPseudoElementShadowNodeByTag(
+        static_cast<Tag>(reactTag));
+    if (shadowNode) {
+      return Bridging<std::shared_ptr<const ShadowNode>>::toJs(rt, shadowNode);
+    }
+  }
+
+  return jsi::Value::null();
+}
+
+void NativeViewTransition::waitForTransitionAnimation(
+    jsi::Runtime& rt,
+    double animationId) {
+  auto& uiManager = UIManagerBinding::getBinding(rt)->getUIManager();
+  auto* viewTransitionDelegate = uiManager.getViewTransitionDelegate();
+  if (viewTransitionDelegate != nullptr) {
+    viewTransitionDelegate->waitForTransitionAnimation(
+        static_cast<int>(animationId));
+  }
+}
+
+void NativeViewTransition::transitionAnimationFinished(
+    jsi::Runtime& rt,
+    double animationId) {
+  auto& uiManager = UIManagerBinding::getBinding(rt)->getUIManager();
+  auto* viewTransitionDelegate = uiManager.getViewTransitionDelegate();
+  if (viewTransitionDelegate != nullptr) {
+    viewTransitionDelegate->transitionAnimationFinished(
+        static_cast<int>(animationId));
+  }
+}
+
+} // namespace facebook::react

package/ReactCommon/react/nativemodule/viewtransition/NativeViewTransition.h

@@ -0,0 +1,37 @@
+/*
+ * 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 <optional>
+#include <string>
+
+#if __has_include("FBReactNativeSpecJSI.h") // CocoaPod headers on Apple
+#include "FBReactNativeSpecJSI.h"
+#else
+#include <FBReactNativeSpec/FBReactNativeSpecJSI.h>
+#endif
+
+#include <react/renderer/bridging/bridging.h>
+
+namespace facebook::react {
+
+class NativeViewTransition : public NativeViewTransitionCxxSpec<NativeViewTransition> {
+ public:
+  explicit NativeViewTransition(std::shared_ptr<CallInvoker> jsInvoker);
+
+  std::optional<jsi::Object>
+  getViewTransitionInstance(jsi::Runtime &rt, const std::string &name, const std::string &pseudo);
+
+  jsi::Value findPseudoElementShadowNodeByTag(jsi::Runtime &rt, double reactTag);
+
+  void waitForTransitionAnimation(jsi::Runtime &rt, double animationId);
+
+  void transitionAnimationFinished(jsi::Runtime &rt, double animationId);
+};
+
+} // namespace facebook::react

package/ReactCommon/react/nativemodule/viewtransition/React-viewtransitionnativemodule.podspec

@@ -0,0 +1,58 @@
+# 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.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we're presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+header_search_paths = [
+  "\"$(PODS_ROOT)/Headers/Private/Yoga\"",
+]
+
+if ENV['USE_FRAMEWORKS']
+  header_search_paths << "\"$(PODS_TARGET_SRCROOT)/../../..\"" # this is needed to allow the viewtransitionnativemodule to access its own files
+end
+
+Pod::Spec.new do |s|
+  s.name                   = "React-viewtransitionnativemodule"
+  s.version                = version
+  s.summary                = "React Native view transition native module"
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Meta Platforms, Inc. and its affiliates"
+  s.platforms              = min_supported_versions
+  s.source                 = source
+  s.source_files           = podspec_sources("*.{cpp,h}", "*.h")
+  s.header_dir             = "react/nativemodule/viewtransition"
+  s.pod_target_xcconfig    = { "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
+                               "HEADER_SEARCH_PATHS" => header_search_paths.join(' '),
+                               "OTHER_CFLAGS" => "$(inherited)",
+                               "DEFINES_MODULE" => "YES" }
+
+  resolve_use_frameworks(s, header_mappings_dir: "../..", module_name: "React_viewtransitionnativemodule")
+
+  s.dependency "React-jsi"
+  s.dependency "React-jsiexecutor"
+
+  depend_on_js_engine(s)
+  add_rn_third_party_dependencies(s)
+  add_rncore_dependency(s)
+
+  s.dependency "Yoga"
+  s.dependency "ReactCommon/turbomodule/core"
+  s.dependency "React-Fabric"
+  s.dependency "React-Fabric/bridging"
+  add_dependency(s, "React-runtimeexecutor", :additional_framework_paths => ["platform/ios"])
+  add_dependency(s, "React-RCTFBReactNativeSpec")
+end

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.cpp

@@ -34,6 +34,15 @@ namespace facebook::react {
 
 namespace {
 
+/**
+ * Default `durationThreshold` (in milliseconds) applied to `event` entries when
+ * the JS API does not provide an explicit value. Per the W3C Event Timing
+ * spec, observers for `event` entries default to a 104ms threshold:
+ * https://www.w3.org/TR/event-timing/#sec-modifications-perf-timeline
+ */
+constexpr HighResDuration DEFAULT_EVENT_DURATION_THRESHOLD =
+    HighResDuration::fromMilliseconds(104);
+
 class PerformanceObserverWrapper : public jsi::NativeState {
  public:
   explicit PerformanceObserverWrapper(
@@ -337,7 +346,7 @@ void NativePerformance::observe(
   }
 
   auto durationThreshold =
-      options.durationThreshold.value_or(HighResDuration::zero());
+      options.durationThreshold.value_or(DEFAULT_EVENT_DURATION_THRESHOLD);
 
   // observer of type multiple
   if (options.entryTypes.has_value()) {

package/ReactCommon/react/networking/NetworkReporter.h

@@ -9,7 +9,6 @@
 
 #include "NetworkTypes.h"
 
-#include <folly/dynamic.h>
 #include <react/timing/primitives.h>
 
 #include <mutex>

package/ReactCommon/react/performance/cdpmetrics/CdpPerfIssuesReporter.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <ReactCommon/RuntimeExecutor.h>
-#include <folly/dynamic.h>
 #include <jsi/jsi.h>
 #include <react/performance/timeline/PerformanceEntry.h>
 #include <react/performance/timeline/PerformanceEntryReporterListeners.h>

package/ReactCommon/react/performance/timeline/PerformanceEntry.h

@@ -80,7 +80,7 @@ using PerformanceEntry = std::variant<
     PerformanceResourceTiming>;
 
 struct PerformanceEntrySorter {
-  bool operator()(const PerformanceEntry &lhs, const PerformanceEntry &rhs)
+  bool operator()(const PerformanceEntry &lhs, const PerformanceEntry &rhs) const
   {
     return std::visit(
         [](const auto &left, const auto &right) {

package/ReactCommon/react/performance/timeline/PerformanceObserver.cpp

@@ -25,16 +25,21 @@ void PerformanceObserver::handleEntry(const PerformanceEntry& entry) {
       return;
     }
 
-    buffer_.push_back(entry);
+    {
+      std::lock_guard lock(bufferMutex_);
+      buffer_.push_back(entry);
+    }
     scheduleFlushBuffer();
   }
 }
 
 std::vector<PerformanceEntry> PerformanceObserver::takeRecords() {
   std::vector<PerformanceEntry> result;
-  buffer_.swap(result);
-
-  didScheduleFlushBuffer_ = false;
+  {
+    std::lock_guard lock(bufferMutex_);
+    buffer_.swap(result);
+    didScheduleFlushBuffer_ = false;
+  }
 
   return result;
 }
@@ -87,9 +92,16 @@ void PerformanceObserver::disconnect() noexcept {
 }
 
 void PerformanceObserver::scheduleFlushBuffer() {
-  if (!didScheduleFlushBuffer_) {
-    didScheduleFlushBuffer_ = true;
+  bool shouldSchedule = false;
+  {
+    std::lock_guard lock(bufferMutex_);
+    if (!didScheduleFlushBuffer_) {
+      didScheduleFlushBuffer_ = true;
+      shouldSchedule = true;
+    }
+  }
 
+  if (shouldSchedule) {
     callback_();
   }
 }

package/ReactCommon/react/performance/timeline/PerformanceObserver.h

@@ -14,6 +14,7 @@
 
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <unordered_set>
 #include <vector>
 
@@ -126,6 +127,7 @@ class PerformanceObserver : public std::enable_shared_from_this<PerformanceObser
 
   /// https://www.w3.org/TR/event-timing/#sec-modifications-perf-timeline
   HighResDuration durationThreshold_ = DEFAULT_DURATION_THRESHOLD;
+  std::mutex bufferMutex_;
   std::vector<PerformanceEntry> buffer_;
   bool didScheduleFlushBuffer_ = false;
   bool requiresDroppedEntries_ = false;

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
@@ -555,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/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

@@ -257,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,6 +55,7 @@ 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;

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/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);
 }