@depup/react-native 0.86.2-depup.0 → 0.87.0-depup.0

package/ReactCommon/react/renderer/animated/drivers/FrameAnimationDriver.cpp

@@ -49,15 +49,34 @@ void FrameAnimationDriver::onConfigChanged() {
     frames_.push_back(frameValue);
   }
   toValue_ = config_["toValue"].asDouble();
+  auto deferIt = config_.find("deferredStart");
+  deferredStart_ = deferIt != config_.items().end() && deferIt->second.asBool();
 }
 
-bool FrameAnimationDriver::update(double timeDeltaMs, bool /*restarting*/) {
+bool FrameAnimationDriver::update(double timeDeltaMs, bool restarting) {
   if (auto node =
           manager_->getAnimatedNode<ValueAnimatedNode>(animatedValueTag_)) {
     if (!startValue_) {
       startValue_ = node->getRawValue();
     }
 
+    if (deferredStart_ && restarting) {
+      // On the very first update after start: output the starting value
+      // (frame 0) and defer the time anchor. The base class will re-anchor
+      // startFrameTimeMs_ on the next call, so elapsed time is measured
+      // from the first frame that has actually been rendered — not from
+      // when startAnimatingNode was dispatched.
+      //
+      // This prevents skipping initial frames when the UI thread is busy
+      // with layout/mount work between animation start and first composite.
+      node->setRawValue(
+          startValue_.value() + frames_[0] * (toValue_ - startValue_.value()));
+      markNodeUpdated(node->tag());
+      startFrameTimeMs_ = -1;
+      deferredStart_ = false;
+      return false;
+    }
+
     const auto startIndex =
         static_cast<size_t>(std::round(timeDeltaMs / SingleFrameIntervalMs));
     assert(startIndex >= 0);

package/ReactCommon/react/renderer/animated/drivers/FrameAnimationDriver.h

@@ -35,6 +35,7 @@ class FrameAnimationDriver : public AnimationDriver {
   std::vector<double> frames_{};
   double toValue_{0};
   std::optional<double> startValue_{};
+  bool deferredStart_{false};
 };
 
 } // namespace facebook::react

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/react/react-native/blob/main/packages/react-native/src/private/animated/NativeAnimatedHelper.js#L35
+// https://github.com/facebook/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/animated/nodes/InterpolationAnimatedNode.cpp

@@ -12,11 +12,13 @@
 #include "InterpolationAnimatedNode.h"
 
 #include <glog/logging.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/animated/NativeAnimatedNodesManager.h>
 #include <react/renderer/animated/drivers/AnimationDriverUtils.h>
 #include <react/renderer/animated/internal/primitives.h>
 #include <react/renderer/animated/nodes/PropsAnimatedNode.h>
 #include <react/renderer/graphics/HostPlatformColor.h>
+#include <algorithm>
 
 namespace facebook::react {
 
@@ -52,6 +54,47 @@ InterpolationAnimatedNode::InterpolationAnimatedNode(
 
   extrapolateLeft_ = nodeConfig["extrapolateLeft"].asString();
   extrapolateRight_ = nodeConfig["extrapolateRight"].asString();
+
+  // Optional non-uniform easing stops baked from a JS interpolation `easing`
+  // function, as [position, value] pairs. Absent for interpolations without
+  // custom easing.
+  if (auto easingStopsIt = nodeConfig.find("easingStops");
+      easingStopsIt != nodeConfig.items().end()) {
+    const auto& easingStops = easingStopsIt->second;
+    react_native_assert(easingStops.type() == folly::dynamic::ARRAY);
+    for (const auto& stop : easingStops) {
+      react_native_assert(
+          stop.type() == folly::dynamic::ARRAY && stop.size() == 2);
+      easingStopInputs_.push_back(stop[0].asDouble());
+      easingStopOutputs_.push_back(stop[1].asDouble());
+    }
+  }
+}
+
+double InterpolationAnimatedNode::easeRatio(double ratio) const {
+  // No easing, or out-of-range ratio (extrapolation) — leave it untouched.
+  if (easingStopInputs_.size() < 2 || ratio < 0.0 || ratio > 1.0) {
+    return ratio;
+  }
+  // Binary search for the stop segment [lower, upper] bracketing `ratio`.
+  const auto it = std::upper_bound(
+      easingStopInputs_.begin(), easingStopInputs_.end(), ratio);
+  if (it == easingStopInputs_.begin()) {
+    return easingStopOutputs_.front();
+  }
+  if (it == easingStopInputs_.end()) {
+    return easingStopOutputs_.back();
+  }
+  const auto upper = static_cast<size_t>(it - easingStopInputs_.begin());
+  const auto lower = upper - 1;
+  const auto inputLo = easingStopInputs_[lower];
+  const auto inputHi = easingStopInputs_[upper];
+  if (inputHi == inputLo) {
+    return easingStopOutputs_[upper];
+  }
+  const auto weight = (ratio - inputLo) / (inputHi - inputLo);
+  return easingStopOutputs_[lower] +
+      (easingStopOutputs_[upper] - easingStopOutputs_[lower]) * weight;
 }
 
 void InterpolationAnimatedNode::update() {
@@ -91,12 +134,30 @@ double InterpolationAnimatedNode::interpolateValue(double value) {
   }
   index--;
 
+  const auto inputMin = inputRanges_[index];
+  const auto inputMax = inputRanges_[index + 1];
+  const auto outputMin = defaultOutputRanges_[index];
+  const auto outputMax = defaultOutputRanges_[index + 1];
+
+  if (!easingStopInputs_.empty() && inputMin != inputMax) {
+    const auto ratio = (value - inputMin) / (inputMax - inputMin);
+    if (ratio >= 0.0 && ratio <= 1.0) {
+      // In-range: map the eased ratio straight to the output. The easing may
+      // overshoot [0, 1] (e.g. Easing.back/elastic); that overshoot must be
+      // preserved, not clamped — it comes from the easing, not from an
+      // out-of-range input. This matches JS, where easing runs after
+      // extrapolation handling. Out-of-range inputs fall through to linear
+      // extrapolation below (the stops only cover [0, 1]).
+      return outputMin + easeRatio(ratio) * (outputMax - outputMin);
+    }
+  }
+
   return interpolate(
       value,
-      inputRanges_[index],
-      inputRanges_[index + 1],
-      defaultOutputRanges_[index],
-      defaultOutputRanges_[index + 1],
+      inputMin,
+      inputMax,
+      outputMin,
+      outputMax,
       extrapolateLeft_,
       extrapolateRight_);
 }
@@ -127,7 +188,7 @@ double InterpolationAnimatedNode::interpolateColor(double value) {
     }
   }
 
-  auto ratio = (value - inputMin) / (inputMax - inputMin);
+  auto ratio = easeRatio((value - inputMin) / (inputMax - inputMin));
 
   auto outputMinA = alphaFromHostPlatformColor(outputMin);
   auto outputMinR = redFromHostPlatformColor(outputMin);
@@ -193,7 +254,7 @@ double InterpolationAnimatedNode::interpolatePlatformColor(double value) {
     }
   }
 
-  auto ratio = (value - inputMin) / (inputMax - inputMin);
+  auto ratio = easeRatio((value - inputMin) / (inputMax - inputMin));
 
   auto outputMinA = alphaFromHostPlatformColor(outputMin);
   auto outputMinR = redFromHostPlatformColor(outputMin);

package/ReactCommon/react/renderer/animated/nodes/InterpolationAnimatedNode.h

@@ -31,12 +31,24 @@ class InterpolationAnimatedNode final : public ValueAnimatedNode {
   double interpolateColor(double value);
   double interpolatePlatformColor(double value);
 
+  // Applies the optional easing stops to a segment's normalized ratio via binary
+  // search + linear interpolation. Returns the ratio unchanged when no easing is
+  // configured or when the ratio falls outside [0, 1] (so extrapolation behavior
+  // is preserved).
+  double easeRatio(double ratio) const;
+
   SurfaceId resolveConnectedRootTag() const;
 
   std::vector<double> inputRanges_;
   std::vector<double> defaultOutputRanges_;
   std::vector<Color> colorOutputRanges_;
   std::vector<folly::dynamic> platformColorOutputRanges_;
+  // Non-uniform easing stops (RDP-simplified, CSS `linear()`-style) baked from a
+  // JS interpolation `easing` function. `easingStopInputs_` are the stop
+  // positions in [0, 1] (sorted), `easingStopOutputs_` the eased values. Both
+  // empty when the interpolation has no custom easing.
+  std::vector<double> easingStopInputs_;
+  std::vector<double> easingStopOutputs_;
   std::string extrapolateLeft_;
   std::string extrapolateRight_;
 

package/ReactCommon/react/renderer/animated/nodes/PropsAnimatedNode.cpp

@@ -12,7 +12,6 @@
 #include "PropsAnimatedNode.h"
 
 #include <react/debug/react_native_assert.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/animated/NativeAnimatedNodesManager.h>
 #include <react/renderer/animated/nodes/ColorAnimatedNode.h>
 #include <react/renderer/animated/nodes/ObjectAnimatedNode.h>
@@ -84,7 +83,7 @@ void PropsAnimatedNode::disconnectFromView(Tag viewTag) {
 void PropsAnimatedNode::restoreDefaultValues() {
   // If node is already disconnected from View, we cannot restore default values
   if (connectedViewTag_ != animated::undefinedAnimatedNodeIdentifier) {
-    if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    if (manager_->useSharedAnimatedBackend()) {
       manager_->schedulePropsCommit(
           connectedViewTag_,
           folly::dynamic::object(),
@@ -98,18 +97,9 @@ void PropsAnimatedNode::restoreDefaultValues() {
   }
 }
 
-void PropsAnimatedNode::update() {
-  return update(false);
-}
-
-void PropsAnimatedNode::update(bool forceFabricCommit) {
-  if (connectedViewTag_ == animated::undefinedAnimatedNodeIdentifier) {
-    return;
-  }
-
+void PropsAnimatedNode::collectPropsLocked() {
   // TODO: T190192206 consolidate shared update logic between
   // Props/StyleAnimatedNode
-  std::lock_guard<std::mutex> lock(propsMutex_);
   const auto& configProps = getConfig()["props"];
   for (const auto& entry : configProps.items()) {
     auto propName = entry.first.asString();
@@ -165,8 +155,30 @@ void PropsAnimatedNode::update(bool forceFabricCommit) {
   }
 
   layoutStyleUpdated_ = isLayoutStyleUpdated(getConfig()["props"], *manager_);
+}
+
+void PropsAnimatedNode::collectProps() {
+  if (connectedViewTag_ == animated::undefinedAnimatedNodeIdentifier) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(propsMutex_);
+  collectPropsLocked();
+}
+
+void PropsAnimatedNode::update() {
+  return update(false);
+}
+
+void PropsAnimatedNode::update(bool forceFabricCommit) {
+  if (connectedViewTag_ == animated::undefinedAnimatedNodeIdentifier) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(propsMutex_);
+  collectPropsLocked();
 
-  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+  if (manager_->useSharedAnimatedBackend()) {
     manager_->schedulePropsCommit(
         connectedViewTag_,
         props_,

package/ReactCommon/react/renderer/animated/nodes/PropsAnimatedNode.h

@@ -46,11 +46,18 @@ class PropsAnimatedNode final : public AnimatedNode {
     return props_;
   }
 
+  // Recompute props_ from the connected nodes WITHOUT scheduling a view
+  // commit, so getManagedProps() is live at connect with no commit side effect.
+  void collectProps();
+
   void update() override;
 
   void update(bool forceFabricCommit);
 
  private:
+  // Caller must hold propsMutex_.
+  void collectPropsLocked();
+
   std::mutex propsMutex_;
   folly::dynamic props_;
   bool layoutStyleUpdated_{false};

package/ReactCommon/react/renderer/animated/tests/AnimationDriverTests.cpp

@@ -117,4 +117,52 @@ TEST_F(AnimationDriverTests, framesAnimationReconfigurationClearsFrames) {
   EXPECT_EQ(round(nodesManager_->getValue(valueNodeTag).value()), toValue2);
 }
 
+TEST_F(AnimationDriverTests, framesAnimationDeferredStart) {
+  // Deferred start outputs frame 0 on the first update and re-anchors
+  // startFrameTimeMs_ so the second update also sees timeDelta=0.
+  // Without the defer the second frame would already be at value 25.
+  initNodesManager();
+
+  auto rootTag = getNextRootViewTag();
+
+  auto valueNodeTag = ++rootTag;
+  nodesManager_->createAnimatedNode(
+      valueNodeTag,
+      folly::dynamic::object("type", "value")("value", 0)("offset", 0));
+
+  const auto animationId = 1;
+  const auto frames = folly::dynamic::array(0.0f, 0.25f, 0.5f, 0.75f, 1.0f);
+  const auto toValue = 100;
+  nodesManager_->startAnimatingNode(
+      animationId,
+      valueNodeTag,
+      folly::dynamic::object("type", "frames")("frames", frames)(
+          "toValue", toValue)("deferredStart", true),
+      std::nullopt);
+
+  const double t = 12345;
+
+  // Frame 1: both with and without deferredStart, timeDelta=0 → value=0
+  runAnimationFrame(t);
+  EXPECT_EQ(nodesManager_->getValue(valueNodeTag).value(), 0);
+
+  // Frame 2: WITHOUT deferredStart timeDelta=SI → value≈25.
+  // WITH deferredStart the deferred start re-anchored startFrameTimeMs_, so
+  // timeDelta=0 → value=0. This assertion fails without deferredStart.
+  runAnimationFrame(t + SingleFrameIntervalMs);
+  EXPECT_EQ(nodesManager_->getValue(valueNodeTag).value(), 0);
+
+  // Frame 3: now timeDelta=SI from the re-anchored start
+  runAnimationFrame(t + SingleFrameIntervalMs * 2);
+  EXPECT_NEAR(nodesManager_->getValue(valueNodeTag).value(), 25, 0.01);
+
+  // Frame 4
+  runAnimationFrame(t + SingleFrameIntervalMs * 3);
+  EXPECT_NEAR(nodesManager_->getValue(valueNodeTag).value(), 50, 0.01);
+
+  // Complete
+  runAnimationFrame(t + SingleFrameIntervalMs * 5);
+  EXPECT_EQ(nodesManager_->getValue(valueNodeTag).value(), toValue);
+}
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/animated/tests/DecayAnimationDriverTest.cpp

@@ -0,0 +1,245 @@
+/*
+ * 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 "AnimationTestsBase.h"
+
+#include <react/renderer/animated/drivers/AnimationDriverUtils.h>
+#include <react/renderer/core/ReactRootViewTagGenerator.h>
+
+#include <cmath>
+#include <limits>
+
+namespace facebook::react {
+
+class DecayAnimationDriverTest : public AnimationTestsBase {
+ protected:
+  // Closed-form analytical value of the decay curve, used to derive expected
+  // values for assertions instead of hard-coding constants. Mirrors the
+  // formula implemented by DecayAnimationDriver::getValueAndVelocityForTime,
+  // which is:
+  //   value = fromValue + velocity / (1 - deceleration)
+  //                       * (1 - exp(-(1 - deceleration) * (1000 * time)))
+  // The driver is called with timeDeltaMs / 1000.0, so 1000 * time collapses
+  // back to timeMs.
+  static double expectedDecayValue(
+      double fromValue,
+      double velocity,
+      double deceleration,
+      double timeMs) {
+    return fromValue +
+        velocity / (1 - deceleration) *
+        (1 - std::exp(-(1 - deceleration) * timeMs));
+  }
+
+  // Create a ValueAnimatedNode with the given initial value and zero offset.
+  Tag createValueNode(double initialValue) {
+    auto tag = ++rootTag_;
+    nodesManager_->createAnimatedNode(
+        tag,
+        folly::dynamic::object("type", "value")("value", initialValue)(
+            "offset", 0));
+    return tag;
+  }
+
+  void startDecay(
+      int animationId,
+      Tag valueNodeTag,
+      double velocity,
+      double deceleration,
+      int iterations = 1) {
+    nodesManager_->startAnimatingNode(
+        animationId,
+        valueNodeTag,
+        folly::dynamic::object("type", "decay")("velocity", velocity)(
+            "deceleration", deceleration)("iterations", iterations),
+        std::nullopt);
+  }
+
+  Tag rootTag_{getNextRootViewTag()};
+};
+
+TEST_F(DecayAnimationDriverTest, decayProducesAnalyticalCurveValues) {
+  // Drives a decay animation and checks the produced values match the
+  // closed-form decay formula at multiple points along the curve. This
+  // guards the formula in getValueAndVelocityForTime against regressions
+  // (e.g. sign flips, swapped operands, exp(+x) vs exp(-x)).
+  initNodesManager();
+  const auto valueNodeTag = createValueNode(0);
+  const auto animationId = 1;
+  const double velocity = 1.0;
+  const double deceleration = 0.998;
+  startDecay(animationId, valueNodeTag, velocity, deceleration);
+
+  const double startTimeInTick = 10000;
+
+  // First frame: the timeDelta is 0, so the produced value must equal the
+  // node's starting value (fromValue is captured from the node here).
+  runAnimationFrame(startTimeInTick);
+  EXPECT_NEAR(nodesManager_->getValue(valueNodeTag).value(), 0.0, 1e-6);
+
+  // Sample the curve at several non-trivial points and compare to the
+  // analytical expectation. We feed the same wall-clock delta the driver
+  // sees (frameTimeMs - startFrameTimeMs_, which equals the offset we add
+  // to startTimeInTick).
+  for (const double dtMs : {100.0, 500.0, 1000.0}) {
+    runAnimationFrame(startTimeInTick + dtMs);
+    const auto expected = expectedDecayValue(0.0, velocity, deceleration, dtMs);
+    EXPECT_NEAR(nodesManager_->getValue(valueNodeTag).value(), expected, 1e-3);
+  }
+}
+
+TEST_F(DecayAnimationDriverTest, decayUsesNodeStartingValueAsOrigin) {
+  // The driver must capture the node's current value as fromValue on the
+  // first update — not assume 0. With a non-zero starting value the entire
+  // curve is shifted by that offset; verifying this catches a regression
+  // where fromValue defaults to 0 (a likely off-by-one mistake).
+  initNodesManager();
+  const double startingValue = 50.0;
+  const auto valueNodeTag = createValueNode(startingValue);
+  const auto animationId = 1;
+  const double velocity = 2.0;
+  const double deceleration = 0.99;
+  startDecay(animationId, valueNodeTag, velocity, deceleration);
+
+  const double startTimeInTick = 10000;
+  runAnimationFrame(startTimeInTick);
+  EXPECT_NEAR(
+      nodesManager_->getValue(valueNodeTag).value(), startingValue, 1e-6);
+
+  const double dtMs = 200.0;
+  runAnimationFrame(startTimeInTick + dtMs);
+  const auto expected =
+      expectedDecayValue(startingValue, velocity, deceleration, dtMs);
+  EXPECT_NEAR(nodesManager_->getValue(valueNodeTag).value(), expected, 1e-3);
+}
+
+TEST_F(DecayAnimationDriverTest, decayWithNegativeVelocityDecreasesValue) {
+  // A negative velocity must produce a monotonically decreasing curve that
+  // approaches the asymptote fromValue + velocity/(1-deceleration) from
+  // above. This catches sign errors in the value computation.
+  initNodesManager();
+  const double startingValue = 100.0;
+  const auto valueNodeTag = createValueNode(startingValue);
+  const auto animationId = 1;
+  const double velocity = -1.0;
+  const double deceleration = 0.998;
+  startDecay(animationId, valueNodeTag, velocity, deceleration);
+
+  const double t = 10000;
+  runAnimationFrame(t);
+  const auto v0 = nodesManager_->getValue(valueNodeTag).value();
+  EXPECT_NEAR(v0, startingValue, 1e-6);
+
+  runAnimationFrame(t + 100);
+  const auto v1 = nodesManager_->getValue(valueNodeTag).value();
+  runAnimationFrame(t + 500);
+  const auto v2 = nodesManager_->getValue(valueNodeTag).value();
+
+  // Strictly decreasing in time.
+  EXPECT_LT(v1, v0);
+  EXPECT_LT(v2, v1);
+
+  // And matches the analytical curve at a sampled point.
+  const auto expected = expectedDecayValue(startingValue, velocity, 0.998, 500);
+  EXPECT_NEAR(v2, expected, 1e-3);
+}
+
+TEST_F(DecayAnimationDriverTest, decayCompletesWhenValueStabilizes) {
+  // The driver reports completion when the change between successive frames
+  // drops below 0.1. Once complete and not running additional iterations,
+  // the node must hold a final value close to the asymptote
+  // fromValue + velocity / (1 - deceleration) and must stop updating.
+  initNodesManager();
+  const auto valueNodeTag = createValueNode(0);
+  const auto animationId = 1;
+  const double velocity = 1.0;
+  const double deceleration = 0.998;
+  startDecay(animationId, valueNodeTag, velocity, deceleration);
+
+  const double startTimeInTick = 10000;
+
+  // Drive enough frames to let the decay settle. The per-frame delta drops
+  // below 0.1 well before this many frames at 60Hz.
+  const int totalFrames = 1500;
+  for (int i = 0; i <= totalFrames; ++i) {
+    runAnimationFrame(startTimeInTick + i * SingleFrameIntervalMs);
+  }
+
+  const auto asymptote = velocity / (1 - deceleration); // == 500
+  const auto finalValue = nodesManager_->getValue(valueNodeTag).value();
+  // The completion threshold is 0.1 per frame; the settled value lands a
+  // few units short of the asymptote. A generous bound that still rules
+  // out the unsettled case (where finalValue would be far below it).
+  EXPECT_LT(std::abs(finalValue - asymptote), 10.0);
+  // Sanity check the opposite direction — the value must not have overshot
+  // the asymptote (the formula is strictly increasing toward it for
+  // positive velocity).
+  EXPECT_LE(finalValue, asymptote);
+
+  // Driving more frames after completion must not change the value: once
+  // the driver reports completion, subsequent frames are short-circuited
+  // by AnimationDriver::runAnimationStep and the node value is unchanged.
+  runAnimationFrame(
+      startTimeInTick + (totalFrames + 100) * SingleFrameIntervalMs);
+  EXPECT_NEAR(nodesManager_->getValue(valueNodeTag).value(), finalValue, 1e-6);
+}
+
+TEST_F(DecayAnimationDriverTest, decayIterationsResetValueToOrigin) {
+  // When the animation has additional iterations remaining, each iteration
+  // after the first must restart from fromValue (the value captured on the
+  // very first update), not from wherever the previous iteration ended.
+  // This exercises the `else` branch in update() that resets the node via
+  // setRawValue when restarting a subsequent iteration. We use iterations
+  // = -1 (infinite) so the driver is guaranteed to restart instead of
+  // terminating.
+  initNodesManager();
+  const double startingValue = 0.0;
+  const auto valueNodeTag = createValueNode(startingValue);
+  const auto animationId = 1;
+  const double velocity = 1.0;
+  const double deceleration = 0.998;
+  startDecay(
+      animationId, valueNodeTag, velocity, deceleration, /*iterations=*/-1);
+
+  const double startTimeInTick = 10000;
+
+  // First frame anchors fromValue at startingValue and emits it.
+  runAnimationFrame(startTimeInTick);
+  ASSERT_NEAR(
+      nodesManager_->getValue(valueNodeTag).value(), startingValue, 1e-6);
+
+  // Walk frame-by-frame until we observe a value drop from one frame to
+  // the next. Decay with positive velocity is strictly monotone, so the
+  // only way the observed value can decrease is if the driver completed
+  // an iteration and reset the node back to fromValue at the start of
+  // the next one. With velocity=1, deceleration=0.998, fromValue=0 the
+  // asymptote is 500, so any reset produces a multi-hundred-unit drop —
+  // not a fragile near-equality.
+  double previousValue = nodesManager_->getValue(valueNodeTag).value();
+  bool sawReset = false;
+  double resetValue = std::numeric_limits<double>::quiet_NaN();
+  // Bound the loop generously — the completion threshold (per-frame delta
+  // < 0.1) is reached in a couple hundred frames for these parameters.
+  constexpr int kMaxFrames = 600;
+  for (int i = 1; i <= kMaxFrames; ++i) {
+    runAnimationFrame(startTimeInTick + i * SingleFrameIntervalMs);
+    const auto current = nodesManager_->getValue(valueNodeTag).value();
+    if (current < previousValue) {
+      sawReset = true;
+      resetValue = current;
+      break;
+    }
+    previousValue = current;
+  }
+
+  ASSERT_TRUE(sawReset);
+  // After the reset, the very next frame of the new iteration emits the
+  // starting value (timeDelta=0 ⇒ value=fromValue).
+  EXPECT_NEAR(resetValue, startingValue, 1e-6);
+}
+
+} // namespace facebook::react