react-native-smooth-clip-view 0.2.5 → 0.2.6

package/android/src/main/cpp/SmoothClipRegistry.cpp

@@ -1,7 +1,8 @@
 #include "SmoothClipAndroid.h"
+#include "SmoothClipAnimationId.h"
+#include "SmoothClipAnimationCurve.h"
 #include "SmoothClipVelocityTracker.h"
 
-#include <android/choreographer.h>
 #include <fbjni/fbjni.h>
 
 #include <algorithm>
@@ -26,6 +27,20 @@ using facebook::jni::global_ref;
 enum class Ownership { Interactive, Native };
 enum class AnimationKind { Timing, Spring, Keyframes };
 
+// Load-bearing invariant, not just a convenience clock: advance()'s frame-clock
+// anchor compares this value ABSOLUTELY against a choreographer frame stamp
+// (std::min), so the two must share an epoch. They do — bionic's steady_clock,
+// System.nanoTime() behind Choreographer#frameTimeNanos, and the
+// SystemClock.uptimeMillis() Reanimated stamps its own animations with are all
+// CLOCK_MONOTONIC since boot. (The anchor this replaced subtracted two samples
+// of this clock and was epoch-independent; the min() is not.)
+//
+// Breaking that invariant fails silently and asymmetrically. A frame axis
+// running BEHIND the wall axis degrades quietly: min() always adopts the frame
+// stamp and animations lose only their sub-frame start offset. A frame axis
+// running AHEAD is fatal: min() always keeps startedAtS, the first fraction
+// (frame - startedAtS)/duration clamps to 1, and every animation completes on
+// its first frame.
 double nowSeconds() {
   return std::chrono::duration<double>(
              std::chrono::steady_clock::now().time_since_epoch())
@@ -40,26 +55,34 @@ struct ActiveAnimation {
   Presentation current{{0, 0, 0, 0, 0}, 0, 0};
   TimingAnimation timing{};
   SpringAnimation spring{};
-  std::vector<Keyframe> keyframes;
+  // Owns the keyframes and their precomputed monotone-cubic tangents; the
+  // tangent solve happens on reset(), never per frame.
+  KeyframeCurve keyframes;
   double durationS = 0;
   double startedAtS = 0;
-  // Wall-clock twin of startedAtS: stamped together with it, NEVER rebased
-  // by the frame-clock anchor. Readers that need honest wall elapsed (the
-  // unregister re-latch remainder, the run-ahead guard) use this; the
-  // animation curve itself paces on the anchored startedAtS frame axis.
+  // Wall-clock twin of startedAtS: stamped together with it, NEVER moved by
+  // the frame-clock anchor. The unregister re-latch remainder needs honest
+  // wall elapsed and reads this; the animation curve itself paces on the
+  // anchored startedAtS frame axis.
   double wallStartedAtS = 0;
   // Integrated spring state (channels: x, y, width, height, radius, tx, ty).
   std::array<double, 7> springPosition{};
   std::array<double, 7> springVelocity{};
   double lastFrameS = 0;
   bool finished = true;
-  // False while the animation is latched: built before any host view
-  // registered, held un-rendered (and out of animatingDrivers()) until the
-  // first registerViewAndroid rebases the clock and starts it.
+  // False while the animation is latched, and held out of animatingDrivers()
+  // so it cannot tick. Two ways in: built before any host view could display
+  // (pre-registration, or a detached/unsized host), or re-latched by
+  // unregisterViewAndroid when the last DISPLAYABLE host left mid-flight.
+  // Started by whichever of registerViewAndroid, setViewHostGeometryAndroid or
+  // viewBecameDisplayableAndroid first sees a displayable entry; each rebases
+  // the clock through startLatchedAnimation.
   bool started = false;
   // False until the first advance() translates the wall-clock start stamp
   // onto the choreographer frame-time axis (elapsed-preserving). Every
-  // startedAtS stamp clears it so a re-latched resume re-anchors too.
+  // startedAtS stamp clears it so a re-latched resume re-anchors too — except
+  // a start that carried the JS-captured Reanimated stamp, which arrives
+  // pre-anchored (see startAnimation) and must not be min()'d again.
   bool frameClockAnchored = false;
 };
 
@@ -79,7 +102,6 @@ struct DriverState {
   Ownership ownership = Ownership::Interactive;
   std::vector<ViewEntry> views;
   std::optional<ActiveAnimation> animation;
-  int32_t nextAnimationId = 0;
   // Set by destroyDriver while views are still registered (StrictMode effect
   // replay, hosts mounted in another subtree). The entry is erased when the
   // last view leaves and revived by a take-ownership setPresentation.
@@ -131,7 +153,7 @@ struct JLooper : facebook::jni::JavaClass<JLooper> {
 std::atomic<pid_t> gMainThreadId{0};
 
 // The registry, the frame loop, and every view mutation are main-thread only:
-// AChoreographer_getInstance is per-thread, and binding the loop to the JS
+// Choreographer.getInstance() is per-thread, and binding the loop to the JS
 // thread would race Fabric mounting and mutate views off-main. The worklets
 // UI runtime executes on the main thread, so supported usage always passes;
 // direct off-main calls fail defined instead of racing.
@@ -155,72 +177,47 @@ bool isOnMainThread() {
 
 // --- Frame loop -----------------------------------------------------------
 
+// fbjni handle for the Kotlin frame-loop bridge. The loop posts through the
+// Java Choreographer (CALLBACK_ANIMATION) rather than the NDK AChoreographer:
+// the NDK instance is a separate frame source on the main Looper whose
+// ordering against the Java Choreographer's traversal (draw) phase is
+// undefined, so advances landing after the traversal presented one vsync
+// late — a randomly flipping ±1-frame phase between the clip and Reanimated
+// content. Posting into the same doFrame pass as Reanimated makes every
+// advance precede the draw by construction. It also retires the 32-bit
+// truncated-timestamp fallback: Java frameTimeNanos is a jlong everywhere.
+//
+// doCallbacks() extracts by wall-now rather than by frame time, so a post
+// issued from an earlier phase of a frame already in flight (CALLBACK_INPUT —
+// a gesture end that starts an animation) runs in that same doFrame instead
+// of the next one. Harmless (the fraction is ~0 and the write dedupes in
+// Kotlin) and one frame cheaper at the handoff than the NDK path allowed.
+struct JSmoothClipBindings : facebook::jni::JavaClass<JSmoothClipBindings> {
+  static constexpr auto kJavaDescriptor =
+      "Lcom/smoothclipview/SmoothClipBindings;";
+};
+
 bool gFrameScheduled = false;
 void onFrameImpl(double now);
-void onFrameLegacy(long frameTimeNanos, void *data);
 
 void scheduleFrame() {
   if (gFrameScheduled) return;
   // Defensive: never bind the per-thread choreographer to a non-main thread.
   if (!isOnMainThread()) return;
-  AChoreographer *choreographer = AChoreographer_getInstance();
-  if (choreographer == nullptr) return;
+  static const auto scheduleMethod =
+      JSmoothClipBindings::javaClassStatic()->getStaticMethod<void()>(
+          "scheduleFrame");
+  scheduleMethod(JSmoothClipBindings::javaClassStatic());
+  // Set only after a successful post: if the up-call ever threw with the flag
+  // already true, the loop would be dead until process restart.
   gFrameScheduled = true;
-  // AChoreographer_postFrameCallback64 (API 29+) only matters on 32-bit ABIs,
-  // where `long` truncates the timestamp; onFrameLegacy falls back to the
-  // clock there, so the legacy entry point covers every case.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
-  AChoreographer_postFrameCallback(choreographer, &onFrameLegacy, nullptr);
-#pragma clang diagnostic pop
 }
 
 // --- Math (ported from SmoothClipRegistry.kt so both platforms match) -----
-
-double clamp01(double value) { return std::min(1.0, std::max(0.0, value)); }
-
-double cubicBezier(
-    double x1,
-    double y1,
-    double x2,
-    double y2,
-    double input) {
-  double low = 0;
-  double high = 1;
-  for (int iteration = 0; iteration < 14; iteration += 1) {
-    const double t = (low + high) / 2;
-    const double inverse = 1 - t;
-    const double x = 3 * inverse * inverse * t * x1 +
-        3 * inverse * t * t * x2 + t * t * t;
-    if (x < input) {
-      low = t;
-    } else {
-      high = t;
-    }
-  }
-  const double t = (low + high) / 2;
-  const double inverse = 1 - t;
-  return 3 * inverse * inverse * t * y1 + 3 * inverse * t * t * y2 +
-      t * t * t;
-}
-
-// Presentation <-> per-channel array (x, y, width, height, radius, tx, ty).
-std::array<double, 7> toChannels(const Presentation &presentation) {
-  return {presentation.clip.x,
-          presentation.clip.y,
-          presentation.clip.width,
-          presentation.clip.height,
-          presentation.clip.radius,
-          presentation.contentTranslateX,
-          presentation.contentTranslateY};
-}
-
-Presentation fromChannels(const std::array<double, 7> &channels) {
-  return Presentation{
-      {channels[0], channels[1], channels[2], channels[3], channels[4]},
-      channels[5],
-      channels[6]};
-}
+//
+// clamp01, toChannels/fromChannels, interpolate, the frame-clock anchor and the
+// keyframe curve now live in cpp/SmoothClipAnimationCurve.h so a test binary can
+// reach them without linking fbjni; ios/tests pins their behavior.
 
 // Springs settle below these per-channel thresholds (DIP and DIP/s).
 constexpr double kSpringSettleDisplacement = 0.05;
@@ -228,13 +225,6 @@ constexpr double kSpringSettleVelocity = 1.0;
 // Settle-based termination is backed by a hard cap so a pathological
 // configuration cannot run the frame loop forever.
 constexpr double kSpringMaxDurationS = 10.0;
-// Fixed slack for the post-stall run-ahead guard in advance(). The lead it
-// bounds is a latency DIFFERENTIAL — the anchor frame's dispatch latency
-// minus the current frame's — so the constant is refresh-rate independent
-// (it is not one vsync period; at 120 Hz it spans two). 17 ms keeps the
-// guard silent through normal callback jitter while capping post-stall
-// run-ahead at one 60 Hz frame of curve time.
-constexpr double kMaxFrameLeadS = 0.017;
 
 // Semi-implicit Euler per channel, substepped: one frame-sized step is only
 // stable for omega*dt < 2, and accepted stiffness/mass ratios exceed that at
@@ -285,37 +275,6 @@ bool advanceSpring(ActiveAnimation &animation, double now) {
   return settled || now - animation.startedAtS >= kSpringMaxDurationS;
 }
 
-Presentation interpolate(
-    const Presentation &from,
-    const Presentation &to,
-    double progress) {
-  const auto mix = [progress](double start, double end) {
-    return start + (end - start) * progress;
-  };
-  return Presentation{
-      {mix(from.clip.x, to.clip.x),
-       mix(from.clip.y, to.clip.y),
-       mix(from.clip.width, to.clip.width),
-       mix(from.clip.height, to.clip.height),
-       mix(from.clip.radius, to.clip.radius)},
-      mix(from.contentTranslateX, to.contentTranslateX),
-      mix(from.contentTranslateY, to.contentTranslateY)};
-}
-
-Presentation interpolateKeyframes(
-    const std::vector<Keyframe> &frames,
-    double progress) {
-  size_t upper = 1;
-  while (upper < frames.size() - 1 && progress > frames[upper].offset) {
-    upper += 1;
-  }
-  const Keyframe &lower = frames[upper - 1];
-  const Keyframe &higher = frames[upper];
-  const double span = higher.offset - lower.offset;
-  const double local = span <= 0 ? 1.0 : (progress - lower.offset) / span;
-  return interpolate(lower.presentation, higher.presentation, clamp01(local));
-}
-
 bool systemAnimatorsEnabled() {
   static const auto valueAnimatorClass =
       facebook::jni::findClassStatic("android/animation/ValueAnimator");
@@ -339,14 +298,6 @@ void emitCompletion(uint64_t driverId, int32_t animationId, bool finished) {
   }
 }
 
-int32_t allocateAnimationId(DriverState &state) {
-  state.nextAnimationId =
-      state.nextAnimationId == std::numeric_limits<int32_t>::max()
-      ? 1
-      : state.nextAnimationId + 1;
-  return state.nextAnimationId;
-}
-
 // Terminal per-frame delivery: scale DIP -> px and normalize against the
 // pushed host metrics in C++, so the JNI call carries final pixel floats and
 // the Kotlin side reduces to field stores + invalidateOutline().
@@ -470,11 +421,25 @@ void startLatchedAnimation(uint64_t driverId, DriverState &state) {
 int32_t startAnimation(
     uint64_t driverId,
     DriverState &state,
-    ActiveAnimation animation) {
-  animation.startedAtS = nowSeconds();
-  animation.lastFrameS = animation.startedAtS;
-  animation.wallStartedAtS = animation.startedAtS;
-  animation.frameClockAnchored = false;
+    ActiveAnimation animation,
+    double startedAtHintS) {
+  // With a JS-captured hint the start stamp is Reanimated's own
+  // (`__frameTimestamp || _getAnimationTimestamp()`, read in the worklet that
+  // issued this call), already on the axis min() only approximates — so the
+  // animation arrives pre-anchored and advance() must not min() it against
+  // the dispatching frame, which for a CALLBACK_INPUT start is EARLIER than
+  // the call and would re-open the intra-frame lead the hint closes. Without
+  // a hint (NaN: latch-less legacy callers, tests, iOS ignoring the field)
+  // this reduces exactly to the old nowSeconds() + min() anchor path.
+  const double wallNow = nowSeconds();
+  const StartStamp stamp = resolveStartStamp(startedAtHintS, wallNow);
+  animation.startedAtS = stamp.startedAtS;
+  animation.lastFrameS = stamp.startedAtS;
+  // Wall axis for the re-latch remainder keeps the native call stamp: the
+  // hint is at most a frame older and the remainder math wants honest wall
+  // elapsed from when the animation actually began integrating.
+  animation.wallStartedAtS = wallNow;
+  animation.frameClockAnchored = stamp.frameClockAnchored;
   // current = start even while latched is load-bearing: cancelAnimation,
   // beginInteraction, prepareAnimation's visibleBefore and registerView's
   // visible all read animation->current, giving a never-rendered latch
@@ -503,35 +468,29 @@ void advance(uint64_t driverId, DriverState &state, double now) {
   ActiveAnimation &animation = *state.animation;
 
   if (!animation.frameClockAnchored) {
-    // startedAtS/lastFrameS hold nowSeconds() sampled mid-frame at the
-    // animateTo call / latch attach, but `now` is the frame's vsync
-    // timestamp — the same CLOCK_MONOTONIC timebase at an earlier sampling
-    // point. Un-anchored, the first fraction clamps to 0 and re-renders the
-    // start (1-2 duplicated frames at every interactive→animateTo handoff).
-    // Re-anchor onto the frame-time axis keeping the real elapsed time, so
-    // the first rendered frame advances honestly and later frames pace on
-    // vsync. On the 32-bit path `now` is itself nowSeconds() → ~identity.
-    const double wallElapsedS =
-        std::max(0.0, nowSeconds() - animation.startedAtS);
-    animation.startedAtS = now - wallElapsedS;
+    // This is the stamp-less/latch fallback. Worklet-issued animations carry
+    // Reanimated's exact `__frameTimestamp || _getAnimationTimestamp()` value
+    // and arrive pre-anchored, so they skip this approximation — including the
+    // CALLBACK_INPUT case where the current frame stamp predates the call.
+    // Here startedAtS/lastFrameS hold nowSeconds() sampled at native latch
+    // attach or by an older caller, while `now` is the frame's vsync stamp on
+    // the same CLOCK_MONOTONIC timebase. Taking the earlier stamp prevents a
+    // mid-frame native start from duplicating fraction zero.
+    //
+    // Deliberately NOT a wall-elapsed rebase (`now - (nowSeconds() -
+    // startedAtS)`): that bakes THIS frame's dispatch latency into the curve
+    // for the animation's whole duration, de-phasing the clip from parallel
+    // Reanimated content by however much main-thread work happened to run
+    // before us on frame one — worst on the first frame of a heavy
+    // transition, which is exactly when it is sampled. Catching up after a
+    // stall needs no help here either: Choreographer#doFrame snaps a late
+    // frameTimeNanos forward to within one frame interval of now (jitter
+    // correction), for every CALLBACK_ANIMATION client at once, so the clip
+    // and the content stall and catch up together.
+    animation.startedAtS = anchorStartTime(animation.startedAtS, now);
     animation.lastFrameS = animation.startedAtS;
     animation.frameClockAnchored = true;
-    // wallStartedAtS deliberately keeps the wall axis through this rebase.
-  }
-
-  // Run-ahead guard: the anchor's one-time shift bakes the first callback's
-  // dispatch latency into the frame axis. If a stalled handoff anchored
-  // against a stale frame stamp and later stamps catch up to real time, the
-  // frame axis leads wall time by up to the stall length and the animation
-  // completes early. Re-anchor forward when the lead exceeds one vsync of
-  // slack; on calm frames the condition (first callback's latency exceeding
-  // this frame's by > 17 ms) cannot hold, so the hot path is unchanged, and
-  // the 32-bit path (frame axis == wall axis) never fires it. lastFrameS is
-  // deliberately untouched: springs pace on dt, already clamped to 64 ms.
-  const double wallElapsedNowS =
-      std::max(0.0, nowSeconds() - animation.wallStartedAtS);
-  if (now - animation.startedAtS > wallElapsedNowS + kMaxFrameLeadS) {
-    animation.startedAtS = now - wallElapsedNowS;
+    // wallStartedAtS deliberately keeps the wall axis (re-latch remainder).
   }
 
   bool done = false;
@@ -539,11 +498,9 @@ void advance(uint64_t driverId, DriverState &state, double now) {
     done = advanceSpring(animation, now);
   } else {
     const double fraction =
-        animation.durationS <= 0
-        ? 1.0
-        : clamp01((now - animation.startedAtS) / animation.durationS);
+        timingFraction(now, animation.startedAtS, animation.durationS);
     if (animation.kind == AnimationKind::Keyframes) {
-      animation.current = interpolateKeyframes(animation.keyframes, fraction);
+      animation.current = animation.keyframes.evaluate(fraction);
     } else {
       const double eased = cubicBezier(
           animation.timing.controlPoint1X,
@@ -593,26 +550,27 @@ void onFrameImpl(double now) {
   if (!animatingDrivers().empty()) scheduleFrame();
 }
 
-void onFrameLegacy(long frameTimeNanos, void * /*data*/) {
-  // An fbjni exception must not unwind out of a C callback (std::terminate).
-  // Clear it, keep the loop scheduled, and let the next frame re-scan.
+} // namespace
+
+// Advances the frame loop; reached from SmoothClipBindings.nativeOnFrame
+// inside Choreographer#doFrame. Nothing may unwind back into doFrame — fbjni
+// would rethrow it as a Java exception and take down the main thread. Clear
+// any pending JNI exception, keep the loop scheduled, and let the next frame
+// re-scan.
+void onFrameAndroid(double frameTimeS) {
   try {
-#if defined(__LP64__) || (defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 8)
-    onFrameImpl(static_cast<double>(frameTimeNanos) / 1e9);
-#else
-    // 32-bit `long` truncates the nanosecond timestamp; fall back to the
-    // clock.
-    onFrameImpl(nowSeconds());
-#endif
+    onFrameImpl(frameTimeS);
   } catch (...) {
     JNIEnv *env = facebook::jni::Environment::current();
     if (env != nullptr && env->ExceptionCheck()) env->ExceptionClear();
-    scheduleFrame();
+    try {
+      scheduleFrame();
+    } catch (...) {
+      // gFrameScheduled stays false; the next animation start re-schedules.
+    }
   }
 }
 
-} // namespace
-
 // --- Public smoothclip:: interface (shared with iOS via SmoothClipRegistry.h)
 
 void setCompletionCallback(const void *owner, CompletionCallback callback) {
@@ -631,7 +589,8 @@ void clearCompletionCallback(const void *owner) {
 void setPresentation(
     uint64_t driverId,
     Presentation presentation,
-    bool takeOwnership) {
+    bool takeOwnership,
+    bool overridePendingAnimation) {
   if (!isOnMainThread()) return;
   auto iterator = registry().find(driverId);
   if (!takeOwnership) {
@@ -647,13 +606,11 @@ void setPresentation(
   if (!takeOwnership && state.ownership != Ownership::Interactive) return;
   if (takeOwnership) {
     state.destroyed = false;
-    // A held latch is strictly newer intent than this write: the latch was
-    // created after whatever value the caller read (the hook's seed replays
-    // a SharedValue that an earlier animateTo already advanced to its
-    // target). Cancelling it here would seed the target and turn the pending
-    // animation into a static jump. Callers that want to override a latch
-    // cancel it explicitly first.
-    if (state.animation.has_value() && !state.animation->started) {
+    // Passive seeds and public setters must not displace newer pending intent.
+    // The fused animation.from write is different: it is the caller's newest,
+    // authoritative start and explicitly opts in to cancelling the old latch.
+    if (state.animation.has_value() && !state.animation->started &&
+        !overridePendingAnimation) {
       return;
     }
     finishActive(driverId, state, false);
@@ -699,10 +656,15 @@ int32_t animateTiming(
     TimingAnimation animation) {
   if (!isOnMainThread()) return 0;
   auto iterator = registry().find(driverId);
-  if (iterator == registry().end()) return 0;
+  if (iterator == registry().end()) {
+    if (!start.hasInteractiveStart) return 0;
+    iterator = registry().try_emplace(driverId).first;
+    iterator->second.latest = start.interactiveStart;
+    iterator->second.hasLatest = true;
+  }
   auto &state = iterator->second;
   state.destroyed = false;
-  const int32_t animationId = allocateAnimationId(state);
+  const int32_t animationId = allocateAnimationId();
   const Presentation resolvedStart =
       prepareAnimation(driverId, state, start, presentation);
   if (shouldReduceMotion(animation.reduceMotion) || animation.durationMs <= 0) {
@@ -717,7 +679,7 @@ int32_t animateTiming(
   active.start = resolvedStart;
   active.target = presentation;
   active.durationS = animation.durationMs / 1000.0;
-  return startAnimation(driverId, state, std::move(active));
+  return startAnimation(driverId, state, std::move(active), start.startedAtHintS);
 }
 
 int32_t animateSpring(
@@ -727,10 +689,15 @@ int32_t animateSpring(
     SpringAnimation animation) {
   if (!isOnMainThread()) return 0;
   auto iterator = registry().find(driverId);
-  if (iterator == registry().end()) return 0;
+  if (iterator == registry().end()) {
+    if (!start.hasInteractiveStart) return 0;
+    iterator = registry().try_emplace(driverId).first;
+    iterator->second.latest = start.interactiveStart;
+    iterator->second.hasLatest = true;
+  }
   auto &state = iterator->second;
   state.destroyed = false;
-  const int32_t animationId = allocateAnimationId(state);
+  const int32_t animationId = allocateAnimationId();
   // Scalar velocity along the current-to-target trajectory; each channel is
   // seeded with velocity·displacement to match the iOS CASpringAnimation
   // per-keypath behavior.
@@ -760,7 +727,7 @@ int32_t animateSpring(
     active.springVelocity[index] =
         velocity * (targetChannels[index] - startChannels[index]);
   }
-  return startAnimation(driverId, state, std::move(active));
+  return startAnimation(driverId, state, std::move(active), start.startedAtHintS);
 }
 
 int32_t animateKeyframes(
@@ -772,10 +739,15 @@ int32_t animateKeyframes(
     int32_t reduceMotion) {
   if (!isOnMainThread()) return 0;
   auto iterator = registry().find(driverId);
-  if (iterator == registry().end()) return 0;
+  if (iterator == registry().end()) {
+    if (!start.hasInteractiveStart) return 0;
+    iterator = registry().try_emplace(driverId).first;
+    iterator->second.latest = start.interactiveStart;
+    iterator->second.hasLatest = true;
+  }
   auto &state = iterator->second;
   state.destroyed = false;
-  const int32_t animationId = allocateAnimationId(state);
+  const int32_t animationId = allocateAnimationId();
   const Presentation resolvedStart =
       prepareAnimation(driverId, state, start, presentation);
   if (shouldReduceMotion(reduceMotion) || durationMs <= 0 ||
@@ -787,18 +759,18 @@ int32_t animateKeyframes(
   ActiveAnimation active;
   active.id = animationId;
   active.kind = AnimationKind::Keyframes;
-  active.keyframes = std::move(keyframes);
+  active.keyframes.reset(std::move(keyframes));
   active.start = resolvedStart;
   active.target = presentation;
   active.durationS = durationMs / 1000.0;
-  return startAnimation(driverId, state, std::move(active));
+  return startAnimation(driverId, state, std::move(active), start.startedAtHintS);
 }
 
 int32_t rejectAnimation(uint64_t driverId) {
   if (!isOnMainThread()) return 0;
   auto iterator = registry().find(driverId);
   if (iterator == registry().end()) return 0;
-  const int32_t animationId = allocateAnimationId(iterator->second);
+  const int32_t animationId = allocateAnimationId();
   emitCompletion(driverId, animationId, false);
   return animationId;
 }
@@ -1009,12 +981,28 @@ void unregisterViewAndroid(
     }
   }
   if (removed && state.animation.has_value()) {
-    state.animation->finished = false;
-    if (state.views.empty() && !state.animation->started) {
-      // A held latch returns to its original zero-view state; the next
-      // displayable registration still starts it (or destroyDriver cancels
-      // it). Completing it here would betray the pending intent.
-    } else if (state.views.empty()) {
+    // Participant-gated like iOS: only a started run has rendered frames a
+    // departing view can leave unfinished. A held latch has installed nothing,
+    // so a view leaving while it is held must not poison the eventual natural
+    // completion with finished:false.
+    if (state.animation->started) state.animation->finished = false;
+    if (!isOnMainThread()) {
+      // Blast-radius reduction, NOT a synchronization fix — be clear about
+      // which. Both call sites (SmoothClipViewManager.onAfterUpdateTransaction
+      // and onDropViewInstance) are Fabric mount operations, so this branch is
+      // unreachable in supported usage; the erase above and the started-gated
+      // `finished` write are still unsynchronized if that ever stops holding. The erase
+      // cannot be skipped — dropping it would leak this view's global_ref for
+      // the process lifetime — but everything below can be, and should be: it
+      // crosses JNI to read view attachment (anyDisplayableView) and mutates
+      // animatingDrivers(), the vector the choreographer callback walks on the
+      // main thread. Record the unfinished flag (started runs only) and leave
+      // the animation for the next main-thread event (attach, host geometry,
+      // destroy) to resolve.
+    } else if (!state.animation->started) {
+      // A held latch stays pending; the next displayable registration or
+      // attach starts it (or destroyDriver cancels it).
+    } else if (!anyDisplayableView(state)) {
       auto &animation = *state.animation;
       // wallStartedAtS, not startedAtS: post-anchor the latter lives on the
       // shifted frame axis and would overstate elapsed by the first
@@ -1030,7 +1018,8 @@ void unregisterViewAndroid(
         state.ownership = Ownership::Interactive;
         finishActive(driverId, state, false);
       } else {
-        // The last rendering host left mid-flight (remount, screen swap).
+        // The last displayable host left mid-flight. Registered detached or
+        // unsized peers do not keep the clock running invisibly.
         // Completing here would leave `latest` at the target and statically
         // snap any re-registering host straight to it. Re-latch instead:
         // freeze the remaining animation at its current geometry so the
@@ -1038,14 +1027,24 @@ void unregisterViewAndroid(
         // destroyDriver cancels a latch that never finds a host, so the
         // completion cannot hang.
         if (animation.kind == AnimationKind::Timing) {
-          animation.durationS = remainingS;
+          const double progress = animation.durationS <= 0
+              ? 1.0
+              : clamp01(elapsedS / animation.durationS);
+          const TimingRemainder remainder =
+              timingRemainder(animation.timing, progress);
+          // Keep the frozen start, cutoff, and shortened curve on one exact
+          // phase. Reusing the old easing here would restart its slope.
+          animation.current = interpolate(
+              animation.start, animation.target, remainder.easedProgress);
+          animation.timing = remainder.animation;
+          animation.durationS = animation.timing.durationMs / 1000.0;
         } else if (animation.kind == AnimationKind::Keyframes) {
           const double progress = animation.durationS <= 0
               ? 1.0
               : clamp01(elapsedS / animation.durationS);
           std::vector<Keyframe> remaining;
           remaining.push_back({0, animation.current});
-          for (const Keyframe &frame : animation.keyframes) {
+          for (const Keyframe &frame : animation.keyframes.frames()) {
             if (frame.offset <= progress) continue;
             remaining.push_back(
                 {(frame.offset - progress) / (1 - progress),
@@ -1054,7 +1053,9 @@ void unregisterViewAndroid(
           if (remaining.size() == 1) {
             remaining.push_back({1, animation.target});
           }
-          animation.keyframes = std::move(remaining);
+          // reset() re-solves the tangents for the pruned curve and rewinds
+          // the segment cursor; the resumed run must not inherit either.
+          animation.keyframes.reset(std::move(remaining));
           animation.durationS = remainingS;
         }
         animation.start = animation.current;