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

package/ios/SmoothClipView.mm

@@ -16,7 +16,9 @@
 #import <react/renderer/components/SmoothClipViewSpec/Props.h>
 #import <react/renderer/components/SmoothClipViewSpec/RCTComponentViewHelpers.h>
 
+#include <algorithm>
 #include <cfloat>
+#include <cmath>
 
 using namespace facebook::react;
 
@@ -80,7 +82,7 @@ static SmoothClipCornerCurve SmoothClipPresentationCurve(
       : SmoothClipCornerCurveCircular;
 }
 
-static bool SmoothClipBuildPresentationV2(
+static bool SmoothClipBuildPresentation(
     double x,
     double y,
     double width,
@@ -93,13 +95,30 @@ static bool SmoothClipBuildPresentationV2(
     double contentTranslateX,
     double contentTranslateY,
     double contentScale,
+    BOOL shadowEnabled,
+    double shadowRed,
+    double shadowGreen,
+    double shadowBlue,
+    double shadowAlpha,
+    double shadowOffsetX,
+    double shadowOffsetY,
+    double shadowBlurRadius,
+    double shadowSpreadDistance,
     smoothclip::Presentation *result) {
   if (result == nullptr || !isfinite(x) || !isfinite(y) ||
       !isfinite(width) || !isfinite(height) ||
       !isfinite(topLeftRadius) || !isfinite(topRightRadius) ||
       !isfinite(bottomRightRadius) || !isfinite(bottomLeftRadius) ||
       !isfinite(contentTranslateX) || !isfinite(contentTranslateY) ||
-      !isfinite(contentScale) || contentScale <= 0 ||
+      !isfinite(contentScale) || !isfinite(shadowRed) ||
+      !isfinite(shadowGreen) || !isfinite(shadowBlue) ||
+      !isfinite(shadowAlpha) ||
+      !isfinite(shadowOffsetX) || !isfinite(shadowOffsetY) ||
+      !isfinite(shadowBlurRadius) || !isfinite(shadowSpreadDistance) ||
+      contentScale <= 0 || shadowRed < 0 || shadowRed > 1 ||
+      shadowGreen < 0 || shadowGreen > 1 ||
+      shadowBlue < 0 || shadowBlue > 1 ||
+      shadowAlpha < 0 || shadowAlpha > 1 || shadowBlurRadius < 0 ||
       (curveCode != static_cast<NSInteger>(smoothclip::ClipCurve::Circular) &&
        curveCode != static_cast<NSInteger>(smoothclip::ClipCurve::Continuous))) {
     return false;
@@ -115,11 +134,121 @@ static bool SmoothClipBuildPresentationV2(
   geometry.bottomRightRadius = bottomRightRadius;
   geometry.bottomLeftRadius = bottomLeftRadius;
   geometry.curve = static_cast<smoothclip::ClipCurve>(curveCode);
+  const smoothclip::Shadow shadow{
+      shadowEnabled,
+      shadowRed,
+      shadowGreen,
+      shadowBlue,
+      shadowAlpha,
+      shadowOffsetX,
+      shadowOffsetY,
+      shadowBlurRadius,
+      shadowSpreadDistance};
   *result = {
-      geometry, contentTranslateX, contentTranslateY, contentScale};
+      geometry, contentTranslateX, contentTranslateY, contentScale, shadow};
   return true;
 }
 
+static bool SmoothBoxShadowEqual(
+    const smoothclip::Shadow &first,
+    const smoothclip::Shadow &second) {
+  return first.enabled == second.enabled &&
+      first.red == second.red && first.green == second.green &&
+      first.blue == second.blue && first.alpha == second.alpha &&
+      first.offsetX == second.offsetX && first.offsetY == second.offsetY &&
+      first.blurRadius == second.blurRadius &&
+      first.spreadDistance == second.spreadDistance;
+}
+
+static bool SmoothBoxShadowVisible(
+    SmoothClipCanonicalGeometry geometry,
+    const smoothclip::Shadow &shadow) {
+  return shadow.enabled && shadow.alpha > 0 && !CGRectIsEmpty(geometry.rect);
+}
+
+static smoothclip::Shadow SmoothBoxShadowWithEffectiveAlpha(
+    SmoothClipCanonicalGeometry geometry,
+    smoothclip::Shadow shadow) {
+  if (!SmoothBoxShadowVisible(geometry, shadow)) {
+    shadow.alpha = 0;
+  }
+  return shadow;
+}
+
+static void SmoothBoxShadowNormalizeAnimationEndpoints(
+    SmoothClipCanonicalGeometry fromGeometry,
+    smoothclip::Shadow *fromShadow,
+    SmoothClipCanonicalGeometry toGeometry,
+    smoothclip::Shadow *toShadow) {
+  const bool fromVisible = SmoothBoxShadowVisible(fromGeometry, *fromShadow);
+  const bool toVisible = SmoothBoxShadowVisible(toGeometry, *toShadow);
+  if (fromVisible == toVisible) {
+    *fromShadow = SmoothBoxShadowWithEffectiveAlpha(
+        fromGeometry, *fromShadow);
+    *toShadow = SmoothBoxShadowWithEffectiveAlpha(toGeometry, *toShadow);
+    return;
+  }
+
+  smoothclip::Shadow *invisible = fromVisible ? toShadow : fromShadow;
+  const smoothclip::Shadow &visible = fromVisible ? *fromShadow : *toShadow;
+  invisible->enabled = true;
+  invisible->red = visible.red;
+  invisible->green = visible.green;
+  invisible->blue = visible.blue;
+  invisible->alpha = 0;
+  invisible->offsetX = visible.offsetX;
+  invisible->offsetY = visible.offsetY;
+  invisible->blurRadius = visible.blurRadius;
+  invisible->spreadDistance = visible.spreadDistance;
+}
+
+static bool SmoothBoxShadowColorEqual(
+    const smoothclip::Shadow &first,
+    const smoothclip::Shadow &second) {
+  return first.red == second.red && first.green == second.green &&
+      first.blue == second.blue && first.alpha == second.alpha;
+}
+
+static bool SmoothBoxShadowPathInputEqual(
+    SmoothClipCanonicalGeometry firstGeometry,
+    const smoothclip::Shadow &firstShadow,
+    SmoothClipCanonicalGeometry secondGeometry,
+    const smoothclip::Shadow &secondShadow) {
+  return CGRectEqualToRect(firstGeometry.rect, secondGeometry.rect) &&
+      SmoothClipCornerRadiiEqual(
+          firstGeometry.radii, secondGeometry.radii) &&
+      firstGeometry.curve == secondGeometry.curve &&
+      firstShadow.spreadDistance == secondShadow.spreadDistance;
+}
+
+static CGFloat SmoothClipAdjustedShadowRadius(
+    CGFloat radius,
+    CGFloat spread) {
+  const CGFloat magnitude = ABS(spread);
+  CGFloat multiplier = 1;
+  if (magnitude > 0 && radius < magnitude) {
+    multiplier = 1 + pow(radius / magnitude - 1, 3);
+  }
+  return MAX(0, radius + spread * multiplier);
+}
+
+static CGPathRef SmoothClipCreateShadowPath(
+    SmoothClipCanonicalGeometry geometry,
+    const smoothclip::Shadow &shadow) {
+  const CGFloat spread = shadow.spreadDistance;
+  CGRect rect = CGRectInset(geometry.rect, -spread, -spread);
+  if (CGRectGetWidth(rect) <= 0 || CGRectGetHeight(rect) <= 0) {
+    rect = CGRectZero;
+  }
+  const SmoothClipCornerRadii radii = {
+      SmoothClipAdjustedShadowRadius(geometry.radii.topLeft, spread),
+      SmoothClipAdjustedShadowRadius(geometry.radii.topRight, spread),
+      SmoothClipAdjustedShadowRadius(geometry.radii.bottomRight, spread),
+      SmoothClipAdjustedShadowRadius(geometry.radii.bottomLeft, spread),
+  };
+  return SmoothClipCreateRoundedRectPath(rect, radii, geometry.curve);
+}
+
 static NSString *SmoothClipCALayerCornerCurve(
     SmoothClipCornerCurve curve) API_AVAILABLE(ios(13.0)) {
   return curve == SmoothClipCornerCurveContinuous
@@ -191,24 +320,38 @@ static std::array<double, 11> SmoothClipVelocityChannels(
           contentScale};
 }
 
+static BOOL SmoothClipRectIntersectsHost(CGRect rect, CGRect host) {
+  const CGRect intersection = CGRectIntersection(rect, host);
+  return !CGRectIsNull(intersection) && !CGRectIsEmpty(intersection);
+}
+
+static smoothclip::Presentation SmoothClipCanonicalSnapshot(
+    smoothclip::Presentation presentation) {
+  smoothclip::canonicalizePresentation(presentation);
+  return presentation;
+}
+
 @implementation SmoothClipView {
+  CALayer *_shadowLayer;
   SmoothClipContainerView *_clipContainer;
   SmoothClipContainerView *_contentContainer;
   CAShapeLayer *_unequalCornerMask;
   CGRect _requestedClip;
-  CGRect _normalizedClip;
+  CGRect _canonicalClip;
   CGFloat _requestedRadius;
-  CGFloat _normalizedRadius;
+  CGFloat _canonicalRadius;
   SmoothClipCornerRadii _requestedRadii;
-  SmoothClipCornerRadii _normalizedRadii;
+  SmoothClipCornerRadii _canonicalRadii;
   SmoothClipCornerCurve _requestedCurve;
-  SmoothClipCornerCurve _normalizedCurve;
+  SmoothClipCornerCurve _canonicalCurve;
   BOOL _requestedHasExplicitRadii;
-  BOOL _normalizedHasExplicitRadii;
+  BOOL _canonicalHasExplicitRadii;
   CGPoint _requestedContentTranslation;
-  CGPoint _normalizedContentTranslation;
+  CGPoint _canonicalContentTranslation;
   CGFloat _requestedContentScale;
-  CGFloat _normalizedContentScale;
+  CGFloat _canonicalContentScale;
+  smoothclip::Shadow _requestedShadow;
+  smoothclip::Shadow _canonicalShadow;
   uint64_t _driverId;
   BOOL _hasLayout;
   BOOL _commandIsAuthoritative;
@@ -219,23 +362,11 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 
   int32_t _activeAnimationId;
   NSInteger _activeAnimationKind;
-  // Set when a native animation install arrived before the first layout.
-  // The install is deferred and re-run through the registry at first layout
-  // so it joins from live presentation geometry with the true remaining time.
-  BOOL _pendingAnimationInstall;
-  CFTimeInterval _animationStartedAt;
-  CFTimeInterval _animationDuration;
-  // Bumped on every CA install. updateLayoutMetrics captures it on entry so a
-  // registry-driven install that happens inside its own lifecycle notification
-  // (a latch resume during that very layout pass) is detectable: the local
-  // rebuild must then be skipped, because its captured remaining time predates
-  // the suspension and would shorten — or zero out — the fresh install.
-  uint32_t _animationInstallGeneration;
   smoothclip::TimingAnimation _timingAnimation;
   smoothclip::SpringAnimation _springAnimation;
   SmoothClipAnimationDelegate *_animationDelegate;
 
-  // 'inherit' velocity samples (normalized geometry, per view); recording/
+  // 'inherit' velocity samples (raw canonical geometry, per view); recording/
   // coalescing/projection live in the shared cpp/SmoothClipVelocityTracker.h
   // (behavior-paired with Android's per-driver history).
   smoothclip::VelocitySampleHistory _velocitySamples;
@@ -262,6 +393,9 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     static const auto defaultProps =
         std::make_shared<const SmoothClipViewProps>();
     _props = defaultProps;
+    // SmoothClipView is the fixed viewport. Consumer overflow props are
+    // intentionally overridden again after every prop update below.
+    self.clipsToBounds = YES;
 
     _clipContainer = [[SmoothClipContainerView alloc] initWithFrame:CGRectZero];
     _clipContainer.layer.masksToBounds = YES;
@@ -277,6 +411,9 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     [_clipContainer addSubview:_contentContainer];
     [self addSubview:_clipContainer];
 
+    _shadowLayer = nil;
+    // Created lazily so the common clipping-only path owns no shadow layer.
+
     _unequalCornerMask = [CAShapeLayer layer];
     _unequalCornerMask.actions = @{
       @"path": [NSNull null],
@@ -287,27 +424,27 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     _unequalCornerMask.needsDisplayOnBoundsChange = NO;
 
     _requestedClip = CGRectZero;
-    _normalizedClip = CGRectZero;
+    _canonicalClip = CGRectZero;
     _requestedRadius = 0;
-    _normalizedRadius = 0;
+    _canonicalRadius = 0;
     _requestedRadii = {0, 0, 0, 0};
-    _normalizedRadii = {0, 0, 0, 0};
+    _canonicalRadii = {0, 0, 0, 0};
     _requestedCurve = SmoothClipCornerCurveCircular;
-    _normalizedCurve = SmoothClipCornerCurveCircular;
+    _canonicalCurve = SmoothClipCornerCurveCircular;
     _requestedHasExplicitRadii = NO;
-    _normalizedHasExplicitRadii = NO;
+    _canonicalHasExplicitRadii = NO;
     _requestedContentTranslation = CGPointZero;
-    _normalizedContentTranslation = CGPointZero;
+    _canonicalContentTranslation = CGPointZero;
     _requestedContentScale = 1;
-    _normalizedContentScale = 1;
+    _canonicalContentScale = 1;
+    _requestedShadow = {};
+    _canonicalShadow = {};
     _driverId = 0;
     _hasLayout = NO;
     _commandIsAuthoritative = NO;
     _ignoreAnimationCallback = NO;
     _activeAnimationId = 0;
     _activeAnimationKind = 0;
-    _pendingAnimationInstall = NO;
-    _animationInstallGeneration = 0;
     smoothclip::clearVelocitySamples(_velocitySamples);
     // App-state transitions are observed by the registry itself (see
     // installApplicationStateObservers): the active flag is process-global,
@@ -364,9 +501,61 @@ static std::array<double, 11> SmoothClipVelocityChannels(
       presentation.contentTranslateX,
       presentation.contentTranslateY);
   _requestedContentScale = presentation.contentScale;
+  _requestedShadow = presentation.shadow;
+}
+
+- (CGColorRef)colorForShadow:(const smoothclip::Shadow &)shadow {
+  return [UIColor colorWithRed:smoothclip::clamp01(shadow.red)
+                         green:smoothclip::clamp01(shadow.green)
+                          blue:smoothclip::clamp01(shadow.blue)
+                         alpha:smoothclip::clamp01(shadow.alpha)].CGColor;
+}
+
+- (CALayer *)ensureShadowLayer {
+  if (_shadowLayer != nil) return _shadowLayer;
+  _shadowLayer = [CALayer layer];
+  _shadowLayer.masksToBounds = NO;
+  _shadowLayer.actions = @{
+    @"shadowPath": [NSNull null],
+    @"shadowColor": [NSNull null],
+    @"shadowOpacity": [NSNull null],
+    @"shadowRadius": [NSNull null],
+    @"shadowOffset": [NSNull null],
+    @"bounds": [NSNull null],
+    @"position": [NSNull null],
+  };
+  [self.layer insertSublayer:_shadowLayer below:_clipContainer.layer];
+  return _shadowLayer;
+}
+
+- (void)writeShadowModel:(const smoothclip::Shadow &)shadow
+                 geometry:(SmoothClipCanonicalGeometry)geometry {
+  const smoothclip::Shadow effectiveShadow =
+      SmoothBoxShadowWithEffectiveAlpha(geometry, shadow);
+  const BOOL visible = SmoothBoxShadowVisible(geometry, effectiveShadow);
+  if (_shadowLayer == nil && !visible) return;
+
+  CALayer *shadowLayer = visible ? [self ensureShadowLayer] : _shadowLayer;
+  shadowLayer.bounds = self.bounds;
+  shadowLayer.position = CGPointMake(
+      CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
+  CGPathRef path = SmoothClipCreateShadowPath(geometry, effectiveShadow);
+  shadowLayer.shadowPath = path;
+  CGPathRelease(path);
+  shadowLayer.shadowColor = [self colorForShadow:effectiveShadow];
+  shadowLayer.shadowOpacity = visible ? 1 : 0;
+  shadowLayer.shadowRadius = MAX(0, effectiveShadow.blurRadius) / 2.0;
+  shadowLayer.shadowOffset = CGSizeMake(
+      effectiveShadow.offsetX, effectiveShadow.offsetY);
 }
 
-- (BOOL)normalizedRequestedGeometry:(SmoothNormalizedClipGeometry *)geometry {
+- (void)writeShadow:(const smoothclip::Shadow &)shadow
+            geometry:(SmoothClipCanonicalGeometry)geometry {
+  _canonicalShadow = shadow;
+  [self writeShadowModel:shadow geometry:geometry];
+}
+
+- (BOOL)canonicalRequestedGeometry:(SmoothClipCanonicalGeometry *)geometry {
   if (!_hasLayout) return NO;
 #if defined(SMOOTH_CLIP_ENABLE_SIGNPOSTS) && SMOOTH_CLIP_ENABLE_SIGNPOSTS
   const bool signpostsEnabled =
@@ -375,11 +564,10 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   if (signpostsEnabled) {
     identifier = os_signpost_id_generate([SmoothClipView signpostLog]);
     os_signpost_interval_begin(
-        [SmoothClipView signpostLog], identifier, "normalization");
+        [SmoothClipView signpostLog], identifier, "canonicalization");
   }
 #endif
-  const CGSize hostSize = self.bounds.size;
-  const BOOL valid = SmoothClipNormalizeGeometryV2(
+  const BOOL valid = SmoothClipCanonicalizeGeometry(
       CGRectGetMinX(_requestedClip),
       CGRectGetMinY(_requestedClip),
       CGRectGetWidth(_requestedClip),
@@ -389,12 +577,11 @@ static std::array<double, 11> SmoothClipVelocityChannels(
       _requestedRadii.bottomRight,
       _requestedRadii.bottomLeft,
       _requestedCurve,
-      CGSizeMake(MAX(0, hostSize.width), MAX(0, hostSize.height)),
       geometry);
 #if defined(SMOOTH_CLIP_ENABLE_SIGNPOSTS) && SMOOTH_CLIP_ENABLE_SIGNPOSTS
   if (signpostsEnabled) {
     os_signpost_interval_end(
-        [SmoothClipView signpostLog], identifier, "normalization");
+        [SmoothClipView signpostLog], identifier, "canonicalization");
   }
 #endif
   return valid;
@@ -409,15 +596,15 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 
 - (void)syncVisibilityForRect:(CGRect)rect {
   [self setClipContainerHidden:CGRectIsEmpty(rect)];
+  _clipContainer.accessibilityElementsHidden =
+      !SmoothClipRectIntersectsHost(rect, self.bounds);
 }
 
 - (void)configureUnequalCornerMaskForGeometry:
-    (SmoothNormalizedClipGeometry)geometry {
-  const CGSize hostSize = self.bounds.size;
-  _unequalCornerMask.bounds = CGRectMake(
-      0, 0, MAX(0, hostSize.width), MAX(0, hostSize.height));
+    (SmoothClipCanonicalGeometry)geometry {
+  _unequalCornerMask.bounds = geometry.rect;
   _unequalCornerMask.position = CGPointMake(
-      MAX(0, hostSize.width) / 2, MAX(0, hostSize.height) / 2);
+      CGRectGetMidX(geometry.rect), CGRectGetMidY(geometry.rect));
   CGPathRef path = SmoothClipCreateRoundedRectPath(
       geometry.rect, geometry.radii, geometry.curve);
   _unequalCornerMask.path = path;
@@ -425,7 +612,7 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 }
 
 - (void)applyStaticCornerRepresentation:
-    (SmoothNormalizedClipGeometry)geometry {
+    (SmoothClipCanonicalGeometry)geometry {
   CALayer *layer = _clipContainer.layer;
   if (SmoothClipCornerRadiiAreUniform(geometry.radii)) {
     layer.mask = nil;
@@ -439,29 +626,29 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   }
 }
 
-- (SmoothNormalizedClipGeometry)normalizedGeometryValue {
+- (SmoothClipCanonicalGeometry)canonicalGeometryValue {
   return {
-      .rect = _normalizedClip,
-      .radius = _normalizedRadius,
-      .radii = _normalizedRadii,
-      .curve = _normalizedCurve,
+      .rect = _canonicalClip,
+      .radius = _canonicalRadius,
+      .radii = _canonicalRadii,
+      .curve = _canonicalCurve,
   };
 }
 
-- (void)writeLayerGeometry:(SmoothNormalizedClipGeometry)geometry
+- (void)writeLayerGeometry:(SmoothClipCanonicalGeometry)geometry
          hasExplicitRadii:(BOOL)hasExplicitRadii {
   const BOOL rectChanged =
-      !CGRectEqualToRect(_normalizedClip, geometry.rect);
+      !CGRectEqualToRect(_canonicalClip, geometry.rect);
   const BOOL radiiChanged =
-      !SmoothClipCornerRadiiEqual(_normalizedRadii, geometry.radii);
-  const BOOL curveChanged = _normalizedCurve != geometry.curve;
+      !SmoothClipCornerRadiiEqual(_canonicalRadii, geometry.radii);
+  const BOOL curveChanged = _canonicalCurve != geometry.curve;
   const BOOL representationChanged =
-      _normalizedHasExplicitRadii != hasExplicitRadii;
-  _normalizedClip = geometry.rect;
-  _normalizedRadius = geometry.radius;
-  _normalizedRadii = geometry.radii;
-  _normalizedCurve = geometry.curve;
-  _normalizedHasExplicitRadii = hasExplicitRadii;
+      _canonicalHasExplicitRadii != hasExplicitRadii;
+  _canonicalClip = geometry.rect;
+  _canonicalRadius = geometry.radius;
+  _canonicalRadii = geometry.radii;
+  _canonicalCurve = geometry.curve;
+  _canonicalHasExplicitRadii = hasExplicitRadii;
   if (!rectChanged && !radiiChanged && !curveChanged &&
       !representationChanged) {
     return;
@@ -496,28 +683,33 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 
 - (void)writeContentTranslation:(CGPoint)translation
                            scale:(CGFloat)scale {
-  if (CGPointEqualToPoint(_normalizedContentTranslation, translation) &&
-      _normalizedContentScale == scale) {
+  if (CGPointEqualToPoint(_canonicalContentTranslation, translation) &&
+      _canonicalContentScale == scale) {
     return;
   }
-  _normalizedContentTranslation = translation;
-  _normalizedContentScale = scale;
+  _canonicalContentTranslation = translation;
+  _canonicalContentScale = scale;
   _contentContainer.layer.affineTransform =
       SmoothClipContentTransform(scale, translation);
 }
 
 - (void)applyRequestedClip {
-  SmoothNormalizedClipGeometry geometry;
-  if (![self normalizedRequestedGeometry:&geometry]) return;
-
-  const BOOL visibilityChanged = _clipHidden != CGRectIsEmpty(geometry.rect);
-  if (CGRectEqualToRect(_normalizedClip, geometry.rect) &&
-      SmoothClipCornerRadiiEqual(_normalizedRadii, geometry.radii) &&
-      _normalizedCurve == geometry.curve &&
-      _normalizedHasExplicitRadii == _requestedHasExplicitRadii &&
+  SmoothClipCanonicalGeometry geometry;
+  if (![self canonicalRequestedGeometry:&geometry]) return;
+
+  const BOOL accessibilityHidden =
+      !SmoothClipRectIntersectsHost(geometry.rect, self.bounds);
+  const BOOL visibilityChanged =
+      _clipHidden != CGRectIsEmpty(geometry.rect) ||
+      _clipContainer.accessibilityElementsHidden != accessibilityHidden;
+  if (CGRectEqualToRect(_canonicalClip, geometry.rect) &&
+      SmoothClipCornerRadiiEqual(_canonicalRadii, geometry.radii) &&
+      _canonicalCurve == geometry.curve &&
+      _canonicalHasExplicitRadii == _requestedHasExplicitRadii &&
       CGPointEqualToPoint(
-          _normalizedContentTranslation, _requestedContentTranslation) &&
-      _normalizedContentScale == _requestedContentScale &&
+          _canonicalContentTranslation, _requestedContentTranslation) &&
+      _canonicalContentScale == _requestedContentScale &&
+      SmoothBoxShadowEqual(_canonicalShadow, _requestedShadow) &&
       !visibilityChanged) {
     return;
   }
@@ -525,6 +717,7 @@ static std::array<double, 11> SmoothClipVelocityChannels(
          hasExplicitRadii:_requestedHasExplicitRadii];
   [self writeContentTranslation:_requestedContentTranslation
                            scale:_requestedContentScale];
+  [self writeShadow:_requestedShadow geometry:geometry];
   [self syncVisibilityForRect:geometry.rect];
 }
 
@@ -545,17 +738,44 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 
 - (CGFloat)inheritedVelocityToRect:(CGRect)target
                              radii:(SmoothClipCornerRadii)targetRadii
-                contentTranslation:(CGPoint)targetContentTranslation {
+                contentTranslation:(CGPoint)targetContentTranslation
+                      contentScale:(CGFloat)targetContentScale {
   return smoothclip::inheritedVelocity(
       _velocitySamples,
       SmoothClipVelocityChannels(
           target,
           targetRadii,
           targetContentTranslation,
-          _requestedContentScale),
+          targetContentScale),
       CACurrentMediaTime());
 }
 
+- (double)smoothClipInheritedVelocityToPresentation:
+    (smoothclip::Presentation)presentation {
+  SmoothClipCanonicalGeometry target;
+  const SmoothClipCornerRadii radii =
+      SmoothClipPresentationRadii(presentation.clip);
+  if (!SmoothClipCanonicalizeGeometry(
+          presentation.clip.x,
+          presentation.clip.y,
+          presentation.clip.width,
+          presentation.clip.height,
+          radii.topLeft,
+          radii.topRight,
+          radii.bottomRight,
+          radii.bottomLeft,
+          SmoothClipPresentationCurve(presentation.clip),
+          &target)) {
+    return 0;
+  }
+  return [self inheritedVelocityToRect:target.rect
+                                 radii:target.radii
+                    contentTranslation:CGPointMake(
+                        presentation.contentTranslateX,
+                        presentation.contentTranslateY)
+                          contentScale:presentation.contentScale];
+}
+
 - (void)smoothClipApplyPresentation:(smoothclip::Presentation)presentation {
   [self smoothClipApplyPresentation:presentation recordVelocitySample:YES];
 }
@@ -565,21 +785,21 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   [self stopLayerAnimationWithoutCallback];
   [self storeRequestedPresentation:presentation];
   [self applyRequestedClip];
-  // Skipped for writes that are not interactive motion (a latched
+  // Skipped for writes that are not interactive motion (a pending-run
   // cancel-to-target): they must not enter the 'inherit' history.
   if (recordVelocitySample && _hasLayout) {
-    [self recordInteractiveRect:_normalizedClip
-                          radii:_normalizedRadii
-             contentTranslation:_normalizedContentTranslation
-                   contentScale:_normalizedContentScale];
+    [self recordInteractiveRect:_canonicalClip
+                          radii:_canonicalRadii
+             contentTranslation:_canonicalContentTranslation
+                   contentScale:_canonicalContentScale];
   }
 }
 
 - (smoothclip::Presentation)smoothClipCurrentPresentation {
-  SmoothClipCornerRadii visibleRadii = _normalizedRadii;
+  SmoothClipCornerRadii visibleRadii = _canonicalRadii;
   const CGRect visibleRect = _activeAnimationId != 0
       ? [self presentationRectWithRadii:&visibleRadii]
-      : _normalizedClip;
+      : _canonicalClip;
   CALayer *contentLayer = _activeAnimationId != 0
       ? (CALayer *)_contentContainer.layer.presentationLayer
       : _contentContainer.layer;
@@ -592,17 +812,45 @@ static std::array<double, 11> SmoothClipVelocityChannels(
       CGRectGetWidth(visibleRect),
       CGRectGetHeight(visibleRect),
       uniform ? visibleRadii.topLeft : 0};
-  if (_normalizedHasExplicitRadii || !uniform) {
+  if (_canonicalHasExplicitRadii || !uniform) {
     geometry.topLeftRadius = visibleRadii.topLeft;
     geometry.topRightRadius = visibleRadii.topRight;
     geometry.bottomRightRadius = visibleRadii.bottomRight;
     geometry.bottomLeftRadius = visibleRadii.bottomLeft;
   }
-  geometry.curve = _normalizedCurve == SmoothClipCornerCurveContinuous
+  geometry.curve = _canonicalCurve == SmoothClipCornerCurveContinuous
       ? smoothclip::ClipCurve::Continuous
       : smoothclip::ClipCurve::Circular;
   const CGFloat contentScale = hypot(transform.a, transform.b);
-  return {geometry, transform.tx, transform.ty, contentScale};
+  smoothclip::Shadow shadow = _canonicalShadow;
+  CALayer *shadowLayer = _activeAnimationId != 0 && _shadowLayer != nil
+      ? (CALayer *)_shadowLayer.presentationLayer
+      : _shadowLayer;
+  if (shadowLayer == nil) return SmoothClipCanonicalSnapshot({
+      geometry, transform.tx, transform.ty, contentScale, shadow});
+  shadow.enabled = _canonicalShadow.enabled || shadowLayer.shadowOpacity > 0;
+  shadow.blurRadius = shadowLayer.shadowRadius * 2.0;
+  shadow.offsetX = shadowLayer.shadowOffset.width;
+  shadow.offsetY = shadowLayer.shadowOffset.height;
+  CGColorRef color = shadowLayer.shadowColor;
+  if (color != nil) {
+    UIColor *uiColor = [UIColor colorWithCGColor:color];
+    CGFloat red = 0, green = 0, blue = 0, alpha = 0;
+    if ([uiColor getRed:&red green:&green blue:&blue alpha:&alpha]) {
+      shadow.red = red;
+      shadow.green = green;
+      shadow.blue = blue;
+      shadow.alpha = alpha;
+    }
+  }
+  CGPathRef shadowPath = shadowLayer.shadowPath;
+  if (shadowPath != nil && !CGRectIsEmpty(visibleRect)) {
+    const CGRect shadowBounds = CGPathGetBoundingBox(shadowPath);
+    shadow.spreadDistance =
+        CGRectGetMinX(visibleRect) - CGRectGetMinX(shadowBounds);
+  }
+  return SmoothClipCanonicalSnapshot(
+      {geometry, transform.tx, transform.ty, contentScale, shadow});
 }
 
 - (BOOL)smoothClipIsJoinable {
@@ -615,28 +863,15 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 - (BOOL)smoothClipCanDisplay {
   // A CA animation committed while this view's layer tree is detached from
   // the render tree does not survive the later attach commit; installs and
-  // latch starts must wait until a frame can actually be produced.
+  // pre-ready runs must wait until a frame can actually be produced.
   return [self smoothClipIsJoinable] && self.window != nil &&
       smoothclip::applicationIsActive();
 }
 
-- (BOOL)smoothClipHasPendingInstall {
-  return _pendingAnimationInstall;
-}
-
 - (void)smoothClipClearVelocitySamples {
   smoothclip::clearVelocitySamples(_velocitySamples);
 }
 
-- (double)smoothClipSpringContinuationVelocity {
-  if (_activeAnimationId == 0 || _activeAnimationKind != 2 ||
-      _pendingAnimationInstall) {
-    return 0;
-  }
-  const double elapsed = MAX(0, CACurrentMediaTime() - _animationStartedAt);
-  return smoothclip::springContinuationVelocity(_springAnimation, elapsed);
-}
-
 - (smoothclip::Presentation)smoothClipFreezePresentation {
   const smoothclip::Presentation visible =
       [self smoothClipCurrentPresentation];
@@ -662,7 +897,7 @@ static std::array<double, 11> SmoothClipVelocityChannels(
           (CAShapeLayer *)_unequalCornerMask.presentationLayer;
       if (mask == nil) mask = _unequalCornerMask;
       *radii = SmoothClipRadiiFromFixedPath(
-          mask.path, rect, _normalizedRadii);
+          mask.path, rect, _canonicalRadii);
     } else {
       *radii = {
           layer.cornerRadius,
@@ -676,7 +911,6 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 }
 
 - (void)stopLayerAnimationWithoutCallback {
-  _pendingAnimationInstall = NO;
   if (_activeAnimationId == 0) return;
   // Invalidate before removing: CA may deliver didStop for the removed
   // animation after this method returns, when _ignoreAnimationCallback has
@@ -687,7 +921,8 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   [_clipContainer.layer removeAnimationForKey:@"smoothClip.geometry"];
   [_contentContainer.layer removeAnimationForKey:@"smoothClip.content"];
   [_unequalCornerMask removeAnimationForKey:@"smoothClip.mask"];
-  [self applyStaticCornerRepresentation:[self normalizedGeometryValue]];
+  [_shadowLayer removeAnimationForKey:@"smoothClip.shadow"];
+  [self applyStaticCornerRepresentation:[self canonicalGeometryValue]];
   _ignoreAnimationCallback = NO;
   _activeAnimationId = 0;
   _activeAnimationKind = 0;
@@ -706,15 +941,19 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 }
 
 - (CFTimeInterval)springSettlingDurationWithVelocity:(double)velocity {
-  // Every key path in the group shares mass/stiffness/damping and the same
-  // normalized initialVelocity, so one settling solve covers all of them.
-  CASpringAnimation *probe =
-      [CASpringAnimation animationWithKeyPath:@"bounds.origin.x"];
-  probe.mass = _springAnimation.mass;
-  probe.stiffness = _springAnimation.stiffness;
-  probe.damping = _springAnimation.damping;
-  probe.initialVelocity = velocity;
-  return probe.settlingDuration;
+  // Every key path shares one normalized trajectory. Derive the terminal
+  // duration from the same relative-energy rule as Android/Reanimated instead
+  // of asking each Core Animation property for an independent settle time.
+  smoothclip::ScalarSpringState state{0, velocity};
+  constexpr double step = 1.0 / 120.0;
+  double elapsed = 0;
+  while (elapsed < 10.0 &&
+         smoothclip::relativeSpringEnergy(state, _springAnimation) >
+             _springAnimation.energyThreshold) {
+    state = smoothclip::advanceScalarSpring(state, _springAnimation, step);
+    elapsed += step;
+  }
+  return elapsed;
 }
 
 - (CASpringAnimation *)springAnimationForKeyPath:(NSString *)keyPath
@@ -735,14 +974,16 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 }
 
 - (void)installAnimationFromGeometry:
-            (SmoothNormalizedClipGeometry)fromGeometry
+            (SmoothClipCanonicalGeometry)fromGeometry
                    fromContentTranslation:(CGPoint)fromContentTranslation
                          fromContentScale:(CGFloat)fromContentScale
+                              fromShadow:(smoothclip::Shadow)fromShadow
                                toGeometry:
-            (SmoothNormalizedClipGeometry)toGeometry
+            (SmoothClipCanonicalGeometry)toGeometry
                      hasExplicitToRadii:(BOOL)hasExplicitToRadii
                      toContentTranslation:(CGPoint)toContentTranslation
                            toContentScale:(CGFloat)toContentScale
+                                toShadow:(smoothclip::Shadow)toShadow
                                  duration:(CFTimeInterval)duration
                             sharedBeginTime:(CFTimeInterval)sharedBeginTime {
   const int32_t animationId = _activeAnimationId;
@@ -756,6 +997,9 @@ static std::array<double, 11> SmoothClipVelocityChannels(
       !CGRectIsEmpty(fromGeometry.rect)) {
     [self setClipContainerHidden:NO];
   }
+  // Autonomous native motion has no per-frame accessibility layout updates.
+  // Hide moving descendants until the endpoint is committed.
+  _clipContainer.accessibilityElementsHidden = YES;
 
   CALayer *layer = _clipContainer.layer;
   const CGRect toBounds = toGeometry.rect;
@@ -774,6 +1018,14 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   [self writeLayerGeometry:toGeometry
          hasExplicitRadii:hasExplicitToRadii];
   [self writeContentTranslation:toContentTranslation scale:toContentScale];
+  _canonicalShadow = toShadow;
+  SmoothBoxShadowNormalizeAnimationEndpoints(
+      fromGeometry, &fromShadow, toGeometry, &toShadow);
+  // The target model layer is complete before any presentation animations are
+  // attached. Core Animation may remove the terminal presentation animation
+  // before its delegate runs, so correctness cannot depend on completion-time
+  // cleanup hiding a stale path or opaque color.
+  [self writeShadowModel:toShadow geometry:toGeometry];
   if (usesMask) {
     // Keep one mask representation for the full interval, including an
     // unequal→uniform transition. Switching layer.mask mid-animation would
@@ -791,10 +1043,41 @@ static std::array<double, 11> SmoothClipVelocityChannels(
       ? SmoothClipCreateRoundedRectPath(
             toGeometry.rect, toGeometry.radii, toGeometry.curve)
       : nil;
-
+  const BOOL fromShadowVisible =
+      SmoothBoxShadowVisible(fromGeometry, fromShadow);
+  const BOOL toShadowVisible =
+      SmoothBoxShadowVisible(toGeometry, toShadow);
+  const BOOL hasVisibleShadow = fromShadowVisible || toShadowVisible;
+  const BOOL animatesShadowPath = hasVisibleShadow &&
+      !SmoothBoxShadowPathInputEqual(
+          fromGeometry, fromShadow, toGeometry, toShadow);
+  const BOOL animatesShadowColor = hasVisibleShadow &&
+      !SmoothBoxShadowColorEqual(fromShadow, toShadow);
+  const BOOL animatesShadowRadius = hasVisibleShadow &&
+      fromShadow.blurRadius != toShadow.blurRadius;
+  const BOOL animatesShadowOffset = hasVisibleShadow &&
+      (fromShadow.offsetX != toShadow.offsetX ||
+       fromShadow.offsetY != toShadow.offsetY);
+  const BOOL animatesShadow = animatesShadowPath || animatesShadowColor ||
+      animatesShadowRadius || animatesShadowOffset;
+  if (hasVisibleShadow) {
+    [self ensureShadowLayer];
+    // Reveal opacity is encoded in shadowColor alpha. Animating layer opacity
+    // too would multiply both curves and produce a quadratic-looking fade.
+    _shadowLayer.shadowOpacity = 1;
+  }
+  CGPathRef fromShadowPath = animatesShadowPath
+      ? SmoothClipCreateShadowPath(fromGeometry, fromShadow)
+      : nil;
+  CGPathRef toShadowPath = animatesShadowPath
+      ? SmoothClipCreateShadowPath(toGeometry, toShadow)
+      : nil;
   CAAnimationGroup *group = [CAAnimationGroup animation];
   CAAnimationGroup *contentGroup = [CAAnimationGroup animation];
-  CAAnimation *maskAnimation = nil;
+  CAAnimationGroup *shadowGroup = animatesShadow
+      ? [CAAnimationGroup animation]
+      : nil;
+  CAAnimationGroup *maskAnimation = nil;
   if (_activeAnimationKind == 1) {
     CAMediaTimingFunction *timing = [CAMediaTimingFunction
         functionWithControlPoints:_timingAnimation.controlPoint1X
@@ -812,10 +1095,21 @@ static std::array<double, 11> SmoothClipVelocityChannels(
                       timingFunction:timing],
     ]];
     if (usesMask) {
-      maskAnimation = [self basicAnimationForKeyPath:@"path"
-                                           fromValue:(__bridge id)fromMaskPath
-                                             toValue:(__bridge id)toMaskPath
-                                      timingFunction:timing];
+      maskAnimation = [CAAnimationGroup animation];
+      maskAnimation.animations = @[
+        [self basicAnimationForKeyPath:@"path"
+                             fromValue:(__bridge id)fromMaskPath
+                               toValue:(__bridge id)toMaskPath
+                        timingFunction:timing],
+        [self basicAnimationForKeyPath:@"bounds"
+                             fromValue:[NSValue valueWithCGRect:fromGeometry.rect]
+                               toValue:[NSValue valueWithCGRect:toGeometry.rect]
+                        timingFunction:timing],
+        [self basicAnimationForKeyPath:@"position"
+                             fromValue:[NSValue valueWithCGPoint:fromPosition]
+                               toValue:[NSValue valueWithCGPoint:toPosition]
+                        timingFunction:timing],
+      ];
     } else {
       [geometryAnimations addObject:
           [self basicAnimationForKeyPath:@"cornerRadius"
@@ -844,6 +1138,33 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     }
     contentGroup.animations = contentAnimations;
     contentGroup.duration = duration;
+    if (animatesShadow) {
+      NSMutableArray<CAAnimation *> *shadowAnimations = [NSMutableArray array];
+      if (animatesShadowPath) [shadowAnimations addObject:
+          [self basicAnimationForKeyPath:@"shadowPath"
+                           fromValue:(__bridge id)fromShadowPath
+                             toValue:(__bridge id)toShadowPath
+                      timingFunction:timing]];
+      if (animatesShadowColor) [shadowAnimations addObject:
+          [self basicAnimationForKeyPath:@"shadowColor"
+                           fromValue:(__bridge id)[self colorForShadow:fromShadow]
+                             toValue:(__bridge id)[self colorForShadow:toShadow]
+                      timingFunction:timing]];
+      if (animatesShadowRadius) [shadowAnimations addObject:
+          [self basicAnimationForKeyPath:@"shadowRadius"
+                           fromValue:@(MAX(0, fromShadow.blurRadius) / 2.0)
+                             toValue:@(MAX(0, toShadow.blurRadius) / 2.0)
+                      timingFunction:timing]];
+      if (animatesShadowOffset) [shadowAnimations addObject:
+          [self basicAnimationForKeyPath:@"shadowOffset"
+                           fromValue:[NSValue valueWithCGSize:CGSizeMake(
+                               fromShadow.offsetX, fromShadow.offsetY)]
+                             toValue:[NSValue valueWithCGSize:CGSizeMake(
+                               toShadow.offsetX, toShadow.offsetY)]
+                      timingFunction:timing]];
+      shadowGroup.animations = shadowAnimations;
+      shadowGroup.duration = duration;
+    }
   } else {
     // `_springAnimation.initialVelocity` is the interactive motion projected
     // onto the current-to-target trajectory, normalized by that distance
@@ -888,11 +1209,44 @@ static std::array<double, 11> SmoothClipVelocityChannels(
                              duration:springDuration],
     ]];
     if (usesMask) {
-      maskAnimation = [self springAnimationForKeyPath:@"path"
-                                            fromValue:(__bridge id)fromMaskPath
-                                              toValue:(__bridge id)toMaskPath
-                                             velocity:velocity
-                                             duration:springDuration];
+      maskAnimation = [CAAnimationGroup animation];
+      maskAnimation.animations = @[
+        [self springAnimationForKeyPath:@"path"
+                              fromValue:(__bridge id)fromMaskPath
+                                toValue:(__bridge id)toMaskPath
+                               velocity:velocity
+                               duration:springDuration],
+        [self springAnimationForKeyPath:@"bounds.origin.x"
+                              fromValue:@(fromGeometry.rect.origin.x)
+                                toValue:@(toGeometry.rect.origin.x)
+                               velocity:velocity
+                               duration:springDuration],
+        [self springAnimationForKeyPath:@"bounds.origin.y"
+                              fromValue:@(fromGeometry.rect.origin.y)
+                                toValue:@(toGeometry.rect.origin.y)
+                               velocity:velocity
+                               duration:springDuration],
+        [self springAnimationForKeyPath:@"bounds.size.width"
+                              fromValue:@(fromGeometry.rect.size.width)
+                                toValue:@(toGeometry.rect.size.width)
+                               velocity:velocity
+                               duration:springDuration],
+        [self springAnimationForKeyPath:@"bounds.size.height"
+                              fromValue:@(fromGeometry.rect.size.height)
+                                toValue:@(toGeometry.rect.size.height)
+                               velocity:velocity
+                               duration:springDuration],
+        [self springAnimationForKeyPath:@"position.x"
+                              fromValue:@(fromPosition.x)
+                                toValue:@(toPosition.x)
+                               velocity:velocity
+                               duration:springDuration],
+        [self springAnimationForKeyPath:@"position.y"
+                              fromValue:@(fromPosition.y)
+                                toValue:@(toPosition.y)
+                               velocity:velocity
+                               duration:springDuration],
+      ];
     } else {
       [geometryAnimations addObject:
           [self springAnimationForKeyPath:@"cornerRadius"
@@ -902,9 +1256,8 @@ static std::array<double, 11> SmoothClipVelocityChannels(
                                  duration:springDuration]];
     }
     group.animations = geometryAnimations;
-    // A rebuilt spring (layout change, foreground resume) must run its own
-    // settling time; clamping to the interrupted run's remaining wall-clock
-    // time would truncate the oscillation and snap to the target.
+    // Springs use their analytic settling time; a wall-clock duration would
+    // truncate oscillation and snap to the target.
     group.duration = springDuration;
     NSMutableArray<CAAnimation *> *contentAnimations = [NSMutableArray arrayWithArray:@[
       [self springAnimationForKeyPath:@"transform.translation.x"
@@ -928,6 +1281,37 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     }
     contentGroup.animations = contentAnimations;
     contentGroup.duration = springDuration;
+    if (animatesShadow) {
+      NSMutableArray<CAAnimation *> *shadowAnimations = [NSMutableArray array];
+      if (animatesShadowPath) [shadowAnimations addObject:
+          [self springAnimationForKeyPath:@"shadowPath"
+                            fromValue:(__bridge id)fromShadowPath
+                              toValue:(__bridge id)toShadowPath
+                             velocity:velocity
+                             duration:springDuration]];
+      if (animatesShadowColor) [shadowAnimations addObject:
+          [self springAnimationForKeyPath:@"shadowColor"
+                            fromValue:(__bridge id)[self colorForShadow:fromShadow]
+                              toValue:(__bridge id)[self colorForShadow:toShadow]
+                             velocity:velocity
+                             duration:springDuration]];
+      if (animatesShadowRadius) [shadowAnimations addObject:
+          [self springAnimationForKeyPath:@"shadowRadius"
+                            fromValue:@(MAX(0, fromShadow.blurRadius) / 2.0)
+                              toValue:@(MAX(0, toShadow.blurRadius) / 2.0)
+                             velocity:velocity
+                             duration:springDuration]];
+      if (animatesShadowOffset) [shadowAnimations addObject:
+          [self springAnimationForKeyPath:@"shadowOffset"
+                            fromValue:[NSValue valueWithCGSize:CGSizeMake(
+                                fromShadow.offsetX, fromShadow.offsetY)]
+                              toValue:[NSValue valueWithCGSize:CGSizeMake(
+                                toShadow.offsetX, toShadow.offsetY)]
+                             velocity:velocity
+                             duration:springDuration]];
+      shadowGroup.animations = shadowAnimations;
+      shadowGroup.duration = springDuration;
+    }
   }
 
   if (maskAnimation != nil) {
@@ -942,6 +1326,11 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     contentGroup.beginTime = [_contentContainer.layer
         convertTime:sharedBeginTime
         fromLayer:nil];
+    if (animatesShadow) {
+      shadowGroup.beginTime = [_shadowLayer
+          convertTime:sharedBeginTime
+          fromLayer:nil];
+    }
     if (maskAnimation != nil) {
       maskAnimation.beginTime = [_unequalCornerMask
           convertTime:sharedBeginTime
@@ -949,10 +1338,6 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     }
   }
 
-  _animationDuration = group.duration;
-  _animationStartedAt = sharedBeginTime > 0
-      ? sharedBeginTime
-      : CACurrentMediaTime();
   _animationDelegate = [SmoothClipAnimationDelegate new];
   _animationDelegate.view = self;
   _animationDelegate.driverId = _driverId;
@@ -961,27 +1346,30 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   [layer addAnimation:group forKey:@"smoothClip.geometry"];
   [_contentContainer.layer addAnimation:contentGroup
                                  forKey:@"smoothClip.content"];
+  if (animatesShadow) {
+    [_shadowLayer addAnimation:shadowGroup forKey:@"smoothClip.shadow"];
+  }
   if (maskAnimation != nil) {
     [_unequalCornerMask addAnimation:maskAnimation forKey:@"smoothClip.mask"];
   }
   if (fromMaskPath != nil) CGPathRelease(fromMaskPath);
   if (toMaskPath != nil) CGPathRelease(toMaskPath);
-  _animationInstallGeneration += 1;
+  if (fromShadowPath != nil) CGPathRelease(fromShadowPath);
+  if (toShadowPath != nil) CGPathRelease(toShadowPath);
 }
 
 - (BOOL)startAnimationToRequestedGeometryWithDuration:(CFTimeInterval)duration
                                        sharedBeginTime:
                                            (CFTimeInterval)sharedBeginTime {
   if (![self smoothClipCanDisplay]) {
-    _pendingAnimationInstall = YES;
     return NO;
   }
-  SmoothNormalizedClipGeometry target;
-  if (![self normalizedRequestedGeometry:&target]) return NO;
+  SmoothClipCanonicalGeometry target;
+  if (![self canonicalRequestedGeometry:&target]) return NO;
   const smoothclip::Presentation current = [self smoothClipCurrentPresentation];
   const SmoothClipCornerRadii currentRadii =
       SmoothClipPresentationRadii(current.clip);
-  const SmoothNormalizedClipGeometry fromGeometry = {
+  const SmoothClipCanonicalGeometry fromGeometry = {
       .rect = CGRectMake(
           current.clip.x,
           current.clip.y,
@@ -998,10 +1386,12 @@ static std::array<double, 11> SmoothClipVelocityChannels(
                                          current.contentTranslateX,
                                          current.contentTranslateY)
                     fromContentScale:current.contentScale
+                         fromShadow:current.shadow
                           toGeometry:target
                 hasExplicitToRadii:_requestedHasExplicitRadii
                 toContentTranslation:_requestedContentTranslation
                       toContentScale:_requestedContentScale
+                           toShadow:_requestedShadow
                             duration:duration
                      sharedBeginTime:sharedBeginTime];
   return YES;
@@ -1045,12 +1435,13 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   [self storeRequestedPresentation:presentation];
   _springAnimation = animation;
   if (animation.inheritVelocity) {
-    SmoothNormalizedClipGeometry target;
-    if ([self normalizedRequestedGeometry:&target]) {
+    SmoothClipCanonicalGeometry target;
+    if ([self canonicalRequestedGeometry:&target]) {
       _springAnimation.initialVelocity =
           [self inheritedVelocityToRect:target.rect
                                    radii:target.radii
-                      contentTranslation:_requestedContentTranslation];
+                      contentTranslation:_requestedContentTranslation
+                            contentScale:_requestedContentScale];
     } else {
       _springAnimation.initialVelocity = 0;
     }
@@ -1061,201 +1452,6 @@ static std::array<double, 11> SmoothClipVelocityChannels(
                                               sharedBeginTime:sharedBeginTime];
 }
 
-- (CAKeyframeAnimation *)keyframeAnimationForKeyPath:(NSString *)keyPath
-                                               values:(NSArray *)values
-                                             keyTimes:(NSArray<NSNumber *> *)keyTimes {
-  CAKeyframeAnimation *animation =
-      [CAKeyframeAnimation animationWithKeyPath:keyPath];
-  animation.values = values;
-  animation.keyTimes = keyTimes;
-  animation.calculationMode = kCAAnimationLinear;
-  return animation;
-}
-
-- (BOOL)smoothClipAnimateKeyframes:(smoothclip::Presentation)presentation
-                          keyframes:(const std::vector<smoothclip::Keyframe> &)keyframes
-                          durationMs:(double)durationMs
-                         animationId:(int32_t)animationId {
-  return [self smoothClipAnimateKeyframes:presentation
-                                keyframes:keyframes
-                               durationMs:durationMs
-                              animationId:animationId
-                          sharedBeginTime:0];
-}
-
-- (BOOL)smoothClipAnimateKeyframes:(smoothclip::Presentation)presentation
-                          keyframes:(const std::vector<smoothclip::Keyframe> &)keyframes
-                          durationMs:(double)durationMs
-                         animationId:(int32_t)animationId
-                     sharedBeginTime:(CFTimeInterval)sharedBeginTime {
-  if (keyframes.size() < 2) return NO;
-  [self storeRequestedPresentation:presentation];
-  _activeAnimationKind = 3;
-  _activeAnimationId = animationId;
-  if (![self smoothClipCanDisplay]) {
-    _pendingAnimationInstall = YES;
-    return NO;
-  }
-  [self stopLayerAnimationWithoutCallback];
-  _activeAnimationKind = 3;
-  _activeAnimationId = animationId;
-
-  const NSUInteger frameCount = keyframes.size();
-  const CGSize hostSize = self.bounds.size;
-  NSMutableArray<NSNumber *> *times =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *boundsValues = [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *positionValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *radiusValues = [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *maskPathValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *translateXValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *translateYValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *scaleValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  BOOL usesMask = NO;
-  BOOL animatesScale = NO;
-  SmoothClipCornerCurve firstCurve = SmoothClipCornerCurveCircular;
-  BOOL hasFirstCurve = NO;
-  std::vector<SmoothNormalizedClipGeometry> normalizedFrames;
-  normalizedFrames.reserve(frameCount);
-  for (const smoothclip::Keyframe &frame : keyframes) {
-    const SmoothClipCornerRadii frameRadii =
-        SmoothClipPresentationRadii(frame.presentation.clip);
-    const SmoothClipCornerCurve frameCurve =
-        SmoothClipPresentationCurve(frame.presentation.clip);
-    SmoothNormalizedClipGeometry normalized;
-    if (!SmoothClipNormalizeGeometryV2(
-            frame.presentation.clip.x,
-            frame.presentation.clip.y,
-            frame.presentation.clip.width,
-            frame.presentation.clip.height,
-            frameRadii.topLeft,
-            frameRadii.topRight,
-            frameRadii.bottomRight,
-            frameRadii.bottomLeft,
-            frameCurve,
-            hostSize,
-            &normalized)) return NO;
-    normalizedFrames.push_back(normalized);
-    if (!SmoothClipCornerRadiiAreUniform(normalized.radii)) usesMask = YES;
-    if (!hasFirstCurve) {
-      firstCurve = normalized.curve;
-      hasFirstCurve = YES;
-    } else if (normalized.curve != firstCurve) {
-      usesMask = YES;
-    }
-    if (frame.presentation.contentScale != 1) animatesScale = YES;
-    [times addObject:@(frame.offset)];
-    [boundsValues addObject:[NSValue valueWithCGRect:normalized.rect]];
-    [positionValues addObject:[NSValue valueWithCGPoint:CGPointMake(
-        CGRectGetMidX(normalized.rect), CGRectGetMidY(normalized.rect))]];
-    [radiusValues addObject:@(normalized.radius)];
-    [translateXValues addObject:@(frame.presentation.contentTranslateX)];
-    [translateYValues addObject:@(frame.presentation.contentTranslateY)];
-    [scaleValues addObject:@(frame.presentation.contentScale)];
-  }
-
-  if (usesMask) {
-    for (const SmoothNormalizedClipGeometry &normalized : normalizedFrames) {
-      CGPathRef path = SmoothClipCreateRoundedRectPath(
-          normalized.rect, normalized.radii, normalized.curve);
-      [maskPathValues addObject:(__bridge id)path];
-      CGPathRelease(path);
-    }
-  }
-
-  SmoothNormalizedClipGeometry target;
-  if (![self normalizedRequestedGeometry:&target]) return NO;
-  [self writeLayerGeometry:target
-         hasExplicitRadii:_requestedHasExplicitRadii];
-  [self writeContentTranslation:_requestedContentTranslation
-                           scale:_requestedContentScale];
-  if (usesMask) {
-    [self configureUnequalCornerMaskForGeometry:target];
-    _clipContainer.layer.cornerRadius = 0;
-    _clipContainer.layer.mask = _unequalCornerMask;
-  }
-  [self setClipContainerHidden:NO];
-
-  CAAnimationGroup *group = [CAAnimationGroup animation];
-  NSMutableArray<CAAnimation *> *geometryAnimations = [NSMutableArray arrayWithArray:@[
-    [self keyframeAnimationForKeyPath:@"bounds"
-                               values:boundsValues
-                             keyTimes:times],
-    [self keyframeAnimationForKeyPath:@"position"
-                               values:positionValues
-                             keyTimes:times],
-  ]];
-  if (!usesMask) {
-    [geometryAnimations addObject:
-        [self keyframeAnimationForKeyPath:@"cornerRadius"
-                                   values:radiusValues
-                                 keyTimes:times]];
-  }
-  group.animations = geometryAnimations;
-  group.duration = MAX(0, durationMs) / 1000.0;
-  CAAnimationGroup *contentGroup = [CAAnimationGroup animation];
-  NSMutableArray<CAAnimation *> *contentAnimations = [NSMutableArray arrayWithArray:@[
-    [self keyframeAnimationForKeyPath:@"transform.translation.x"
-                               values:translateXValues
-                             keyTimes:times],
-    [self keyframeAnimationForKeyPath:@"transform.translation.y"
-                               values:translateYValues
-                             keyTimes:times],
-  ]];
-  if (animatesScale) {
-    [contentAnimations addObject:
-        [self keyframeAnimationForKeyPath:@"transform.scale"
-                                   values:scaleValues
-                                 keyTimes:times]];
-  }
-  contentGroup.animations = contentAnimations;
-  contentGroup.duration = group.duration;
-
-  CAKeyframeAnimation *maskAnimation = usesMask
-      ? [self keyframeAnimationForKeyPath:@"path"
-                                  values:maskPathValues
-                                keyTimes:times]
-      : nil;
-  maskAnimation.duration = group.duration;
-
-  if (sharedBeginTime > 0) {
-    group.beginTime = [_clipContainer.layer
-        convertTime:sharedBeginTime
-        fromLayer:nil];
-    contentGroup.beginTime = [_contentContainer.layer
-        convertTime:sharedBeginTime
-        fromLayer:nil];
-    if (maskAnimation != nil) {
-      maskAnimation.beginTime = [_unequalCornerMask
-          convertTime:sharedBeginTime
-          fromLayer:nil];
-    }
-  }
-
-  _animationDuration = group.duration;
-  _animationStartedAt = sharedBeginTime > 0
-      ? sharedBeginTime
-      : CACurrentMediaTime();
-  _animationDelegate = [SmoothClipAnimationDelegate new];
-  _animationDelegate.view = self;
-  _animationDelegate.driverId = _driverId;
-  _animationDelegate.animationId = _activeAnimationId;
-  group.delegate = _animationDelegate;
-  [_clipContainer.layer addAnimation:group forKey:@"smoothClip.geometry"];
-  [_contentContainer.layer addAnimation:contentGroup
-                                 forKey:@"smoothClip.content"];
-  if (maskAnimation != nil) {
-    [_unequalCornerMask addAnimation:maskAnimation forKey:@"smoothClip.mask"];
-  }
-  _animationInstallGeneration += 1;
-  return YES;
-}
-
 - (void)smoothClipCancelAnimationUsingTarget:(BOOL)useTarget {
   if (_activeAnimationId == 0) return;
   const smoothclip::Presentation visible =
@@ -1277,8 +1473,11 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   _activeAnimationKind = 0;
   _animationDelegate = nil;
   [_unequalCornerMask removeAnimationForKey:@"smoothClip.mask"];
-  [self applyStaticCornerRepresentation:[self normalizedGeometryValue]];
-  [self syncVisibilityForRect:_normalizedClip];
+  [_shadowLayer removeAnimationForKey:@"smoothClip.shadow"];
+  [self applyStaticCornerRepresentation:[self canonicalGeometryValue]];
+  [self writeShadow:_requestedShadow
+            geometry:[self canonicalGeometryValue]];
+  [self syncVisibilityForRect:_canonicalClip];
   smoothclip::viewAnimationDidStop(
       driverId, animationId, self, finished);
 }
@@ -1288,45 +1487,38 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   const auto &newProps =
       *std::static_pointer_cast<const SmoothClipViewProps>(props);
   [super updateProps:props oldProps:oldProps];
+  self.clipsToBounds = YES;
 
   const uint64_t nextDriverId =
       isfinite(newProps.driverId) && newProps.driverId > 0
       ? static_cast<uint64_t>(newProps.driverId)
       : 0;
   smoothclip::Presentation initial{};
-  if (newProps.presentationVersion == 2) {
-    if (!SmoothClipBuildPresentationV2(
-            newProps.initialClipX,
-            newProps.initialClipY,
-            newProps.initialClipWidth,
-            newProps.initialClipHeight,
-            newProps.initialClipTopLeftRadius,
-            newProps.initialClipTopRightRadius,
-            newProps.initialClipBottomRightRadius,
-            newProps.initialClipBottomLeftRadius,
-            newProps.initialClipCurve,
-            newProps.initialContentTranslateX,
-            newProps.initialContentTranslateY,
-            newProps.initialContentScale,
-            &initial)) {
-      // The initial V2 presentation is one atomic value. Do not unregister an
-      // old driver or apply a subset of valid channels when any field rejects.
-      return;
-    }
-  } else if (newProps.presentationVersion == 0 ||
-             newProps.presentationVersion == 1) {
-    // Version zero is what old JS produces when the versioned prop does not
-    // exist. Preserve that old-JS/new-native path byte-for-byte as V1.
-    initial = {
-        {newProps.initialClipX,
-         newProps.initialClipY,
-         newProps.initialClipWidth,
-         newProps.initialClipHeight,
-         newProps.initialClipRadius},
-        newProps.initialContentTranslateX,
-        newProps.initialContentTranslateY};
-  } else {
-    // A future protocol must not be silently interpreted as V1.
+  if (!SmoothClipBuildPresentation(
+          newProps.initialClipX,
+          newProps.initialClipY,
+          newProps.initialClipWidth,
+          newProps.initialClipHeight,
+          newProps.initialClipTopLeftRadius,
+          newProps.initialClipTopRightRadius,
+          newProps.initialClipBottomRightRadius,
+          newProps.initialClipBottomLeftRadius,
+          newProps.initialClipCurve,
+          newProps.initialContentTranslateX,
+          newProps.initialContentTranslateY,
+          newProps.initialContentScale,
+          newProps.initialClipBoxShadowEnabled,
+          newProps.initialClipBoxShadowRed,
+          newProps.initialClipBoxShadowGreen,
+          newProps.initialClipBoxShadowBlue,
+          newProps.initialClipBoxShadowAlpha,
+          newProps.initialClipBoxShadowOffsetX,
+          newProps.initialClipBoxShadowOffsetY,
+          newProps.initialClipBoxShadowBlurRadius,
+          newProps.initialClipBoxShadowSpreadDistance,
+          &initial)) {
+    // The initial presentation is atomic. Never apply a valid subset when one
+    // field rejects.
     return;
   }
 
@@ -1354,121 +1546,24 @@ static std::array<double, 11> SmoothClipVelocityChannels(
 
 - (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
              oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
-  const BOOL wasAnimating = _activeAnimationId != 0;
-  const BOOL wasPending = _pendingAnimationInstall;
-  const uint32_t installGenerationAtEntry = _animationInstallGeneration;
-  const smoothclip::Presentation visible = wasAnimating && !wasPending
-      ? [self smoothClipCurrentPresentation]
-      : smoothclip::Presentation{{0, 0, 0, 0, 0}, 0, 0, 1};
-  const CGRect visibleRect = CGRectMake(
-      visible.clip.x,
-      visible.clip.y,
-      visible.clip.width,
-      visible.clip.height);
-  const SmoothClipCornerRadii visibleRadii =
-      SmoothClipPresentationRadii(visible.clip);
-  const SmoothClipCornerCurve visibleCurve =
-      SmoothClipPresentationCurve(visible.clip);
-  const CGPoint visibleContentTranslation = CGPointMake(
-      visible.contentTranslateX,
-      visible.contentTranslateY);
-  const CGFloat visibleContentScale = visible.contentScale;
-  CFTimeInterval remaining = wasAnimating
-      ? MAX(0, _animationDuration -
-                   (CACurrentMediaTime() - _animationStartedAt))
-      : 0;
-  const double springContinuationVelocity =
-      wasAnimating && !wasPending && _activeAnimationKind == 2
-      ? [self smoothClipSpringContinuationVelocity]
-      : 0;
-
   [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
   _hasLayout = YES;
   [self layoutContentContainer];
   if (_driverId != 0) {
-    // Both edges matter: zero size/detach/background suspend an installed
-    // participant; the first positive visible layout resumes the held latch.
     smoothclip::viewDisplayabilityChanged(_driverId, self);
   }
-  if (wasPending) {
-    // The registry either kept the install deferred or installed the rebased
-    // latch. Relayout must not independently restart a background-held id.
-    if (_activeAnimationId == 0) [self applyRequestedClip];
-    return;
-  }
-  if (wasAnimating) {
-    // A negative transition may have frozen this host and re-latched the
-    // registry above. Its non-recording freeze is already the correct model
-    // state for the new lifecycle; do not resurrect a local timer.
-    if (_activeAnimationId == 0 || ![self smoothClipCanDisplay]) return;
-    // The lifecycle notification above may itself have installed this
-    // animation from the registry's trimmed remainder (a latch resume inside
-    // this very layout pass). That install rebased the clocks; the `remaining`
-    // captured on entry predates the suspension and would rebuild a shorter —
-    // possibly zero-duration — run on top of the fresh one. The id alone
-    // cannot detect this (a resume keeps the animation id), so compare the
-    // install generation.
-    if (_animationInstallGeneration != installGenerationAtEntry) return;
-    const int32_t animationId = _activeAnimationId;
-    const NSInteger animationKind = _activeAnimationKind;
-    [self stopLayerAnimationWithoutCallback];
-    _activeAnimationId = animationId;
-    _activeAnimationKind = animationKind;
-    if (_activeAnimationKind == 1 && _animationDuration > 0) {
-      const double progress = smoothclip::clamp01(
-          1 - remaining / _animationDuration);
-      _timingAnimation =
-          smoothclip::timingRemainder(_timingAnimation, progress).animation;
-      remaining = _timingAnimation.durationMs / 1000.0;
-    } else if (_activeAnimationKind == 2) {
-      _springAnimation.initialVelocity = springContinuationVelocity;
-      _springAnimation.inheritVelocity = false;
-    } else if (_activeAnimationKind == 3) {
-      _activeAnimationKind = 1;
-      _timingAnimation = {remaining * 1000.0, 0, 0, 1, 1, 2};
-    }
-    SmoothNormalizedClipGeometry current;
-    SmoothClipNormalizeGeometryV2(
-        CGRectGetMinX(visibleRect),
-        CGRectGetMinY(visibleRect),
-        CGRectGetWidth(visibleRect),
-        CGRectGetHeight(visibleRect),
-        visibleRadii.topLeft,
-        visibleRadii.topRight,
-        visibleRadii.bottomRight,
-        visibleRadii.bottomLeft,
-        visibleCurve,
-        self.bounds.size,
-        &current);
-    SmoothNormalizedClipGeometry target;
-    if ([self normalizedRequestedGeometry:&target]) {
-      [self installAnimationFromGeometry:current
-                  fromContentTranslation:visibleContentTranslation
-                        fromContentScale:visibleContentScale
-                              toGeometry:target
-                    hasExplicitToRadii:_requestedHasExplicitRadii
-                    toContentTranslation:_requestedContentTranslation
-                              toContentScale:_requestedContentScale
-                                duration:remaining
-                         sharedBeginTime:0];
-    }
-  } else {
-    if (_driverId != 0 && smoothclip::hasActiveAnimation(_driverId)) {
-      // Registry-level lifecycle pause owns the frozen model. A layout pass
-      // while its latch is held must not apply the requested target or start a
-      // per-view timer; foreground/reattach will normalize and resume it once.
-      return;
-    }
+  if (_activeAnimationId == 0 &&
+      (_driverId == 0 || !smoothclip::hasActiveAnimation(_driverId))) {
     [self applyRequestedClip];
   }
 }
 
 - (BOOL)pointInside:(CGPoint)point withEvent:(UIEvent *)event {
   if (![super pointInside:point withEvent:event]) return NO;
-  SmoothClipCornerRadii radii = _normalizedRadii;
+  SmoothClipCornerRadii radii = _canonicalRadii;
   const CGRect clip = _activeAnimationId != 0
       ? [self presentationRectWithRadii:&radii]
-      : _normalizedClip;
+      : _canonicalClip;
   if (CGRectIsEmpty(clip) || !CGRectContainsPoint(clip, point)) return NO;
   CGPathRef path = nil;
   if (_clipContainer.layer.mask == _unequalCornerMask) {
@@ -1479,7 +1574,7 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     path = mask.path;
     return path != nil && CGPathContainsPoint(path, NULL, point, NO);
   }
-  path = SmoothClipCreateRoundedRectPath(clip, radii, _normalizedCurve);
+  path = SmoothClipCreateRoundedRectPath(clip, radii, _canonicalCurve);
   const BOOL contains = CGPathContainsPoint(path, NULL, point, NO);
   CGPathRelease(path);
   return contains;
@@ -1491,31 +1586,7 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   RCTSmoothClipViewHandleCommand(self, commandName, args);
 }
 
-- (void)setClipGeometry:(double)x
-                       y:(double)y
-                   width:(double)width
-                  height:(double)height
-                  radius:(double)radius {
-  _commandIsAuthoritative = YES;
-  [self smoothClipApplyPresentation:
-      {{x, y, width, height, radius}, 0, 0}];
-}
-
 - (void)setClipPresentation:(double)x
-                           y:(double)y
-                       width:(double)width
-                      height:(double)height
-                      radius:(double)radius
-           contentTranslateX:(double)contentTranslateX
-           contentTranslateY:(double)contentTranslateY {
-  _commandIsAuthoritative = YES;
-  [self smoothClipApplyPresentation:
-      {{x, y, width, height, radius},
-       contentTranslateX,
-       contentTranslateY}];
-}
-
-- (void)setClipPresentationV2:(double)x
                             y:(double)y
                         width:(double)width
                        height:(double)height
@@ -1526,9 +1597,18 @@ static std::array<double, 11> SmoothClipVelocityChannels(
                     curveCode:(NSInteger)curveCode
             contentTranslateX:(double)contentTranslateX
             contentTranslateY:(double)contentTranslateY
-                 contentScale:(double)contentScale {
+                 contentScale:(double)contentScale
+                shadowEnabled:(BOOL)shadowEnabled
+                     shadowRed:(double)shadowRed
+                   shadowGreen:(double)shadowGreen
+                    shadowBlue:(double)shadowBlue
+                   shadowAlpha:(double)shadowAlpha
+                 shadowOffsetX:(double)shadowOffsetX
+                 shadowOffsetY:(double)shadowOffsetY
+              shadowBlurRadius:(double)shadowBlurRadius
+              shadowSpreadDistance:(double)shadowSpreadDistance {
   smoothclip::Presentation presentation{};
-  if (!SmoothClipBuildPresentationV2(
+  if (!SmoothClipBuildPresentation(
           x,
           y,
           width,
@@ -1541,6 +1621,15 @@ static std::array<double, 11> SmoothClipVelocityChannels(
           contentTranslateX,
           contentTranslateY,
           contentScale,
+          shadowEnabled,
+          shadowRed,
+          shadowGreen,
+          shadowBlue,
+          shadowAlpha,
+          shadowOffsetX,
+          shadowOffsetY,
+          shadowBlurRadius,
+          shadowSpreadDistance,
           &presentation)) {
     return;
   }
@@ -1554,23 +1643,24 @@ static std::array<double, 11> SmoothClipVelocityChannels(
     _driverId = 0;
   }
   [self stopLayerAnimationWithoutCallback];
-  _pendingAnimationInstall = NO;
   smoothclip::clearVelocitySamples(_velocitySamples);
   [super prepareForRecycle];
   _requestedClip = CGRectZero;
-  _normalizedClip = CGRectZero;
+  _canonicalClip = CGRectZero;
   _requestedRadius = 0;
-  _normalizedRadius = 0;
+  _canonicalRadius = 0;
   _requestedRadii = {0, 0, 0, 0};
-  _normalizedRadii = {0, 0, 0, 0};
+  _canonicalRadii = {0, 0, 0, 0};
   _requestedCurve = SmoothClipCornerCurveCircular;
-  _normalizedCurve = SmoothClipCornerCurveCircular;
+  _canonicalCurve = SmoothClipCornerCurveCircular;
   _requestedHasExplicitRadii = NO;
-  _normalizedHasExplicitRadii = NO;
+  _canonicalHasExplicitRadii = NO;
   _requestedContentTranslation = CGPointZero;
-  _normalizedContentTranslation = CGPointZero;
+  _canonicalContentTranslation = CGPointZero;
   _requestedContentScale = 1;
-  _normalizedContentScale = 1;
+  _canonicalContentScale = 1;
+  _requestedShadow = {};
+  _canonicalShadow = {};
   _hasLayout = NO;
   _commandIsAuthoritative = NO;
 
@@ -1582,6 +1672,10 @@ static std::array<double, 11> SmoothClipVelocityChannels(
   layer.mask = nil;
   _unequalCornerMask.path = nil;
   _contentContainer.layer.affineTransform = CGAffineTransformIdentity;
+  _shadowLayer.shadowPath = nil;
+  _shadowLayer.shadowOpacity = 0;
+  _shadowLayer.shadowRadius = 0;
+  _shadowLayer.shadowOffset = CGSizeZero;
   [self setClipContainerHidden:YES];
 }