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

package/README.md

@@ -208,10 +208,10 @@ puts on screen, which is the property worth keeping identical.
   (< 4 ms apart, e.g. a release-sample `from` seed right after the last drag
   write) coalesce into one sample, and an identical re-write is ignored, so a
   fused handoff can neither zero nor inflate the inherited velocity.
-  `beginInteraction()` records the frozen presentation as a plain sample on
-  both platforms, so a grab-and-instant-refling inherits bounded recent
-  motion (the staleness guard still zeroes a stale pair) instead of
-  launching dead.
+  Only interactive writes contribute samples. Internal freeze/join/resume and
+  static-finalization writes do not, so grabbing a native animation cannot
+  manufacture velocity for a later `'inherit'` spring; a subsequent drag (or
+  explicit `animation.from`) supplies the release samples instead.
 - `driver.react` exposes `beginInteraction`, `set`, `animateTo`, and `cancel`
   as Promises (`setScalars` is UI-worklet-only). React code never blocks
   waiting for main/UI-thread work. An immediate animation request resolves
@@ -249,26 +249,40 @@ puts on screen, which is the property worth keeping identical.
   authoritative interactive start, creates the missing driver state and
   returns a real id. `0` — with no completion — is reserved for off-main,
   invalid-id, or otherwise unsupported dispatch: a missing-state native request
-  with no authoritative start, and any `driver.ui.animateTo` issued after the
-  driver's hook has unmounted. (The second case is decided on the UI runtime,
+  with no authoritative start, any `driver.ui.animateTo` issued after the
+  driver's hook has unmounted, and an invalid-parameter request issued before
+  the driver's first seed reached native (validation rejections mint their
+  `finished: false` completion only once the native entry exists). (The
+  post-unmount case is decided on the UI runtime,
   because a destroyed driver and a not-yet-seeded one are the same missing
   registry entry to native — accepting it would build a latch nothing can start
-  and nothing can cancel.) Removing the last displayable
-  host mid-flight does not complete the animation: the remainder is re-latched
-  even if detached or unsized peers remain registered, and the next displayable
-  host resumes it, so the completion arrives when it finishes there — or unfinished on
-  replacement, cancellation, `beginInteraction()`, or driver destruction.
-  With multiple hosts on one driver, unregistering any host that installed the
-  running animation makes the eventual completion `finished: false` — a
-  detached or un-laid-out host does not become a completion participant until
-  its native animation is actually installed. `finished: true` means every
-  installed participant ran the animation to its end.
+  and nothing can cancel.) A host is displayable only while it is attached,
+  foreground/window-visible, laid out, and positive-sized (the window's own
+  `hidden`/scene state is not consulted — RN's single always-visible window
+  makes it moot). Losing the last
+  displayable host mid-flight — including temporary detach, zero-size layout,
+  or app background — freezes and re-latches the exact remainder instead of
+  consuming duration offscreen. Foreground/reattach resumes the same animation
+  ID from that stored timing/keyframe phase or spring state.
+  Parallel Reanimated clocks do **not** pause with it: a `withTiming` started
+  beside `animateTo` keeps its wall-clock start, so after backgrounding it
+  completes on its first resumed frame while the native run still animates its
+  preserved remainder. Key teardown and state transitions off
+  `onAnimationComplete` (or re-synchronize on `AppState`) rather than off a
+  duration-matched Reanimated callback.
+  With multiple hosts on one driver, a host becomes an installed participant
+  only after its native animation starts. Temporary loss moves it to suspended;
+  a rejoin restores active participation. Unregistering an installed/suspended
+  host, or reaching completion while it remains suspended, makes the eventual
+  completion `finished: false`. A host that stayed deferred because it was
+  detached, unlaid-out, or zero-sized never poisons completion. `finished: true`
+  means every installed participant either ran to the end or rejoined and did so.
 - An `animateTo` issued before any host view can produce a visible frame (for
   example from an effect in the same commit that mounts the host, or inside a
   modal route whose subtree attaches to its window late) is held pending and
   starts with its full duration at the first moment a registered host can
-  produce a frame — registration, first layout, or window attach, whichever
-  comes last. This also covers an animation worklet that runs before the
+  produce a frame — positive layout, window attach/visibility, and foreground
+  state must all be present. This also covers an animation worklet that runs before the
   hook's seed worklet: the animation creates the state and the later passive
   seed cannot reset its ownership or active id. A pending animation owns the
   driver: ordinary take-ownership writes (`set`, `setScalars`, the hook's seed)

package/android/build.gradle

@@ -114,6 +114,19 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
+  testOptions {
+    unitTests {
+      includeAndroidResources = true
+      all {
+        // Robolectric on Java 17 reflects into these platform packages.
+        jvmArgs "--add-opens=java.base/java.lang=ALL-UNNAMED",
+                "--add-opens=java.base/java.util=ALL-UNNAMED",
+                "--add-opens=java.base/java.io=ALL-UNNAMED",
+                "--add-opens=java.base/java.net=ALL-UNNAMED"
+      }
+    }
+  }
+
   packagingOptions {
     // Provided by the host application at runtime.
     excludes += [
@@ -128,4 +141,6 @@ android {
 dependencies {
   implementation "com.facebook.react:react-android"
   testImplementation "junit:junit:4.13.2"
+  testImplementation "org.mockito:mockito-core:5.14.2"
+  testImplementation "org.robolectric:robolectric:4.16"
 }

package/android/src/main/cpp/SmoothClipAndroid.h

@@ -22,7 +22,6 @@ struct JSmoothClipView : facebook::jni::JavaClass<JSmoothClipView> {
       const NormalizedClip &clip,
       double contentTranslateXPx,
       double contentTranslateYPx) const;
-  bool isViewAttachedToWindow() const;
 };
 
 // Called from Kotlin (SmoothClipViewManager) on the UI thread when a Fabric
@@ -33,7 +32,8 @@ void registerViewAndroid(
     Presentation initialPresentation,
     double density,
     double hostWidthPx,
-    double hostHeightPx);
+    double hostHeightPx,
+    bool lifecycleVisible);
 // Refreshes a registered view's density / host size (px) and synchronously
 // redelivers the driver's visible value pre-normalized against them.
 void setViewHostGeometryAndroid(
@@ -45,13 +45,12 @@ void setViewHostGeometryAndroid(
 void unregisterViewAndroid(
     uint64_t driverId,
     facebook::jni::alias_ref<JSmoothClipView> view);
-// Called from Kotlin when a registered view attaches to a window. A latched
-// animation may only start once a registered view can actually produce a
-// visible frame (attached AND has host geometry); otherwise its clock would
-// burn progress no one can see.
-void viewBecameDisplayableAndroid(
+// Pushes attachment/window visibility independently of host geometry. The
+// registry combines both signals into its displayability/participant state.
+void setViewLifecycleVisibilityAndroid(
     uint64_t driverId,
-    facebook::jni::alias_ref<JSmoothClipView> view);
+    facebook::jni::alias_ref<JSmoothClipView> view,
+    bool lifecycleVisible);
 
 // Advances the registry frame loop. Called from Kotlin (SmoothClipBindings)
 // inside Choreographer#doFrame with the frame's vsync timestamp converted to

package/android/src/main/cpp/SmoothClipBindings.cpp

@@ -389,7 +389,8 @@ void nativeRegisterView(
     jdouble contentTranslateY,
     jdouble density,
     jdouble widthPx,
-    jdouble heightPx) {
+    jdouble heightPx,
+    jboolean lifecycleVisible) {
   if (driverId <= 0 || !std::isfinite(driverId)) return;
   smoothclip::registerViewAndroid(
       static_cast<uint64_t>(driverId),
@@ -398,7 +399,8 @@ void nativeRegisterView(
           {x, y, width, height, radius}, contentTranslateX, contentTranslateY},
       density,
       widthPx,
-      heightPx);
+      heightPx,
+      lifecycleVisible != 0);
 }
 
 void nativeSetViewHostGeometry(
@@ -421,13 +423,14 @@ void nativeUnregisterView(
   smoothclip::unregisterViewAndroid(static_cast<uint64_t>(driverId), view);
 }
 
-void nativeViewBecameDisplayable(
+void nativeSetViewLifecycleVisibility(
     jni::alias_ref<jni::JObject>,
     jdouble driverId,
-    jni::alias_ref<smoothclip::JSmoothClipView> view) {
+    jni::alias_ref<smoothclip::JSmoothClipView> view,
+    jboolean lifecycleVisible) {
   if (driverId <= 0 || !std::isfinite(driverId)) return;
-  smoothclip::viewBecameDisplayableAndroid(
-      static_cast<uint64_t>(driverId), view);
+  smoothclip::setViewLifecycleVisibilityAndroid(
+      static_cast<uint64_t>(driverId), view, lifecycleVisible != 0);
 }
 
 void nativeInvalidate(jni::alias_ref<jni::JObject>) {
@@ -451,7 +454,8 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
                 "nativeSetViewHostGeometry", nativeSetViewHostGeometry),
             makeNativeMethod("nativeUnregisterView", nativeUnregisterView),
             makeNativeMethod(
-                "nativeViewBecameDisplayable", nativeViewBecameDisplayable),
+                "nativeSetViewLifecycleVisibility",
+                nativeSetViewLifecycleVisibility),
             makeNativeMethod("nativeInvalidate", nativeInvalidate),
             makeNativeMethod("nativeOnFrame", nativeOnFrame),
         });

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

@@ -26,6 +26,7 @@ using facebook::jni::global_ref;
 
 enum class Ownership { Interactive, Native };
 enum class AnimationKind { Timing, Spring, Keyframes };
+enum class ViewParticipation { Deferred, Active, Suspended };
 
 // Load-bearing invariant, not just a convenience clock: advance()'s frame-clock
 // anchor compares this value ABSOLUTELY against a choreographer frame stamp
@@ -60,11 +61,6 @@ struct ActiveAnimation {
   KeyframeCurve keyframes;
   double durationS = 0;
   double startedAtS = 0;
-  // 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{};
@@ -74,9 +70,8 @@ struct ActiveAnimation {
   // 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.
+  // Started by whichever lifecycle/geometry update 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
@@ -94,6 +89,8 @@ struct ViewEntry {
   double density = 0;
   double hostWidthPx = 0;
   double hostHeightPx = 0;
+  bool lifecycleVisible = false;
+  ViewParticipation participation = ViewParticipation::Deferred;
 };
 
 struct DriverState {
@@ -349,6 +346,9 @@ std::vector<uint64_t> &animatingDrivers() {
 // erase/recreate cycle would let one frame integrate the animation twice.
 void clearActiveAnimation(uint64_t driverId, DriverState &state) {
   state.animation.reset();
+  for (ViewEntry &entry : state.views) {
+    entry.participation = ViewParticipation::Deferred;
+  }
   auto &active = animatingDrivers();
   active.erase(
       std::remove(active.begin(), active.end(), driverId), active.end());
@@ -388,7 +388,7 @@ Presentation prepareAnimation(
 // no one can see (the transparentModal mount pattern).
 bool entryDisplayable(const ViewEntry &entry) {
   return entry.hostWidthPx > 0 && entry.hostHeightPx > 0 &&
-      entry.view->isViewAttachedToWindow();
+      entry.lifecycleVisible;
 }
 
 bool anyDisplayableView(const DriverState &state) {
@@ -405,7 +405,6 @@ void startLatchedAnimation(uint64_t driverId, DriverState &state) {
   animation.started = true;
   animation.startedAtS = nowSeconds();
   animation.lastFrameS = animation.startedAtS;
-  animation.wallStartedAtS = animation.startedAtS;
   // Load-bearing for re-latch resumes: unregisterViewAndroid rewrites this
   // ActiveAnimation in place, so a stale anchor would replay the fraction-0
   // first frame the anchor exists to remove.
@@ -414,6 +413,11 @@ void startLatchedAnimation(uint64_t driverId, DriverState &state) {
   if (std::find(active.begin(), active.end(), driverId) == active.end()) {
     active.push_back(driverId);
   }
+  for (ViewEntry &entry : state.views) {
+    if (entryDisplayable(entry)) {
+      entry.participation = ViewParticipation::Active;
+    }
+  }
   applyToViews(state, animation.start);
   scheduleFrame();
 }
@@ -435,10 +439,6 @@ int32_t startAnimation(
   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
@@ -447,6 +447,11 @@ int32_t startAnimation(
   animation.current = animation.start;
   animation.started = anyDisplayableView(state);
   state.animation = std::move(animation);
+  for (ViewEntry &entry : state.views) {
+    entry.participation = state.animation->started && entryDisplayable(entry)
+        ? ViewParticipation::Active
+        : ViewParticipation::Deferred;
+  }
   if (!state.animation->started) {
     // Latch: no host view can display yet (animateTo raced the mount, or
     // every host is detached/unsized). The first displayable registration,
@@ -464,6 +469,78 @@ int32_t startAnimation(
   return state.animation->id;
 }
 
+void relatchIfNoDisplayable(uint64_t driverId, DriverState &state) {
+  if (!state.animation.has_value() || !state.animation->started ||
+      anyDisplayableView(state)) {
+    return;
+  }
+  auto &animation = *state.animation;
+  for (ViewEntry &entry : state.views) {
+    if (entry.participation == ViewParticipation::Active) {
+      entry.participation = ViewParticipation::Suspended;
+    }
+  }
+
+  if (animation.kind == AnimationKind::Timing) {
+    const TimingContinuation continuation = timingContinuationAtFrame(
+        animation.timing,
+        animation.start,
+        animation.target,
+        animation.lastFrameS,
+        animation.startedAtS,
+        animation.durationS);
+    animation.current = continuation.start;
+    animation.timing = continuation.animation;
+    animation.durationS = continuation.animation.durationMs / 1000.0;
+  } else if (animation.kind == AnimationKind::Keyframes) {
+    const KeyframeContinuation continuation = keyframeContinuationAtFrame(
+        animation.keyframes.frames(),
+        animation.current,
+        animation.target,
+        animation.lastFrameS,
+        animation.startedAtS,
+        animation.durationS);
+    animation.current = continuation.start;
+    animation.keyframes.reset(continuation.frames);
+    animation.durationS = continuation.durationMs / 1000.0;
+  }
+
+  if (state.destroyed ||
+      (animation.kind != AnimationKind::Spring && animation.durationS <= 0)) {
+    state.ownership = Ownership::Interactive;
+    finishActive(driverId, state, false);
+    return;
+  }
+
+  animation.start = animation.current;
+  animation.started = false;
+  animation.frameClockAnchored = false;
+  auto &active = animatingDrivers();
+  active.erase(
+      std::remove(active.begin(), active.end(), driverId), active.end());
+}
+
+void reconcileViewDisplayability(
+    uint64_t driverId,
+    DriverState &state,
+    ViewEntry &entry) {
+  if (!state.animation.has_value()) return;
+  if (!state.animation->started) {
+    if (entryDisplayable(entry)) startLatchedAnimation(driverId, state);
+    return;
+  }
+
+  if (entryDisplayable(entry)) {
+    if (entry.participation != ViewParticipation::Active) {
+      entry.participation = ViewParticipation::Active;
+      deliverToView(entry, state.animation->current);
+    }
+  } else if (entry.participation == ViewParticipation::Active) {
+    entry.participation = ViewParticipation::Suspended;
+  }
+  relatchIfNoDisplayable(driverId, state);
+}
+
 void advance(uint64_t driverId, DriverState &state, double now) {
   ActiveAnimation &animation = *state.animation;
 
@@ -490,13 +567,15 @@ void advance(uint64_t driverId, DriverState &state, double now) {
     animation.startedAtS = anchorStartTime(animation.startedAtS, now);
     animation.lastFrameS = animation.startedAtS;
     animation.frameClockAnchored = true;
-    // wallStartedAtS deliberately keeps the wall axis (re-latch remainder).
   }
 
   bool done = false;
   if (animation.kind == AnimationKind::Spring) {
     done = advanceSpring(animation, now);
   } else {
+    // This is the frame whose presentation is delivered below. Lifecycle
+    // re-latch must trim from this timestamp, never from a later wall sample.
+    animation.lastFrameS = now;
     const double fraction =
         timingFraction(now, animation.startedAtS, animation.durationS);
     if (animation.kind == AnimationKind::Keyframes) {
@@ -518,7 +597,13 @@ void advance(uint64_t driverId, DriverState &state, double now) {
 
   if (done) {
     const int32_t animationId = animation.id;
-    const bool finished = animation.finished;
+    bool finished = animation.finished;
+    for (const ViewEntry &entry : state.views) {
+      if (entry.participation == ViewParticipation::Suspended) {
+        finished = false;
+        break;
+      }
+    }
     const Presentation target = animation.target;
     clearActiveAnimation(driverId, state);
     state.latest = target;
@@ -638,12 +723,8 @@ Presentation beginInteraction(uint64_t driverId) {
   state.latest = current;
   state.hasLatest = true;
   state.ownership = Ownership::Interactive;
-  // Plain record, not a reset — iOS parity (smoothClipFreezePresentation
-  // records the frozen value). Pairing the frozen mid-flight presentation
-  // with the last real sample lets a grab-and-instant-refling inherit
-  // bounded recent motion instead of launching dead; an unchanged value
-  // dedupes to a no-op and ages out through the staleness guard.
-  recordVelocitySample(state.samples, toChannels(current), nowSeconds());
+  // The frozen frame came from native animation movement, not an interactive
+  // write. Do not let it become a later `initialVelocity: inherit` sample.
   applyToViews(state, current);
   emitCompletion(driverId, animationId, false);
   return current;
@@ -809,6 +890,11 @@ void destroyDriver(uint64_t driverId) {
   auto &state = iterator->second;
   state.ownership = Ownership::Interactive;
   finishActive(driverId, state, false);
+  // A destroyed driver's interaction history must not seed a revived
+  // incarnation: the revival seed would otherwise pair with these samples and
+  // refresh the staleness clock with motion no finger produced. (iOS clears
+  // its per-view histories at the same point.)
+  state.samples = VelocitySampleHistory{};
   if (state.views.empty()) {
     registry().erase(iterator);
   } else {
@@ -822,12 +908,6 @@ void destroyDriver(uint64_t driverId) {
 
 // --- Android view lifecycle ----------------------------------------------
 
-bool JSmoothClipView::isViewAttachedToWindow() const {
-  static const auto method =
-      javaClassStatic()->getMethod<jboolean()>("isAttachedToWindow");
-  return method(self());
-}
-
 void JSmoothClipView::applyClip(const Presentation &presentation) const {
   static const auto method =
       javaClassStatic()
@@ -871,7 +951,8 @@ void registerViewAndroid(
     Presentation initialPresentation,
     double density,
     double hostWidthPx,
-    double hostHeightPx) {
+    double hostHeightPx,
+    bool lifecycleVisible) {
   auto &state = registry()[driverId];
   state.destroyed = false;
   if (!state.hasLatest) {
@@ -887,32 +968,24 @@ void registerViewAndroid(
       existing.density = density;
       existing.hostWidthPx = hostWidthPx;
       existing.hostHeightPx = hostHeightPx;
+      existing.lifecycleVisible = lifecycleVisible;
       deliverToView(existing, visible);
-      if (state.animation.has_value() && !state.animation->started &&
-          entryDisplayable(existing)) {
-        startLatchedAnimation(driverId, state);
-      }
+      reconcileViewDisplayability(driverId, state, existing);
       return;
     }
   }
   ViewEntry entry{
-      facebook::jni::make_global(view), density, hostWidthPx, hostHeightPx};
+      facebook::jni::make_global(view),
+      density,
+      hostWidthPx,
+      hostHeightPx,
+      lifecycleVisible,
+      ViewParticipation::Deferred};
   // `visible` above already delivered animation->current (= start) to the
   // registering view — the correct first frame for a latched animation.
   deliverToView(entry, visible);
   state.views.push_back(std::move(entry));
-  if (state.animation.has_value() && !state.animation->started &&
-      entryDisplayable(state.views.back())) {
-    // Start the latched animation: rebase the clock so the first frame
-    // integrates from now, not from the pre-mount animateTo call. Gated on
-    // displayability — a mount-time registration from a detached subtree
-    // holds the latch until window attach / first host geometry.
-    // Note this function has no isOnMainThread() guard (Kotlin calls it from
-    // the view's main-thread attach path); scheduleFrame() is itself
-    // main-thread-gated, so an off-main register cannot bind the
-    // choreographer to the wrong thread.
-    startLatchedAnimation(driverId, state);
-  }
+  reconcileViewDisplayability(driverId, state, state.views.back());
 }
 
 void setViewHostGeometryAndroid(
@@ -937,29 +1010,24 @@ void setViewHostGeometryAndroid(
           state.animation.has_value() ? state.animation->current
                                       : state.latest);
     }
-    if (state.animation.has_value() && !state.animation->started &&
-        entryDisplayable(entry)) {
-      // First real host geometry made this view displayable.
-      startLatchedAnimation(driverId, state);
-    }
+    reconcileViewDisplayability(driverId, state, entry);
     return;
   }
 }
 
-void viewBecameDisplayableAndroid(
+void setViewLifecycleVisibilityAndroid(
     uint64_t driverId,
-    alias_ref<JSmoothClipView> view) {
+    alias_ref<JSmoothClipView> view,
+    bool lifecycleVisible) {
   if (!isOnMainThread()) return;
   auto iterator = registry().find(driverId);
   if (iterator == registry().end()) return;
   auto &state = iterator->second;
-  if (!state.animation.has_value() || state.animation->started) return;
   JNIEnv *env = facebook::jni::Environment::current();
   for (auto &entry : state.views) {
     if (!env->IsSameObject(entry.view.get(), view.get())) continue;
-    if (entryDisplayable(entry)) {
-      startLatchedAnimation(driverId, state);
-    }
+    entry.lifecycleVisible = lifecycleVisible;
+    reconcileViewDisplayability(driverId, state, entry);
     return;
   }
 }
@@ -971,9 +1039,12 @@ void unregisterViewAndroid(
   if (iterator == registry().end()) return;
   auto &state = iterator->second;
   bool removed = false;
+  bool removedParticipant = false;
   JNIEnv *env = facebook::jni::Environment::current();
   for (auto view_it = state.views.begin(); view_it != state.views.end();) {
     if (env->IsSameObject(view_it->view.get(), view.get())) {
+      removedParticipant = removedParticipant ||
+          view_it->participation != ViewParticipation::Deferred;
       view_it = state.views.erase(view_it);
       removed = true;
     } else {
@@ -981,93 +1052,24 @@ void unregisterViewAndroid(
     }
   }
   if (removed && state.animation.has_value()) {
-    // 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;
+    // Only a host that actually joined (or is unresolved after suspension)
+    // affects completion. A detached/unsized registration that stayed deferred
+    // never installed or rendered this animation.
+    if (removedParticipant) 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
+      // unreachable in supported usage; the erase above and participant-based
       // `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
-      // callback's dispatch latency, shortening the resumed remainder and
-      // advancing the keyframe rebase past the rendered position.
-      const double elapsedS = nowSeconds() - animation.wallStartedAtS;
-      const double remainingS = std::max(0.0, animation.durationS - elapsedS);
-      const bool canResume = !state.destroyed &&
-          (animation.kind == AnimationKind::Spring || remainingS > 0);
-      if (!canResume) {
-        // The animation ends here; release ownership so a later remount's
-        // interactive updates are not dropped.
-        state.ownership = Ownership::Interactive;
-        finishActive(driverId, state, false);
-      } else {
-        // 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
-        // next displayable host resumes it with the true remaining time.
-        // destroyDriver cancels a latch that never finds a host, so the
-        // completion cannot hang.
-        if (animation.kind == AnimationKind::Timing) {
-          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.frames()) {
-            if (frame.offset <= progress) continue;
-            remaining.push_back(
-                {(frame.offset - progress) / (1 - progress),
-                 frame.presentation});
-          }
-          if (remaining.size() == 1) {
-            remaining.push_back({1, animation.target});
-          }
-          // 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;
-        animation.started = false;
-        // A held latch must not tick: leave animatingDrivers() without
-        // resetting the animation (the eager-removal rule the choreographer
-        // loop depends on).
-        auto &active = animatingDrivers();
-        active.erase(
-            std::remove(active.begin(), active.end(), driverId),
-            active.end());
-      }
+      // mutates animatingDrivers(), the vector the choreographer callback walks
+      // on the main thread. Record the unfinished flag and leave the animation
+      // for the next main-thread event (attach, host geometry, destroy) to
+      // resolve.
+    } else {
+      relatchIfNoDisplayable(driverId, state);
     }
   }
   if (state.destroyed && state.views.empty()) {