react-native-smooth-clip-view 0.3.0 → 0.4.1

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

@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <array>
 #include <atomic>
+#include <cassert>
 #include <chrono>
 #include <cmath>
 #include <limits>
@@ -26,8 +27,8 @@ using facebook::jni::alias_ref;
 using facebook::jni::global_ref;
 
 enum class Ownership { Interactive, Native };
-enum class AnimationKind { Timing, Spring, Keyframes };
-enum class ViewParticipation { Deferred, Active, Suspended };
+enum class AnimationKind { Timing, Spring };
+enum class ViewParticipation { Deferred, Active };
 
 // Load-bearing invariant, not just a convenience clock: advance()'s frame-clock
 // anchor compares this value ABSOLUTELY against a choreographer frame stamp
@@ -51,40 +52,35 @@ double nowSeconds() {
 
 struct ActiveAnimation {
   int32_t id = 0;
+  int32_t completionTag = 0;
   AnimationKind kind = AnimationKind::Timing;
   Presentation start{{0, 0, 0, 0, 0}, 0, 0};
   Presentation target{{0, 0, 0, 0, 0}, 0, 0};
   Presentation current{{0, 0, 0, 0, 0}, 0, 0};
   TimingAnimation timing{};
   SpringAnimation spring{};
-  // Owns the segment-linear keyframes and a cursor into the active segment.
-  KeyframeCurve keyframes;
   double durationS = 0;
   double startedAtS = 0;
-  // Integrated spring state (the eleven continuous V2 channels; curve is
-  // categorical and remains the start presentation's curve while running).
+  // Integrated spring state. Shadow channels are skipped when neither endpoint
+  // has a visible shadow.
   Channels springPosition{};
   Channels springVelocity{};
+  std::size_t springChannelCount = kBaseChannelCount;
   double lastFrameS = 0;
-  bool finished = true;
-  // 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 lifecycle/geometry update first sees a displayable
-  // entry; each rebases the clock through startLatchedAnimation.
+  ScalarSpringState scalarSpring{0, 0};
+  // False only while a pre-ready animation waits for its first displayable
+  // host. Once started, host loss freezes the visible presentation.
   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 — except
-  // a start that carried the JS-captured Reanimated stamp, which arrives
+  // A start that carried the JS-captured Reanimated stamp arrives
   // pre-anchored (see startAnimation) and must not be min()'d again.
   bool frameClockAnchored = false;
 };
 
 // Per-view fanout state. Density and host metrics are pushed from Kotlin at
-// register time and on size/density changes; density 0 (not pushed yet) falls
-// back to DIP delivery through setClipPresentationDip.
+// register time and on size/density changes; density 0 falls back to DIP
+// delivery until physical host metrics arrive.
 struct ViewEntry {
   global_ref<JSmoothClipView> view;
   double density = 0;
@@ -130,10 +126,11 @@ struct GroupMemberAnimation {
 struct ActiveGroup {
   uint64_t controllerId = 0;
   int32_t id = 0;
+  int32_t completionTag = 0;
   AnimationKind kind = AnimationKind::Timing;
-  GroupSuspensionPolicy suspensionPolicy = GroupSuspensionPolicy::Pause;
   TimingAnimation timing{};
   SpringAnimation spring{};
+  ScalarSpringState scalarSpring{0, 0};
   double durationS = 0;
   double startedAtS = 0;
   double lastFrameS = 0;
@@ -142,6 +139,8 @@ struct ActiveGroup {
   std::vector<GroupMemberAnimation> members;
 };
 
+bool anyDisplayableView(const DriverState &state);
+
 std::unordered_map<uint64_t, DriverState> &registry() {
   static std::unordered_map<uint64_t, DriverState> value;
   return value;
@@ -255,9 +254,16 @@ void scheduleFrame() {
 
 // --- Math (ported from SmoothClipRegistry.kt so both platforms match) -----
 //
-// 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.
+// clamp01, toChannels/fromChannels, interpolate, and the frame-clock anchor
+// live in cpp/SmoothClipAnimationCurve.h so a test binary can reach them
+// without linking fbjni; ios/tests pins their behavior.
+
+std::array<double, 11> velocityChannels(const Presentation &presentation) {
+  const Channels channels = toChannels(presentation);
+  std::array<double, 11> result{};
+  std::copy_n(channels.begin(), result.size(), result.begin());
+  return result;
+}
 
 // Springs settle below these per-channel thresholds (DIP and DIP/s).
 constexpr double kSpringSettleDisplacement = 0.05;
@@ -272,7 +278,9 @@ constexpr double kSpringMaxDurationS = 10.0;
 // stiffness/mass = 200k. Termination is settle-based: every channel must be
 // near its target and nearly stationary at the same time.
 bool advanceSpring(ActiveAnimation &animation, double now) {
-  const auto target = toChannels(animation.target);
+  const auto normalizedEndpoints = normalizeShadowEndpoints(
+      animation.start, animation.target);
+  const auto target = toChannels(normalizedEndpoints.second);
   double dt = now - animation.lastFrameS;
   animation.lastFrameS = now;
   if (dt < 0) dt = 0;
@@ -284,7 +292,7 @@ bool advanceSpring(ActiveAnimation &animation, double now) {
   while (dt > 0) {
     const double step = std::min(dt, kMaxStepS);
     dt -= step;
-    for (std::size_t index = 0; index < kChannelCount; index += 1) {
+    for (std::size_t index = 0; index < animation.springChannelCount; index += 1) {
       const double displacement =
           animation.springPosition[index] - target[index];
       const double acceleration =
@@ -296,7 +304,7 @@ bool advanceSpring(ActiveAnimation &animation, double now) {
     }
   }
   bool settled = true;
-  for (std::size_t index = 0; index < kChannelCount; index += 1) {
+  for (std::size_t index = 0; index < animation.springChannelCount; index += 1) {
     if (!std::isfinite(animation.springPosition[index]) ||
         !std::isfinite(animation.springVelocity[index])) {
       // A divergent configuration must never freeze the clip: end at target.
@@ -311,8 +319,14 @@ bool advanceSpring(ActiveAnimation &animation, double now) {
       settled = false;
     }
   }
-  animation.current =
-      fromChannels(animation.springPosition, animation.start.clip.curve);
+  animation.current = fromChannels(
+      animation.springPosition,
+      animation.start.clip.curve,
+      animation.start.shadow.enabled || animation.target.shadow.enabled);
+  if (!canonicalizePresentation(animation.current)) {
+    animation.current = animation.target;
+    return true;
+  }
   return settled || now - animation.startedAtS >= kSpringMaxDurationS;
 }
 
@@ -332,23 +346,42 @@ bool shouldReduceMotion(int32_t setting) {
 
 // --- State helpers --------------------------------------------------------
 
-void emitCompletion(uint64_t driverId, int32_t animationId, bool finished) {
+void emitCompletion(
+    uint64_t driverId,
+    int32_t animationId,
+    int32_t completionTag,
+    bool finished) {
   std::lock_guard<std::mutex> lock(completionSinkMutex());
   if (completionSink().callback) {
-    completionSink().callback(driverId, animationId, finished);
+    completionSink().callback(
+        driverId, animationId, completionTag, finished);
   }
 }
 
 void emitGroupCompletion(const ActiveGroup &group, bool finished) {
-  std::vector<uint64_t> driverIds;
-  driverIds.reserve(group.members.size());
+  std::vector<DriverSnapshot> snapshots;
+  snapshots.reserve(group.members.size());
   for (const GroupMemberAnimation &member : group.members) {
-    driverIds.push_back(member.driverId);
+    const auto iterator = registry().find(member.driverId);
+    if (iterator == registry().end() || iterator->second.destroyed) {
+      snapshots.push_back(
+          {member.driverId, unavailablePresentation(), false});
+    } else {
+      snapshots.push_back({
+          member.driverId,
+          iterator->second.latest,
+          anyDisplayableView(iterator->second),
+      });
+    }
   }
   std::lock_guard<std::mutex> lock(completionSinkMutex());
   if (groupCompletionSink().callback) {
     groupCompletionSink().callback(
-        group.controllerId, group.id, finished, std::move(driverIds));
+        group.controllerId,
+        group.id,
+        group.completionTag,
+        finished,
+        std::move(snapshots));
   }
 }
 
@@ -374,67 +407,28 @@ Presentation visiblePresentation(
   return state.animation.has_value() ? state.animation->current : state.latest;
 }
 
-bool needsV2Delivery(const Presentation &presentation) {
-  const double topLeft = SmoothClipResolvedRadius(
-      presentation.clip.topLeftRadius, presentation.clip.radius);
-  const double topRight = SmoothClipResolvedRadius(
-      presentation.clip.topRightRadius, presentation.clip.radius);
-  const double bottomRight = SmoothClipResolvedRadius(
-      presentation.clip.bottomRightRadius, presentation.clip.radius);
-  const double bottomLeft = SmoothClipResolvedRadius(
-      presentation.clip.bottomLeftRadius, presentation.clip.radius);
-  return presentation.clip.curve != ClipCurve::Circular ||
-      presentation.contentScale != 1.0 ||
-      topLeft != presentation.clip.radius ||
-      topRight != presentation.clip.radius ||
-      bottomRight != presentation.clip.radius ||
-      bottomLeft != presentation.clip.radius;
-}
-
-// 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().
+// Terminal per-frame delivery: scale canonical DIP geometry to pixels without
+// consulting host metrics. Each SmoothClipView applies the fixed viewport crop.
 void deliverToView(const ViewEntry &entry, const Presentation &presentation) {
-  const bool deliverV2 = needsV2Delivery(presentation);
   if (entry.density <= 0) {
-    if (deliverV2) {
-      entry.view->applyClipV2(presentation);
-    } else {
-      entry.view->applyClip(presentation);
-    }
+    entry.view->applyClip(presentation);
     return;
   }
   const double density = entry.density;
-  NormalizedClip clip;
-  if (deliverV2) {
-    if (!SmoothClipNormalizeV2(
-            presentation.clip.x * density,
-            presentation.clip.y * density,
-            presentation.clip.width * density,
-            presentation.clip.height * density,
-            presentation.clip.radius * density,
-            presentation.clip.topLeftRadius * density,
-            presentation.clip.topRightRadius * density,
-            presentation.clip.bottomRightRadius * density,
-            presentation.clip.bottomLeftRadius * density,
-            presentation.clip.curve,
-            entry.hostWidthPx,
-            entry.hostHeightPx,
-            clip)) {
-      return;
-    }
-  } else {
-    if (!SmoothClipNormalize(
-            presentation.clip.x * density,
-            presentation.clip.y * density,
-            presentation.clip.width * density,
-            presentation.clip.height * density,
-            presentation.clip.radius * density,
-            entry.hostWidthPx,
-            entry.hostHeightPx,
-            clip)) {
-      return;
-    }
+  CanonicalClip clip;
+  if (!SmoothClipCanonicalize(
+          presentation.clip.x * density,
+          presentation.clip.y * density,
+          presentation.clip.width * density,
+          presentation.clip.height * density,
+          presentation.clip.radius * density,
+          presentation.clip.topLeftRadius * density,
+          presentation.clip.topRightRadius * density,
+          presentation.clip.bottomRightRadius * density,
+          presentation.clip.bottomLeftRadius * density,
+          presentation.clip.curve,
+          clip)) {
+    return;
   }
   const double translateX = presentation.contentTranslateX * density;
   const double translateY = presentation.contentTranslateY * density;
@@ -444,12 +438,17 @@ void deliverToView(const ViewEntry &entry, const Presentation &presentation) {
       presentation.contentScale <= 0) {
     return;
   }
-  if (deliverV2) {
-    entry.view->applyClipV2Px(
-        clip, translateX, translateY, presentation.contentScale);
-  } else {
-    entry.view->applyClipPx(clip, translateX, translateY);
-  }
+  Shadow shadowPx = presentation.shadow;
+  shadowPx.offsetX *= density;
+  shadowPx.offsetY *= density;
+  shadowPx.blurRadius *= density;
+  shadowPx.spreadDistance *= density;
+  entry.view->applyClipPx(
+      clip,
+      translateX,
+      translateY,
+      presentation.contentScale,
+      shadowPx);
 }
 
 void applyToViews(DriverState &state, const Presentation &presentation) {
@@ -458,6 +457,22 @@ void applyToViews(DriverState &state, const Presentation &presentation) {
   }
 }
 
+void setAutonomousMotion(DriverState &state, bool active) {
+  for (const ViewEntry &entry : state.views) {
+    entry.view->setAutonomousMotion(active);
+  }
+}
+
+void applyAnimationFrameToViews(
+    DriverState &state,
+    const Presentation &presentation) {
+  for (const auto &entry : state.views) {
+    if (entry.participation == ViewParticipation::Active) {
+      deliverToView(entry, presentation);
+    }
+  }
+}
+
 void applyPresentation(DriverState &state, const Presentation &presentation) {
   state.latest = presentation;
   state.hasLatest = true;
@@ -474,6 +489,7 @@ std::vector<uint64_t> &animatingDrivers() {
 // visits animating drivers. Removal is eager: a stale id surviving a driver
 // erase/recreate cycle would let one frame integrate the animation twice.
 void clearActiveAnimation(uint64_t driverId, DriverState &state) {
+  setAutonomousMotion(state, false);
   state.animation.reset();
   for (ViewEntry &entry : state.views) {
     entry.participation = ViewParticipation::Deferred;
@@ -486,8 +502,9 @@ void clearActiveAnimation(uint64_t driverId, DriverState &state) {
 void finishActive(uint64_t driverId, DriverState &state, bool finished) {
   if (!state.animation.has_value()) return;
   const int32_t animationId = state.animation->id;
+  const int32_t completionTag = state.animation->completionTag;
   clearActiveAnimation(driverId, state);
-  emitCompletion(driverId, animationId, finished);
+  emitCompletion(driverId, animationId, completionTag, finished);
 }
 
 Presentation prepareAnimation(
@@ -522,77 +539,6 @@ bool entryDisplayable(const ViewEntry &entry) {
       entry.lifecycleVisible;
 }
 
-Geometry geometryInPixels(
-    const Geometry &geometry,
-    double density) {
-  Geometry result = geometry;
-  result.x *= density;
-  result.y *= density;
-  result.width *= density;
-  result.height *= density;
-  result.radius *= density;
-  result.topLeftRadius *= density;
-  result.topRightRadius *= density;
-  result.bottomRightRadius *= density;
-  result.bottomLeftRadius *= density;
-  return result;
-}
-
-bool presentationFitsEveryKnownHostWithoutNormalization(
-    const DriverState &state,
-    const Presentation &presentation) {
-  for (const ViewEntry &entry : state.views) {
-    // Zero host metrics are still waiting on Fabric layout and remain covered
-    // by the existing readiness latch. Once metrics exist, density is required
-    // to compare the DIP presentation against the exact pixel host bounds.
-    if (entry.hostWidthPx <= 0 || entry.hostHeightPx <= 0) continue;
-    if (entry.density <= 0 ||
-        !SmoothClipGeometryNormalizationIsIdentity(
-            geometryInPixels(presentation.clip, entry.density),
-            entry.hostWidthPx,
-            entry.hostHeightPx)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool timingPlanPreservesLinearHostNormalization(
-    const DriverState &state,
-    const Presentation &start,
-    const Presentation &target,
-    const TimingAnimation &animation) {
-  const double minimumProgress = std::min(
-      {0.0, 1.0, animation.controlPoint1Y, animation.controlPoint2Y});
-  const double maximumProgress = std::max(
-      {0.0, 1.0, animation.controlPoint1Y, animation.controlPoint2Y});
-  const Presentation minimum =
-      interpolate(start, target, minimumProgress);
-  const Presentation maximum =
-      interpolate(start, target, maximumProgress);
-  return isFiniteProtocolV2Presentation(minimum) &&
-      isFiniteProtocolV2Presentation(maximum) &&
-      presentationFitsEveryKnownHostWithoutNormalization(state, minimum) &&
-      presentationFitsEveryKnownHostWithoutNormalization(state, maximum);
-}
-
-bool keyframePlanPreservesLinearHostNormalization(
-    const DriverState &state,
-    const Presentation &resolvedStart,
-    const std::vector<Keyframe> &keyframes) {
-  if (!presentationFitsEveryKnownHostWithoutNormalization(
-          state, resolvedStart)) {
-    return false;
-  }
-  for (std::size_t index = 1; index < keyframes.size(); index += 1) {
-    if (!presentationFitsEveryKnownHostWithoutNormalization(
-            state, keyframes[index].presentation)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 bool anyDisplayableView(const DriverState &state) {
   for (const ViewEntry &entry : state.views) {
     if (entryDisplayable(entry)) return true;
@@ -617,6 +563,8 @@ void removeAnimatingGroup(int32_t groupId) {
 }
 
 void applyGroupCurrent(const ActiveGroup &group) {
+  // Group readiness is the participation contract. Each controller owns one
+  // host, and host loss removes the group before another frame can advance.
   for (const GroupMemberAnimation &member : group.members) {
     const auto iterator = registry().find(member.driverId);
     if (iterator != registry().end()) {
@@ -625,6 +573,23 @@ void applyGroupCurrent(const ActiveGroup &group) {
   }
 }
 
+void startGroupFrameLoop(ActiveGroup &group) {
+  assert(group.started);
+  assert(allGroupMembersReady(group));
+  for (const GroupMemberAnimation &member : group.members) {
+    auto iterator = registry().find(member.driverId);
+    if (iterator != registry().end()) {
+      setAutonomousMotion(iterator->second, true);
+    }
+  }
+  auto &active = animatingGroups();
+  if (std::find(active.begin(), active.end(), group.id) == active.end()) {
+    active.push_back(group.id);
+  }
+  applyGroupCurrent(group);
+  scheduleFrame();
+}
+
 std::vector<DriverSnapshot> finishGroupImpl(
     int32_t groupId,
     bool useTarget,
@@ -650,6 +615,7 @@ std::vector<DriverSnapshot> finishGroupImpl(
     state.latest = result;
     state.hasLatest = true;
     state.ownership = Ownership::Interactive;
+    setAutonomousMotion(state, false);
     applyToViews(state, result);
     snapshots.push_back(
         {member.driverId, result, !state.destroyed && anyDisplayableView(state)});
@@ -658,7 +624,7 @@ std::vector<DriverSnapshot> finishGroupImpl(
   return snapshots;
 }
 
-void startLatchedGroup(ActiveGroup &group) {
+void startPendingGroup(ActiveGroup &group) {
   const double now = nowSeconds();
   group.started = true;
   group.startedAtS = now;
@@ -669,45 +635,7 @@ void startLatchedGroup(ActiveGroup &group) {
     member.animation.lastFrameS = now;
     member.animation.frameClockAnchored = false;
   }
-  auto &active = animatingGroups();
-  if (std::find(active.begin(), active.end(), group.id) == active.end()) {
-    active.push_back(group.id);
-  }
-  applyGroupCurrent(group);
-  scheduleFrame();
-}
-
-void pauseGroup(ActiveGroup &group) {
-  if (group.kind == AnimationKind::Timing) {
-    const double rawProgress = timingFraction(
-        group.lastFrameS, group.startedAtS, group.durationS);
-    const TimingRemainder remainder = timingRemainder(group.timing, rawProgress);
-    group.timing = remainder.animation;
-    group.durationS = remainder.animation.durationMs / 1000.0;
-    for (GroupMemberAnimation &member : group.members) {
-      member.animation.start = member.animation.current;
-      member.animation.timing = remainder.animation;
-    }
-  } else if (group.kind == AnimationKind::Keyframes) {
-    double remainingDurationMs = 0;
-    for (GroupMemberAnimation &member : group.members) {
-      const KeyframeContinuation continuation = keyframeContinuationAtFrame(
-          member.animation.keyframes.frames(),
-          member.animation.current,
-          member.animation.target,
-          group.lastFrameS,
-          group.startedAtS,
-          group.durationS);
-      member.animation.start = continuation.start;
-      member.animation.current = continuation.start;
-      member.animation.keyframes.reset(continuation.frames);
-      remainingDurationMs = continuation.durationMs;
-    }
-    group.durationS = remainingDurationMs / 1000.0;
-  }
-  group.started = false;
-  group.frameClockAnchored = false;
-  removeAnimatingGroup(group.id);
+  startGroupFrameLoop(group);
 }
 
 void reconcileGroupReadiness(uint64_t driverId) {
@@ -724,27 +652,20 @@ void reconcileGroupReadiness(uint64_t driverId) {
   ActiveGroup &group = groupIterator->second;
   const bool ready = allGroupMembersReady(group);
   if (!group.started) {
-    if (ready) startLatchedGroup(group);
+    if (ready) startPendingGroup(group);
     return;
   }
   if (ready) return;
-  if (group.suspensionPolicy == GroupSuspensionPolicy::Finish) {
-    finishGroupImpl(groupId, true, true);
-  } else {
-    pauseGroup(group);
-  }
+  finishGroupImpl(groupId, false, false);
 }
 
-// Starts a latched animation: rebases the clock so no progress was burned
-// while no view could display, then joins the choreographer loop.
-void startLatchedAnimation(uint64_t driverId, DriverState &state) {
+// Starts a pre-ready animation with its full duration, then joins the
+// choreographer loop.
+void startPendingAnimation(uint64_t driverId, DriverState &state) {
   auto &animation = *state.animation;
   animation.started = true;
   animation.startedAtS = nowSeconds();
   animation.lastFrameS = 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.
   animation.frameClockAnchored = false;
   auto &active = animatingDrivers();
   if (std::find(active.begin(), active.end(), driverId) == active.end()) {
@@ -755,6 +676,7 @@ void startLatchedAnimation(uint64_t driverId, DriverState &state) {
       entry.participation = ViewParticipation::Active;
     }
   }
+  setAutonomousMotion(state, true);
   applyToViews(state, animation.start);
   scheduleFrame();
 }
@@ -770,16 +692,16 @@ int32_t startAnimation(
   // 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)
+  // a hint (NaN: unstamped 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;
   animation.frameClockAnchored = stamp.frameClockAnchored;
-  // current = start even while latched is load-bearing: cancelAnimation,
+  // current = start while pre-ready is load-bearing: cancelAnimation,
   // beginInteraction, prepareAnimation's visibleBefore and registerView's
-  // visible all read animation->current, giving a never-rendered latch
+  // visible all read animation->current, giving a never-rendered pending-run
   // freeze-at-start / replace-from-start semantics with no extra branches.
   animation.current = animation.start;
   animation.started = anyDisplayableView(state);
@@ -790,9 +712,9 @@ int32_t startAnimation(
         : 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,
-    // host-geometry push, or window attach rebases the clock, joins
+    // No host can display yet (animateTo raced the mount, or the host is
+    // detached/unsized). The first displayable registration, host-geometry
+    // push, or window attach starts the full clock, joins
     // animatingDrivers() and schedules the frame loop. Non-zero id is still
     // returned so the JS side does not treat this as rejection.
     return state.animation->id;
@@ -801,60 +723,23 @@ int32_t startAnimation(
   if (std::find(active.begin(), active.end(), driverId) == active.end()) {
     active.push_back(driverId);
   }
+  setAutonomousMotion(state, true);
   applyToViews(state, state.animation->start);
   scheduleFrame();
   return state.animation->id;
 }
 
-void relatchIfNoDisplayable(uint64_t driverId, DriverState &state) {
+void finishIfHostUnavailable(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());
+  const Presentation target = state.animation->target;
+  state.latest = target;
+  state.hasLatest = true;
+  state.ownership = Ownership::Interactive;
+  applyToViews(state, target);
+  finishActive(driverId, state, true);
 }
 
 void reconcileViewDisplayability(
@@ -863,7 +748,7 @@ void reconcileViewDisplayability(
     ViewEntry &entry) {
   if (!state.animation.has_value()) return;
   if (!state.animation->started) {
-    if (entryDisplayable(entry)) startLatchedAnimation(driverId, state);
+    if (entryDisplayable(entry)) startPendingAnimation(driverId, state);
     return;
   }
 
@@ -873,20 +758,20 @@ void reconcileViewDisplayability(
       deliverToView(entry, state.animation->current);
     }
   } else if (entry.participation == ViewParticipation::Active) {
-    entry.participation = ViewParticipation::Suspended;
+    entry.participation = ViewParticipation::Deferred;
   }
-  relatchIfNoDisplayable(driverId, state);
+  finishIfHostUnavailable(driverId, state);
 }
 
 void advance(uint64_t driverId, DriverState &state, double now) {
   ActiveAnimation &animation = *state.animation;
 
   if (!animation.frameClockAnchored) {
-    // This is the stamp-less/latch fallback. Worklet-issued animations carry
+    // This is the unstamped/pre-ready 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
+    // Here startedAtS/lastFrameS hold nowSeconds() sampled at native
     // 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.
@@ -910,44 +795,36 @@ void advance(uint64_t driverId, DriverState &state, double now) {
   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) {
-      animation.current = animation.keyframes.evaluate(fraction);
-    } else {
-      const double eased = cubicBezier(
-          animation.timing.controlPoint1X,
-          animation.timing.controlPoint1Y,
-          animation.timing.controlPoint2X,
-          animation.timing.controlPoint2Y,
-          fraction);
-      animation.current = interpolate(animation.start, animation.target, eased);
+    const double eased = cubicBezier(
+        animation.timing.controlPoint1X,
+        animation.timing.controlPoint1Y,
+        animation.timing.controlPoint2X,
+        animation.timing.controlPoint2Y,
+        fraction);
+    animation.current = interpolate(animation.start, animation.target, eased);
+    const bool canonical = canonicalizePresentation(animation.current);
+    if (!canonical) {
+      animation.current = animation.target;
     }
-    done = fraction >= 1.0;
+    done = !canonical || fraction >= 1.0;
   }
   // The completion branch below fans out the exact target; applying the
   // integrated value too would double every JNI crossing on the final frame.
-  if (!done) applyToViews(state, animation.current);
+  if (!done) applyAnimationFrameToViews(state, animation.current);
 
   if (done) {
     const int32_t animationId = animation.id;
-    bool finished = animation.finished;
-    for (const ViewEntry &entry : state.views) {
-      if (entry.participation == ViewParticipation::Suspended) {
-        finished = false;
-        break;
-      }
-    }
+    const int32_t completionTag = animation.completionTag;
     const Presentation target = animation.target;
     clearActiveAnimation(driverId, state);
     state.latest = target;
     state.hasLatest = true;
     state.ownership = Ownership::Interactive;
     applyToViews(state, target);
-    emitCompletion(driverId, animationId, finished);
+    emitCompletion(driverId, animationId, completionTag, true);
   }
 }
 
@@ -965,31 +842,44 @@ void advanceGroup(int32_t groupId, ActiveGroup &group, double now) {
 
   bool done = false;
   if (group.kind == AnimationKind::Spring) {
-    done = true;
+    const double deltaTime = now - group.lastFrameS;
+    group.lastFrameS = now;
+    group.scalarSpring = advanceScalarSpring(
+        group.scalarSpring, group.spring, deltaTime);
+    done = now - group.startedAtS >= kSpringMaxDurationS ||
+        relativeSpringEnergy(group.scalarSpring, group.spring) <=
+            group.spring.energyThreshold;
     for (GroupMemberAnimation &member : group.members) {
-      if (!advanceSpring(member.animation, now)) done = false;
+      member.animation.current = interpolate(
+          member.animation.start,
+          member.animation.target,
+          done ? 1.0 : group.scalarSpring.position);
+      if (!canonicalizePresentation(member.animation.current)) {
+        member.animation.current = member.animation.target;
+        done = true;
+      }
     }
   } else {
     group.lastFrameS = now;
     const double fraction =
         timingFraction(now, group.startedAtS, group.durationS);
+    const double eased = cubicBezier(
+        group.timing.controlPoint1X,
+        group.timing.controlPoint1Y,
+        group.timing.controlPoint2X,
+        group.timing.controlPoint2Y,
+        fraction);
+    bool canonical = true;
     for (GroupMemberAnimation &member : group.members) {
       member.animation.lastFrameS = now;
-      if (group.kind == AnimationKind::Keyframes) {
-        member.animation.current =
-            member.animation.keyframes.evaluate(fraction);
-      } else {
-        const double eased = cubicBezier(
-            group.timing.controlPoint1X,
-            group.timing.controlPoint1Y,
-            group.timing.controlPoint2X,
-            group.timing.controlPoint2Y,
-            fraction);
-        member.animation.current = interpolate(
-            member.animation.start, member.animation.target, eased);
+      member.animation.current = interpolate(
+          member.animation.start, member.animation.target, eased);
+      if (!canonicalizePresentation(member.animation.current)) {
+        member.animation.current = member.animation.target;
+        canonical = false;
       }
     }
-    done = fraction >= 1.0;
+    done = !canonical || fraction >= 1.0;
   }
 
   if (done) {
@@ -1147,12 +1037,13 @@ std::vector<DriverSnapshot> beginGroupInteraction(
     DriverState &state = registry().at(driverId);
     if (state.animation.has_value()) {
       const int32_t animationId = state.animation->id;
+      const int32_t completionTag = state.animation->completionTag;
       const Presentation current = state.animation->current;
       clearActiveAnimation(driverId, state);
       state.latest = current;
       state.hasLatest = true;
       applyToViews(state, current);
-      emitCompletion(driverId, animationId, false);
+      emitCompletion(driverId, animationId, completionTag, false);
     }
     state.ownership = Ownership::Interactive;
   }
@@ -1161,17 +1052,21 @@ std::vector<DriverSnapshot> beginGroupInteraction(
 
 bool setPresentationBatch(const std::vector<BatchEntry> &entries) {
   if (!isOnMainThread() || entries.empty()) return false;
+  std::vector<BatchEntry> canonicalEntries = entries;
+  for (BatchEntry &entry : canonicalEntries) {
+    if (!canonicalizePresentation(entry.presentation)) return false;
+  }
   std::vector<uint64_t> unique;
   std::vector<int32_t> groupsToCancel;
   unique.reserve(entries.size());
-  for (const BatchEntry &entry : entries) {
+  for (const BatchEntry &entry : canonicalEntries) {
     if (entry.driverId == 0 ||
         std::find(unique.begin(), unique.end(), entry.driverId) != unique.end()) {
       return false;
     }
     const auto iterator = registry().find(entry.driverId);
     if (iterator == registry().end() || iterator->second.destroyed ||
-        !isFiniteProtocolV2Presentation(entry.presentation)) {
+        !isFinitePresentation(entry.presentation)) {
       return false;
     }
     if (iterator != registry().end() && iterator->second.groupId != 0 &&
@@ -1192,16 +1087,17 @@ bool setPresentationBatch(const std::vector<BatchEntry> &entries) {
   }
 
   const double now = nowSeconds();
-  for (const BatchEntry &entry : entries) {
+  for (const BatchEntry &entry : canonicalEntries) {
     DriverState &state = registry().at(entry.driverId);
     state.destroyed = false;
     finishActive(entry.driverId, state, false);
     state.latest = entry.presentation;
     state.hasLatest = true;
     state.ownership = Ownership::Interactive;
-    recordVelocitySample(state.samples, toChannels(entry.presentation), now);
+    recordVelocitySample(
+        state.samples, velocityChannels(entry.presentation), now);
   }
-  for (const BatchEntry &entry : entries) {
+  for (const BatchEntry &entry : canonicalEntries) {
     applyToViews(registry().at(entry.driverId), entry.presentation);
   }
   return true;
@@ -1217,24 +1113,23 @@ int32_t startGroupCommon(
     SpringAnimation spring,
     double durationMs,
     int32_t reduceMotion,
-    GroupSuspensionPolicy suspensionPolicy,
+    int32_t completionTag,
     double startedAtHintS) {
-  if (!isOnMainThread() || controllerId == 0 || entries.empty() ||
-      (suspensionPolicy != GroupSuspensionPolicy::Pause &&
-       suspensionPolicy != GroupSuspensionPolicy::Finish)) {
+  if (!isOnMainThread() || controllerId == 0 || entries.empty()) {
     return 0;
   }
+  for (GroupMotionEntry &entry : entries) {
+    if ((entry.hasFrom && !canonicalizePresentation(entry.from)) ||
+        !canonicalizePresentation(entry.target)) {
+      return 0;
+    }
+  }
   if (kind == AnimationKind::Timing &&
-      !isValidProtocolV2Timing(timing)) {
+      !isValidTiming(timing)) {
     return 0;
   }
   if (kind == AnimationKind::Spring &&
-      !isValidProtocolV2Spring(spring)) {
-    return 0;
-  }
-  if (kind == AnimationKind::Keyframes &&
-      (!std::isfinite(durationMs) || durationMs < 0 ||
-       !isValidReduceMotionCode(reduceMotion))) {
+      (!isValidSpring(spring) || spring.inheritVelocity)) {
     return 0;
   }
   const bool reduce = shouldReduceMotion(reduceMotion) ||
@@ -1264,36 +1159,16 @@ int32_t startGroupCommon(
     const Presentation resolvedStart = entry.hasFrom
         ? entry.from
         : visiblePresentation(entry.driverId, iterator->second);
-    if (!isFiniteProtocolV2Presentation(resolvedStart) ||
-        !isFiniteProtocolV2Presentation(entry.target) ||
-        resolvedStart.clip.curve != entry.target.clip.curve) {
-      return 0;
-    }
-    if (kind == AnimationKind::Spring &&
-        !protocolV2SpringScaleIsProvablyPositive(
-            resolvedStart, entry.target, spring)) {
-      return 0;
-    }
-    if (kind == AnimationKind::Keyframes) {
-      if (!isValidProtocolV2Keyframes(
-              entry.keyframes,
-              resolvedStart,
-              entry.target,
-              entry.hasFrom)) {
-        return 0;
-      }
-    } else if (!entry.keyframes.empty()) {
+    if (!isFinitePresentation(resolvedStart) ||
+        !isFinitePresentation(entry.target) ||
+        !isAutonomousUniformCircular(resolvedStart) ||
+        !isAutonomousUniformCircular(entry.target)) {
       return 0;
     }
-    if (!reduce && iterator != registry().end()) {
-      if (kind == AnimationKind::Timing &&
-          !timingPlanPreservesLinearHostNormalization(
-              iterator->second, resolvedStart, entry.target, timing)) {
-        return 0;
-      }
-      if (kind == AnimationKind::Keyframes &&
-          !keyframePlanPreservesLinearHostNormalization(
-              iterator->second, resolvedStart, entry.keyframes)) {
+    if (kind == AnimationKind::Spring) {
+      const double velocity = spring.initialVelocity;
+      if (!springScaleStaysPositive(
+              resolvedStart, entry.target, spring, velocity)) {
         return 0;
       }
     }
@@ -1311,10 +1186,11 @@ int32_t startGroupCommon(
   ActiveGroup group;
   group.controllerId = controllerId;
   group.id = allocateAnimationId();
+  group.completionTag = completionTag;
   group.kind = kind;
-  group.suspensionPolicy = suspensionPolicy;
   group.timing = timing;
   group.spring = spring;
+  group.scalarSpring = {0, spring.initialVelocity};
   group.durationS = durationMs / 1000.0;
   group.members.reserve(entries.size());
   const double wallNow = nowSeconds();
@@ -1340,32 +1216,13 @@ int32_t startGroupCommon(
     member.animation.timing = timing;
     member.animation.spring = spring;
     member.animation.durationS = group.durationS;
-    if (kind == AnimationKind::Keyframes) {
-      if (!entry.hasFrom) {
-        entry.keyframes.front().presentation = resolvedStart;
-      }
-      member.animation.keyframes.reset(std::move(entry.keyframes));
-    } else if (kind == AnimationKind::Spring) {
-      const double velocity = spring.inheritVelocity
-          ? inheritedVelocity(state.samples, toChannels(entry.target), wallNow)
-          : spring.initialVelocity;
-      member.animation.spring.initialVelocity = velocity;
-      member.animation.spring.inheritVelocity = false;
-      const Channels startChannels = toChannels(resolvedStart);
-      const Channels targetChannels = toChannels(entry.target);
-      for (std::size_t index = 0; index < kChannelCount; index += 1) {
-        member.animation.springPosition[index] = startChannels[index];
-        member.animation.springVelocity[index] =
-            velocity * (targetChannels[index] - startChannels[index]);
-      }
-    }
     group.members.push_back(std::move(member));
   }
 
   // Apply every explicit start after the whole participant set has passed
   // preflight and acquired the new immutable group id. This remains one
   // synchronous main-thread transaction even when the initial readiness
-  // barrier is latched; ready hosts must not keep displaying their old frame
+  // barrier is pending; ready hosts must not keep displaying their old frame
   // while snapshots already report `from`.
   for (std::size_t entryIndex = 0; entryIndex < entries.size(); entryIndex += 1) {
     if (!entries[entryIndex].hasFrom) continue;
@@ -1392,9 +1249,7 @@ int32_t startGroupCommon(
   }
   ActiveGroup &stored = groupRegistry().at(groupId);
   if (stored.started) {
-    animatingGroups().push_back(groupId);
-    applyGroupCurrent(stored);
-    scheduleFrame();
+    startGroupFrameLoop(stored);
   }
   return groupId;
 }
@@ -1405,7 +1260,7 @@ int32_t animateTimingGroup(
     uint64_t controllerId,
     std::vector<GroupMotionEntry> entries,
     TimingAnimation animation,
-    GroupSuspensionPolicy suspensionPolicy,
+    int32_t completionTag,
     double startedAtHintS) {
   return startGroupCommon(
       controllerId,
@@ -1415,7 +1270,7 @@ int32_t animateTimingGroup(
       {},
       animation.durationMs,
       animation.reduceMotion,
-      suspensionPolicy,
+      completionTag,
       startedAtHintS);
 }
 
@@ -1423,7 +1278,7 @@ int32_t animateSpringGroup(
     uint64_t controllerId,
     std::vector<GroupMotionEntry> entries,
     SpringAnimation animation,
-    GroupSuspensionPolicy suspensionPolicy,
+    int32_t completionTag,
     double startedAtHintS) {
   return startGroupCommon(
       controllerId,
@@ -1433,26 +1288,7 @@ int32_t animateSpringGroup(
       animation,
       kSpringMaxDurationS * 1000.0,
       animation.reduceMotion,
-      suspensionPolicy,
-      startedAtHintS);
-}
-
-int32_t animateKeyframesGroup(
-    uint64_t controllerId,
-    std::vector<GroupMotionEntry> entries,
-    double durationMs,
-    int32_t reduceMotion,
-    GroupSuspensionPolicy suspensionPolicy,
-    double startedAtHintS) {
-  return startGroupCommon(
-      controllerId,
-      std::move(entries),
-      AnimationKind::Keyframes,
-      {},
-      {},
-      durationMs,
-      reduceMotion,
-      suspensionPolicy,
+      completionTag,
       startedAtHintS);
 }
 
@@ -1472,6 +1308,7 @@ void setPresentation(
     bool overridePendingAnimation,
     bool recordVelocity) {
   if (!isOnMainThread()) return;
+  if (!canonicalizePresentation(presentation)) return;
   SMOOTH_CLIP_TRACE("SmoothClip.setPresentation");
   auto iterator = registry().find(driverId);
   if (!takeOwnership) {
@@ -1493,7 +1330,7 @@ void setPresentation(
     state.destroyed = false;
     // 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.
+    // authoritative start and explicitly cancels the pending run.
     if (state.animation.has_value() && !state.animation->started &&
         !overridePendingAnimation) {
       return;
@@ -1504,7 +1341,8 @@ void setPresentation(
   state.hasLatest = true;
   state.ownership = Ownership::Interactive;
   if (recordVelocity) {
-    recordVelocitySample(state.samples, toChannels(presentation), nowSeconds());
+    recordVelocitySample(
+        state.samples, velocityChannels(presentation), nowSeconds());
   } else if (state.samples.hasLatest) {
     // Untracked movement invalidates the recorded velocity pair.
     clearVelocitySamples(state.samples);
@@ -1526,6 +1364,7 @@ Presentation beginInteraction(uint64_t driverId) {
     return state.latest;
   }
   const int32_t animationId = state.animation->id;
+  const int32_t completionTag = state.animation->completionTag;
   const Presentation current = state.animation->current;
   clearActiveAnimation(driverId, state);
   state.latest = current;
@@ -1534,7 +1373,7 @@ Presentation beginInteraction(uint64_t driverId) {
   // 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);
+  emitCompletion(driverId, animationId, completionTag, false);
   return current;
 }
 
@@ -1543,29 +1382,22 @@ int32_t animateTiming(
     AnimationStart start,
     Presentation presentation,
     TimingAnimation animation,
-    AnimationValidationMode validationMode) {
-  const bool strictV2 =
-      validationMode == AnimationValidationMode::ProtocolV2;
-  const bool validAnimation = strictV2
-      ? isValidProtocolV2Timing(animation)
-      : std::isfinite(animation.durationMs) &&
-          std::isfinite(animation.controlPoint1X) &&
-          std::isfinite(animation.controlPoint1Y) &&
-          std::isfinite(animation.controlPoint2X) &&
-          std::isfinite(animation.controlPoint2Y) &&
-          isValidReduceMotionCode(animation.reduceMotion);
-  if (!strictV2 && validAnimation) {
-    animation.durationMs = std::max(0.0, animation.durationMs);
+    int32_t completionTag) {
+  const bool validAnimation = isValidTiming(animation);
+  if (!canonicalizePresentation(presentation) ||
+      (start.hasInteractiveStart &&
+       !canonicalizePresentation(start.interactiveStart))) {
+    return 0;
   }
   if (!isOnMainThread() || driverId == 0 ||
-      !isFiniteProtocolV2Presentation(presentation) || !validAnimation) {
+      !isFinitePresentation(presentation) || !validAnimation) {
     return 0;
   }
   auto iterator = registry().find(driverId);
   Presentation preflightStart;
   if (iterator == registry().end()) {
     if (!start.hasInteractiveStart ||
-        !isFiniteProtocolV2Presentation(start.interactiveStart)) {
+        !isFinitePresentation(start.interactiveStart)) {
       return 0;
     }
     preflightStart = start.interactiveStart;
@@ -1575,17 +1407,12 @@ int32_t animateTiming(
         ? start.interactiveStart
         : visiblePresentation(driverId, iterator->second);
   }
-  if (!isFiniteProtocolV2Presentation(preflightStart) ||
+  if (!isFinitePresentation(preflightStart) ||
       preflightStart.clip.curve != presentation.clip.curve) {
     return 0;
   }
   const bool reduce = shouldReduceMotion(animation.reduceMotion) ||
       animation.durationMs <= 0;
-  if (strictV2 && !reduce && iterator != registry().end() &&
-      !timingPlanPreservesLinearHostNormalization(
-          iterator->second, preflightStart, presentation, animation)) {
-    return 0;
-  }
   if (iterator == registry().end()) {
     iterator = registry().try_emplace(driverId).first;
     iterator->second.latest = start.interactiveStart;
@@ -1599,11 +1426,12 @@ int32_t animateTiming(
       prepareAnimation(driverId, state, start, presentation);
   if (reduce) {
     applyPresentation(state, presentation);
-    emitCompletion(driverId, animationId, true);
+    emitCompletion(driverId, animationId, completionTag, true);
     return animationId;
   }
   ActiveAnimation active;
   active.id = animationId;
+  active.completionTag = completionTag;
   active.kind = AnimationKind::Timing;
   active.timing = animation;
   active.start = resolvedStart;
@@ -1617,30 +1445,22 @@ int32_t animateSpring(
     AnimationStart start,
     Presentation presentation,
     SpringAnimation animation,
-    AnimationValidationMode validationMode) {
-  const bool strictV2 =
-      validationMode == AnimationValidationMode::ProtocolV2;
-  const bool validAnimation = strictV2
-      ? isValidProtocolV2Spring(animation)
-      : std::isfinite(animation.mass) &&
-          std::isfinite(animation.stiffness) &&
-          std::isfinite(animation.damping) &&
-          std::isfinite(animation.initialVelocity) &&
-          isValidReduceMotionCode(animation.reduceMotion);
-  if (!strictV2 && validAnimation) {
-    animation.mass = std::max(0.0001, animation.mass);
-    animation.stiffness = std::max(0.0001, animation.stiffness);
-    animation.damping = std::max(0.0, animation.damping);
+    int32_t completionTag) {
+  const bool validAnimation = isValidSpring(animation);
+  if (!canonicalizePresentation(presentation) ||
+      (start.hasInteractiveStart &&
+       !canonicalizePresentation(start.interactiveStart))) {
+    return 0;
   }
   if (!isOnMainThread() || driverId == 0 ||
-      !isFiniteProtocolV2Presentation(presentation) || !validAnimation) {
+      !isFinitePresentation(presentation) || !validAnimation) {
     return 0;
   }
   auto iterator = registry().find(driverId);
   Presentation preflightStart;
   if (iterator == registry().end()) {
     if (!start.hasInteractiveStart ||
-        !isFiniteProtocolV2Presentation(start.interactiveStart)) {
+        !isFinitePresentation(start.interactiveStart)) {
       return 0;
     }
     preflightStart = start.interactiveStart;
@@ -1650,10 +1470,17 @@ int32_t animateSpring(
         ? start.interactiveStart
         : visiblePresentation(driverId, iterator->second);
   }
-  if (!isFiniteProtocolV2Presentation(preflightStart) ||
+  const double velocity = animation.inheritVelocity &&
+          iterator != registry().end()
+      ? inheritedVelocity(
+            iterator->second.samples,
+            velocityChannels(presentation),
+            nowSeconds())
+      : animation.initialVelocity;
+  if (!isFinitePresentation(preflightStart) ||
       preflightStart.clip.curve != presentation.clip.curve ||
-      (strictV2 && !protocolV2SpringScaleIsProvablyPositive(
-          preflightStart, presentation, animation))) {
+      !springScaleStaysPositive(
+          preflightStart, presentation, animation, velocity)) {
     return 0;
   }
   if (iterator == registry().end()) {
@@ -1668,18 +1495,16 @@ int32_t animateSpring(
   // Scalar velocity along the current-to-target trajectory; each channel is
   // seeded with velocity·displacement to match the iOS CASpringAnimation
   // per-keypath behavior.
-  const double velocity = animation.inheritVelocity
-      ? inheritedVelocity(state.samples, toChannels(presentation), nowSeconds())
-      : animation.initialVelocity;
   const Presentation resolvedStart =
       prepareAnimation(driverId, state, start, presentation);
   if (shouldReduceMotion(animation.reduceMotion)) {
     applyPresentation(state, presentation);
-    emitCompletion(driverId, animationId, true);
+    emitCompletion(driverId, animationId, completionTag, true);
     return animationId;
   }
   ActiveAnimation active;
   active.id = animationId;
+  active.completionTag = completionTag;
   active.kind = AnimationKind::Spring;
   active.spring = animation;
   active.spring.initialVelocity = velocity;
@@ -1687,106 +1512,31 @@ int32_t animateSpring(
   active.start = resolvedStart;
   active.target = presentation;
   active.durationS = kSpringMaxDurationS;
-  const auto startChannels = toChannels(resolvedStart);
-  const auto targetChannels = toChannels(presentation);
-  for (std::size_t index = 0; index < kChannelCount; index += 1) {
-    active.springPosition[index] = startChannels[index];
+  const auto normalizedEndpoints = normalizeShadowEndpoints(
+      resolvedStart, presentation);
+  const auto startChannels = toChannels(normalizedEndpoints.first);
+  const auto targetChannels = toChannels(normalizedEndpoints.second);
+  active.springChannelCount =
+      (resolvedStart.shadow.enabled && resolvedStart.shadow.alpha > 0) ||
+          (presentation.shadow.enabled && presentation.shadow.alpha > 0)
+      ? kChannelCount
+      : kBaseChannelCount;
+  active.springPosition = startChannels;
+  for (std::size_t index = 0;
+       index < active.springChannelCount;
+       index += 1) {
     active.springVelocity[index] =
         velocity * (targetChannels[index] - startChannels[index]);
   }
   return startAnimation(driverId, state, std::move(active), start.startedAtHintS);
 }
 
-int32_t animateKeyframes(
-    uint64_t driverId,
-    AnimationStart start,
-    Presentation presentation,
-    double durationMs,
-    std::vector<Keyframe> keyframes,
-    int32_t reduceMotion,
-    AnimationValidationMode validationMode) {
-  const bool strictV2 =
-      validationMode == AnimationValidationMode::ProtocolV2;
-  const bool finiteDuration = std::isfinite(durationMs);
-  if (!strictV2 && finiteDuration) durationMs = std::max(0.0, durationMs);
-  if (!isOnMainThread() || driverId == 0 ||
-      !isFiniteProtocolV2Presentation(presentation) ||
-      !finiteDuration || (strictV2 && durationMs < 0) ||
-      !isValidReduceMotionCode(reduceMotion)) {
-    return 0;
-  }
-  auto iterator = registry().find(driverId);
-  Presentation preflightStart;
-  if (iterator == registry().end()) {
-    if (!start.hasInteractiveStart ||
-        !isFiniteProtocolV2Presentation(start.interactiveStart)) {
-      return 0;
-    }
-    preflightStart = start.interactiveStart;
-  } else {
-    if (iterator->second.destroyed && !start.hasInteractiveStart) return 0;
-    preflightStart = start.hasInteractiveStart
-        ? start.interactiveStart
-        : visiblePresentation(driverId, iterator->second);
-  }
-  bool validKeyframes = keyframes.size() >= 2 &&
-      keyframes.front().offset == 0 && keyframes.back().offset == 1;
-  double previousOffset = -1;
-  for (const Keyframe &keyframe : keyframes) {
-    validKeyframes = validKeyframes && std::isfinite(keyframe.offset) &&
-        keyframe.offset > previousOffset && keyframe.offset >= 0 &&
-        keyframe.offset <= 1 &&
-        isFiniteProtocolV2Presentation(keyframe.presentation);
-    previousOffset = keyframe.offset;
-  }
-  if (strictV2) {
-    validKeyframes = isValidProtocolV2Keyframes(
-        keyframes, preflightStart, presentation, start.hasInteractiveStart);
-  }
-  if (!isFiniteProtocolV2Presentation(preflightStart) || !validKeyframes) {
-    return 0;
-  }
-  const bool reduce = shouldReduceMotion(reduceMotion) || durationMs <= 0;
-  if (strictV2 && !reduce && iterator != registry().end() &&
-      !keyframePlanPreservesLinearHostNormalization(
-          iterator->second, preflightStart, keyframes)) {
-    return 0;
-  }
-  if (iterator == registry().end()) {
-    iterator = registry().try_emplace(driverId).first;
-    iterator->second.latest = start.interactiveStart;
-    iterator->second.hasLatest = true;
-  }
-  auto &state = iterator->second;
-  if (state.groupId != 0) finishGroupImpl(state.groupId, false, false);
-  state.destroyed = false;
-  const int32_t animationId = allocateAnimationId();
-  const Presentation resolvedStart =
-      prepareAnimation(driverId, state, start, presentation);
-  if (reduce) {
-    applyPresentation(state, presentation);
-    emitCompletion(driverId, animationId, true);
-    return animationId;
-  }
-  if (strictV2 && !start.hasInteractiveStart) {
-    keyframes.front().presentation = resolvedStart;
-  }
-  ActiveAnimation active;
-  active.id = animationId;
-  active.kind = AnimationKind::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), 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();
-  emitCompletion(driverId, animationId, false);
+  emitCompletion(driverId, animationId, 0, false);
   return animationId;
 }
 
@@ -1820,12 +1570,13 @@ CancelResult cancelAnimation(
   const Presentation result =
       useTarget ? state.animation->target : state.animation->current;
   const int32_t activeId = state.animation->id;
+  const int32_t completionTag = state.animation->completionTag;
   clearActiveAnimation(driverId, state);
   state.latest = result;
   state.hasLatest = true;
   state.ownership = Ownership::Interactive;
   applyToViews(state, result);
-  emitCompletion(driverId, activeId, false);
+  emitCompletion(driverId, activeId, completionTag, false);
   return {true, result};
 }
 
@@ -1856,23 +1607,6 @@ void destroyDriver(uint64_t driverId) {
 // --- Android view lifecycle ----------------------------------------------
 
 void JSmoothClipView::applyClip(const Presentation &presentation) const {
-  static const auto method =
-      javaClassStatic()
-          ->getMethod<void(
-              jdouble, jdouble, jdouble, jdouble, jdouble, jdouble, jdouble)>(
-              "setClipPresentationDip");
-  method(
-      self(),
-      presentation.clip.x,
-      presentation.clip.y,
-      presentation.clip.width,
-      presentation.clip.height,
-      presentation.clip.radius,
-      presentation.contentTranslateX,
-      presentation.contentTranslateY);
-}
-
-void JSmoothClipView::applyClipV2(const Presentation &presentation) const {
   static const auto method =
       javaClassStatic()
           ->getMethod<void(
@@ -1887,7 +1621,16 @@ void JSmoothClipView::applyClipV2(const Presentation &presentation) const {
               jint,
               jdouble,
               jdouble,
-              jdouble)>("setClipPresentationV2Dip");
+              jdouble,
+              jboolean,
+              jdouble,
+              jdouble,
+              jdouble,
+              jdouble,
+              jdouble,
+              jdouble,
+              jdouble,
+              jdouble)>("setClipPresentationDip");
   method(
       self(),
       presentation.clip.x,
@@ -1905,34 +1648,24 @@ void JSmoothClipView::applyClipV2(const Presentation &presentation) const {
       static_cast<jint>(presentation.clip.curve),
       presentation.contentTranslateX,
       presentation.contentTranslateY,
-      presentation.contentScale);
+      presentation.contentScale,
+      presentation.shadow.enabled,
+      presentation.shadow.red,
+      presentation.shadow.green,
+      presentation.shadow.blue,
+      presentation.shadow.alpha,
+      presentation.shadow.offsetX,
+      presentation.shadow.offsetY,
+      presentation.shadow.blurRadius,
+      presentation.shadow.spreadDistance);
 }
 
 void JSmoothClipView::applyClipPx(
-    const NormalizedClip &clip,
-    double contentTranslateXPx,
-    double contentTranslateYPx) const {
-  static const auto method =
-      javaClassStatic()
-          ->getMethod<void(
-              jfloat, jfloat, jfloat, jfloat, jfloat, jfloat, jfloat)>(
-              "setClipPresentationPx");
-  method(
-      self(),
-      static_cast<jfloat>(clip.left),
-      static_cast<jfloat>(clip.top),
-      static_cast<jfloat>(clip.right),
-      static_cast<jfloat>(clip.bottom),
-      static_cast<jfloat>(clip.radius),
-      static_cast<jfloat>(contentTranslateXPx),
-      static_cast<jfloat>(contentTranslateYPx));
-}
-
-void JSmoothClipView::applyClipV2Px(
-    const NormalizedClip &clip,
+    const CanonicalClip &clip,
     double contentTranslateXPx,
     double contentTranslateYPx,
-    double contentScale) const {
+    double contentScale,
+    const Shadow &shadowPx) const {
   static const auto method =
       javaClassStatic()
           ->getMethod<void(
@@ -1947,7 +1680,16 @@ void JSmoothClipView::applyClipV2Px(
               jint,
               jfloat,
               jfloat,
-              jfloat)>("setClipPresentationV2Px");
+              jfloat,
+              jboolean,
+              jfloat,
+              jfloat,
+              jfloat,
+              jfloat,
+              jfloat,
+              jfloat,
+              jfloat,
+              jfloat)>("setClipPresentationPx");
   method(
       self(),
       static_cast<jfloat>(clip.left),
@@ -1961,7 +1703,22 @@ void JSmoothClipView::applyClipV2Px(
       static_cast<jint>(clip.curve),
       static_cast<jfloat>(contentTranslateXPx),
       static_cast<jfloat>(contentTranslateYPx),
-      static_cast<jfloat>(contentScale));
+      static_cast<jfloat>(contentScale),
+      shadowPx.enabled,
+      static_cast<jfloat>(shadowPx.red),
+      static_cast<jfloat>(shadowPx.green),
+      static_cast<jfloat>(shadowPx.blue),
+      static_cast<jfloat>(shadowPx.alpha),
+      static_cast<jfloat>(shadowPx.offsetX),
+      static_cast<jfloat>(shadowPx.offsetY),
+      static_cast<jfloat>(shadowPx.blurRadius),
+      static_cast<jfloat>(shadowPx.spreadDistance));
+}
+
+void JSmoothClipView::setAutonomousMotion(bool active) const {
+  static const auto method =
+      javaClassStatic()->getMethod<void(jboolean)>("setAutonomousMotion");
+  method(self(), active);
 }
 
 void registerViewAndroid(
@@ -1972,6 +1729,7 @@ void registerViewAndroid(
     double hostWidthPx,
     double hostHeightPx,
     bool lifecycleVisible) {
+  if (!canonicalizePresentation(initialPresentation)) return;
   auto &state = registry()[driverId];
   state.destroyed = false;
   if (!state.hasLatest) {
@@ -1992,6 +1750,10 @@ void registerViewAndroid(
       return;
     }
   }
+  // The public controller contract permits one simultaneous host. The React
+  // wrapper reports this as a development error; native also refuses a second
+  // host so release behavior cannot silently fan one controller out.
+  if (!state.views.empty()) return;
   ViewEntry entry{
       facebook::jni::make_global(view),
       density,
@@ -1999,8 +1761,7 @@ void registerViewAndroid(
       hostHeightPx,
       lifecycleVisible,
       ViewParticipation::Deferred};
-  // `visible` above already delivered animation->current (= start) to the
-  // registering view — the correct first frame for a latched animation.
+  // `visible` already contains the start of a pre-ready animation.
   deliverToView(entry, visible);
   state.views.push_back(std::move(entry));
   reconcileViewDisplayability(driverId, state, state.views.back());
@@ -2057,12 +1818,9 @@ 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 {
@@ -2070,10 +1828,6 @@ void unregisterViewAndroid(
     }
   }
   if (removed && state.animation.has_value()) {
-    // 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
@@ -2087,7 +1841,7 @@ void unregisterViewAndroid(
       // for the next main-thread event (attach, host geometry, destroy) to
       // resolve.
     } else {
-      relatchIfNoDisplayable(driverId, state);
+      finishIfHostUnavailable(driverId, state);
     }
   }
   if (removed && state.groupId != 0 && isOnMainThread()) {