react-native 0.85.1 → 0.85.3

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsDynamicProvider.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<db6a2d2e1d96e088574d91ae2825fe5e>>
+ * @generated SignedSource<<e2a6a7a32ffbf20eb8906dfa526a5f9b>>
  */
 
 /**
@@ -414,6 +414,15 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::enableModuleArgumentNSNullConversionIOS();
   }
 
+  bool enableMutationObserverByDefault() override {
+    auto value = values_["enableMutationObserverByDefault"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::enableMutationObserverByDefault();
+  }
+
   bool enableNativeCSSParsing() override {
     auto value = values_["enableNativeCSSParsing"];
     if (!value.isNull()) {
@@ -576,6 +585,15 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::fuseboxEnabledRelease();
   }
 
+  bool fuseboxFrameRecordingEnabled() override {
+    auto value = values_["fuseboxFrameRecordingEnabled"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::fuseboxFrameRecordingEnabled();
+  }
+
   bool fuseboxNetworkInspectionEnabled() override {
     auto value = values_["fuseboxNetworkInspectionEnabled"];
     if (!value.isNull()) {
@@ -585,6 +603,15 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::fuseboxNetworkInspectionEnabled();
   }
 
+  bool fuseboxScreenshotCaptureEnabled() override {
+    auto value = values_["fuseboxScreenshotCaptureEnabled"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::fuseboxScreenshotCaptureEnabled();
+  }
+
   bool hideOffscreenVirtualViewsOnIOS() override {
     auto value = values_["hideOffscreenVirtualViewsOnIOS"];
     if (!value.isNull()) {
@@ -639,6 +666,24 @@ class ReactNativeFeatureFlagsDynamicProvider : public ReactNativeFeatureFlagsDef
     return ReactNativeFeatureFlagsDefaults::preventShadowTreeCommitExhaustion();
   }
 
+  bool redBoxV2Android() override {
+    auto value = values_["redBoxV2Android"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::redBoxV2Android();
+  }
+
+  bool redBoxV2IOS() override {
+    auto value = values_["redBoxV2IOS"];
+    if (!value.isNull()) {
+      return value.getBool();
+    }
+
+    return ReactNativeFeatureFlagsDefaults::redBoxV2IOS();
+  }
+
   bool shouldPressibilityUseW3CPointerEventsForHover() override {
     auto value = values_["shouldPressibilityUseW3CPointerEventsForHover"];
     if (!value.isNull()) {

package/ReactCommon/react/featureflags/ReactNativeFeatureFlagsProvider.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<43e301c5028a2ed195e2a3d0a4cd0ab3>>
+ * @generated SignedSource<<ba443ccb843898a70e1968ba5d4ab62c>>
  */
 
 /**
@@ -66,6 +66,7 @@ class ReactNativeFeatureFlagsProvider {
   virtual bool enableLayoutAnimationsOnIOS() = 0;
   virtual bool enableMainQueueCoordinatorOnIOS() = 0;
   virtual bool enableModuleArgumentNSNullConversionIOS() = 0;
+  virtual bool enableMutationObserverByDefault() = 0;
   virtual bool enableNativeCSSParsing() = 0;
   virtual bool enableNetworkEventReporting() = 0;
   virtual bool enablePreparedTextLayout() = 0;
@@ -84,13 +85,17 @@ class ReactNativeFeatureFlagsProvider {
   virtual bool fixTextClippingAndroid15useBoundsForWidth() = 0;
   virtual bool fuseboxAssertSingleHostState() = 0;
   virtual bool fuseboxEnabledRelease() = 0;
+  virtual bool fuseboxFrameRecordingEnabled() = 0;
   virtual bool fuseboxNetworkInspectionEnabled() = 0;
+  virtual bool fuseboxScreenshotCaptureEnabled() = 0;
   virtual bool hideOffscreenVirtualViewsOnIOS() = 0;
   virtual bool overrideBySynchronousMountPropsAtMountingAndroid() = 0;
   virtual bool perfIssuesEnabled() = 0;
   virtual bool perfMonitorV2Enabled() = 0;
   virtual double preparedTextCacheSize() = 0;
   virtual bool preventShadowTreeCommitExhaustion() = 0;
+  virtual bool redBoxV2Android() = 0;
+  virtual bool redBoxV2IOS() = 0;
   virtual bool shouldPressibilityUseW3CPointerEventsForHover() = 0;
   virtual bool shouldTriggerResponderTransferOnScrollAndroid() = 0;
   virtual bool skipActivityIdentityAssertionOnHostPause() = 0;

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

@@ -22,6 +22,7 @@ target_link_libraries(react_nativemodule_defaults
         react_nativemodule_microtasks
         react_nativemodule_idlecallbacks
         react_nativemodule_intersectionobserver
+        react_nativemodule_mutationobserver
         react_nativemodule_webperformance
         react_renderer_animated
 )

package/ReactCommon/react/nativemodule/defaults/DefaultTurboModules.cpp

@@ -12,6 +12,7 @@
 #include <react/nativemodule/idlecallbacks/NativeIdleCallbacks.h>
 #include <react/nativemodule/intersectionobserver/NativeIntersectionObserver.h>
 #include <react/nativemodule/microtasks/NativeMicrotasks.h>
+#include <react/nativemodule/mutationobserver/NativeMutationObserver.h>
 #include <react/nativemodule/webperformance/NativePerformance.h>
 #include <react/renderer/animated/AnimatedModule.h>
 
@@ -50,6 +51,12 @@ namespace facebook::react {
     }
   }
 
+  if (ReactNativeFeatureFlags::enableMutationObserverByDefault()) {
+    if (name == NativeMutationObserver::kModuleName) {
+      return std::make_shared<NativeMutationObserver>(jsInvoker);
+    }
+  }
+
   if (ReactNativeFeatureFlags::cxxNativeAnimatedEnabled() &&
       ReactNativeFeatureFlags::useSharedAnimatedBackend() &&
       name == AnimatedModule::kModuleName) {

package/ReactCommon/react/nativemodule/defaults/React-defaultsnativemodule.podspec

@@ -53,6 +53,7 @@ Pod::Spec.new do |s|
   s.dependency "React-microtasksnativemodule"
   s.dependency "React-idlecallbacksnativemodule"
   s.dependency "React-intersectionobservernativemodule"
+  s.dependency "React-mutationobservernativemodule"
   s.dependency "React-webperformancenativemodule"
   s.dependency "React-Fabric/animated"
   add_dependency(s, "React-RCTFBReactNativeSpec")

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.cpp

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<006c43555032f785207c6c013f1974f5>>
+ * @generated SignedSource<<4dd16dbf31dc31860960aa2abcb7862d>>
  */
 
 /**
@@ -249,6 +249,11 @@ bool NativeReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS(
   return ReactNativeFeatureFlags::enableModuleArgumentNSNullConversionIOS();
 }
 
+bool NativeReactNativeFeatureFlags::enableMutationObserverByDefault(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::enableMutationObserverByDefault();
+}
+
 bool NativeReactNativeFeatureFlags::enableNativeCSSParsing(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::enableNativeCSSParsing();
@@ -339,11 +344,21 @@ bool NativeReactNativeFeatureFlags::fuseboxEnabledRelease(
   return ReactNativeFeatureFlags::fuseboxEnabledRelease();
 }
 
+bool NativeReactNativeFeatureFlags::fuseboxFrameRecordingEnabled(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::fuseboxFrameRecordingEnabled();
+}
+
 bool NativeReactNativeFeatureFlags::fuseboxNetworkInspectionEnabled(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::fuseboxNetworkInspectionEnabled();
 }
 
+bool NativeReactNativeFeatureFlags::fuseboxScreenshotCaptureEnabled(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::fuseboxScreenshotCaptureEnabled();
+}
+
 bool NativeReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::hideOffscreenVirtualViewsOnIOS();
@@ -374,6 +389,16 @@ bool NativeReactNativeFeatureFlags::preventShadowTreeCommitExhaustion(
   return ReactNativeFeatureFlags::preventShadowTreeCommitExhaustion();
 }
 
+bool NativeReactNativeFeatureFlags::redBoxV2Android(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::redBoxV2Android();
+}
+
+bool NativeReactNativeFeatureFlags::redBoxV2IOS(
+    jsi::Runtime& /*runtime*/) {
+  return ReactNativeFeatureFlags::redBoxV2IOS();
+}
+
 bool NativeReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover(
     jsi::Runtime& /*runtime*/) {
   return ReactNativeFeatureFlags::shouldPressibilityUseW3CPointerEventsForHover();

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<525d64b15e1b72440743363280116c6a>>
+ * @generated SignedSource<<ed4a87c5d258ebf5aa61e7d74d1b09be>>
  */
 
 /**
@@ -118,6 +118,8 @@ class NativeReactNativeFeatureFlags
 
   bool enableModuleArgumentNSNullConversionIOS(jsi::Runtime& runtime);
 
+  bool enableMutationObserverByDefault(jsi::Runtime& runtime);
+
   bool enableNativeCSSParsing(jsi::Runtime& runtime);
 
   bool enableNetworkEventReporting(jsi::Runtime& runtime);
@@ -154,8 +156,12 @@ class NativeReactNativeFeatureFlags
 
   bool fuseboxEnabledRelease(jsi::Runtime& runtime);
 
+  bool fuseboxFrameRecordingEnabled(jsi::Runtime& runtime);
+
   bool fuseboxNetworkInspectionEnabled(jsi::Runtime& runtime);
 
+  bool fuseboxScreenshotCaptureEnabled(jsi::Runtime& runtime);
+
   bool hideOffscreenVirtualViewsOnIOS(jsi::Runtime& runtime);
 
   bool overrideBySynchronousMountPropsAtMountingAndroid(jsi::Runtime& runtime);
@@ -168,6 +174,10 @@ class NativeReactNativeFeatureFlags
 
   bool preventShadowTreeCommitExhaustion(jsi::Runtime& runtime);
 
+  bool redBoxV2Android(jsi::Runtime& runtime);
+
+  bool redBoxV2IOS(jsi::Runtime& runtime);
+
   bool shouldPressibilityUseW3CPointerEventsForHover(jsi::Runtime& runtime);
 
   bool shouldTriggerResponderTransferOnScrollAndroid(jsi::Runtime& runtime);

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/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/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -515,7 +515,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();

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) {

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

@@ -60,10 +60,19 @@ class AnimationBackend : public UIManagerAnimationBackend {
 
   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/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/uimanager/UIManagerAnimationBackend.h

@@ -31,6 +31,7 @@ class UIManagerAnimationBackend {
   virtual void stop(CallbackId callbackId) = 0;
   virtual void clearRegistry(SurfaceId surfaceId) = 0;
   virtual void trigger() = 0;
+  virtual void pushAnimationMutations(const Callback &callback) = 0;
   virtual void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) = 0;
 };