react-native-smooth-clip-view 0.2.9 → 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;
 
@@ -51,26 +53,305 @@ using namespace facebook::react;
                                        finished:(BOOL)finished;
 @end
 
-static std::array<double, 7> SmoothClipVelocityChannels(
-    CGRect rect, CGFloat radius, CGPoint contentTranslation) {
+static SmoothClipCornerRadii SmoothClipPresentationRadii(
+    const smoothclip::Geometry &geometry) {
+  return {
+      (CGFloat)smoothclip::resolvedRadius(
+          geometry.topLeftRadius, geometry.radius),
+      (CGFloat)smoothclip::resolvedRadius(
+          geometry.topRightRadius, geometry.radius),
+      (CGFloat)smoothclip::resolvedRadius(
+          geometry.bottomRightRadius, geometry.radius),
+      (CGFloat)smoothclip::resolvedRadius(
+          geometry.bottomLeftRadius, geometry.radius),
+  };
+}
+
+static BOOL SmoothClipPresentationHasExplicitRadii(
+    const smoothclip::Geometry &geometry) {
+  return isfinite(geometry.topLeftRadius) ||
+      isfinite(geometry.topRightRadius) ||
+      isfinite(geometry.bottomRightRadius) ||
+      isfinite(geometry.bottomLeftRadius);
+}
+
+static SmoothClipCornerCurve SmoothClipPresentationCurve(
+    const smoothclip::Geometry &geometry) {
+  return geometry.curve == smoothclip::ClipCurve::Continuous
+      ? SmoothClipCornerCurveContinuous
+      : SmoothClipCornerCurveCircular;
+}
+
+static bool SmoothClipBuildPresentation(
+    double x,
+    double y,
+    double width,
+    double height,
+    double topLeftRadius,
+    double topRightRadius,
+    double bottomRightRadius,
+    double bottomLeftRadius,
+    NSInteger curveCode,
+    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) || !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;
+  }
+
+  const bool uniform = topLeftRadius == topRightRadius &&
+      topLeftRadius == bottomRightRadius &&
+      topLeftRadius == bottomLeftRadius;
+  smoothclip::Geometry geometry{
+      x, y, width, height, uniform ? topLeftRadius : 0};
+  geometry.topLeftRadius = topLeftRadius;
+  geometry.topRightRadius = topRightRadius;
+  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, 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
+      ? kCACornerCurveContinuous
+      : kCACornerCurveCircular;
+}
+
+static CGAffineTransform SmoothClipContentTransform(
+    CGFloat scale,
+    CGPoint translation) {
+  // Construct the matrix directly. Concatenating a translation and a scale is
+  // order-sensitive and can multiply tx/ty; the presentation contract requires
+  // a centered uniform scale with translation remaining in unscaled points.
+  return CGAffineTransformMake(
+      scale, 0, 0, scale, translation.x, translation.y);
+}
+
+struct SmoothClipPathEndpoints {
+  CGPoint points[9];
+  size_t count;
+};
+
+static void SmoothClipCollectPathEndpoints(
+    void *context,
+    const CGPathElement *element) {
+  SmoothClipPathEndpoints *endpoints =
+      static_cast<SmoothClipPathEndpoints *>(context);
+  if (endpoints->count >= 9 ||
+      element->type == kCGPathElementCloseSubpath) {
+    return;
+  }
+  const size_t endpointIndex =
+      element->type == kCGPathElementAddCurveToPoint ? 2 :
+      element->type == kCGPathElementAddQuadCurveToPoint ? 1 : 0;
+  endpoints->points[endpoints->count++] = element->points[endpointIndex];
+}
+
+static SmoothClipCornerRadii SmoothClipRadiiFromFixedPath(
+    CGPathRef path,
+    CGRect rect,
+    SmoothClipCornerRadii fallback) {
+  if (path == nil) return fallback;
+  SmoothClipPathEndpoints endpoints{};
+  CGPathApply(path, &endpoints, SmoothClipCollectPathEndpoints);
+  if (endpoints.count != 9) return fallback;
+  return {
+      MAX(0, endpoints.points[0].x - CGRectGetMinX(rect)),
+      MAX(0, CGRectGetMaxX(rect) - endpoints.points[1].x),
+      MAX(0, CGRectGetMaxY(rect) - endpoints.points[3].y),
+      MAX(0, endpoints.points[5].x - CGRectGetMinX(rect)),
+  };
+}
+
+static std::array<double, 11> SmoothClipVelocityChannels(
+    CGRect rect,
+    SmoothClipCornerRadii radii,
+    CGPoint contentTranslation,
+    CGFloat contentScale) {
   return {CGRectGetMinX(rect),
           CGRectGetMinY(rect),
           CGRectGetWidth(rect),
           CGRectGetHeight(rect),
-          radius,
+          radii.topLeft,
+          radii.topRight,
+          radii.bottomRight,
+          radii.bottomLeft,
           contentTranslation.x,
-          contentTranslation.y};
+          contentTranslation.y,
+          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 _canonicalRadii;
+  SmoothClipCornerCurve _requestedCurve;
+  SmoothClipCornerCurve _canonicalCurve;
+  BOOL _requestedHasExplicitRadii;
+  BOOL _canonicalHasExplicitRadii;
   CGPoint _requestedContentTranslation;
-  CGPoint _normalizedContentTranslation;
+  CGPoint _canonicalContentTranslation;
+  CGFloat _requestedContentScale;
+  CGFloat _canonicalContentScale;
+  smoothclip::Shadow _requestedShadow;
+  smoothclip::Shadow _canonicalShadow;
   uint64_t _driverId;
   BOOL _hasLayout;
   BOOL _commandIsAuthoritative;
@@ -81,23 +362,11 @@ static std::array<double, 7> 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;
@@ -124,6 +393,9 @@ static std::array<double, 7> 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;
@@ -139,20 +411,40 @@ static std::array<double, 7> 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],
+      @"bounds": [NSNull null],
+      @"position": [NSNull null],
+    };
+    _unequalCornerMask.fillColor = UIColor.blackColor.CGColor;
+    _unequalCornerMask.needsDisplayOnBoundsChange = NO;
+
     _requestedClip = CGRectZero;
-    _normalizedClip = CGRectZero;
+    _canonicalClip = CGRectZero;
     _requestedRadius = 0;
-    _normalizedRadius = 0;
+    _canonicalRadius = 0;
+    _requestedRadii = {0, 0, 0, 0};
+    _canonicalRadii = {0, 0, 0, 0};
+    _requestedCurve = SmoothClipCornerCurveCircular;
+    _canonicalCurve = SmoothClipCornerCurveCircular;
+    _requestedHasExplicitRadii = NO;
+    _canonicalHasExplicitRadii = NO;
     _requestedContentTranslation = CGPointZero;
-    _normalizedContentTranslation = CGPointZero;
+    _canonicalContentTranslation = CGPointZero;
+    _requestedContentScale = 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,
@@ -198,13 +490,72 @@ static std::array<double, 7> SmoothClipVelocityChannels(
       geometry.y,
       MAX(0, geometry.width),
       MAX(0, geometry.height));
-  _requestedRadius = MAX(0, geometry.radius);
+  _requestedRadii = SmoothClipPresentationRadii(geometry);
+  _requestedRadius = SmoothClipCornerRadiiAreUniform(_requestedRadii)
+      ? MAX(0, _requestedRadii.topLeft)
+      : 0;
+  _requestedCurve = SmoothClipPresentationCurve(geometry);
+  _requestedHasExplicitRadii =
+      SmoothClipPresentationHasExplicitRadii(geometry);
   _requestedContentTranslation = CGPointMake(
       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;
 }
 
-- (BOOL)normalizedRequestedGeometry:(SmoothNormalizedClipGeometry *)geometry {
+- (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);
+}
+
+- (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 =
@@ -213,22 +564,24 @@ static std::array<double, 7> 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 = SmoothClipNormalizeGeometry(
+  const BOOL valid = SmoothClipCanonicalizeGeometry(
       CGRectGetMinX(_requestedClip),
       CGRectGetMinY(_requestedClip),
       CGRectGetWidth(_requestedClip),
       CGRectGetHeight(_requestedClip),
-      _requestedRadius,
-      CGSizeMake(MAX(0, hostSize.width), MAX(0, hostSize.height)),
+      _requestedRadii.topLeft,
+      _requestedRadii.topRight,
+      _requestedRadii.bottomRight,
+      _requestedRadii.bottomLeft,
+      _requestedCurve,
       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;
@@ -243,14 +596,63 @@ static std::array<double, 7> SmoothClipVelocityChannels(
 
 - (void)syncVisibilityForRect:(CGRect)rect {
   [self setClipContainerHidden:CGRectIsEmpty(rect)];
+  _clipContainer.accessibilityElementsHidden =
+      !SmoothClipRectIntersectsHost(rect, self.bounds);
+}
+
+- (void)configureUnequalCornerMaskForGeometry:
+    (SmoothClipCanonicalGeometry)geometry {
+  _unequalCornerMask.bounds = geometry.rect;
+  _unequalCornerMask.position = CGPointMake(
+      CGRectGetMidX(geometry.rect), CGRectGetMidY(geometry.rect));
+  CGPathRef path = SmoothClipCreateRoundedRectPath(
+      geometry.rect, geometry.radii, geometry.curve);
+  _unequalCornerMask.path = path;
+  CGPathRelease(path);
+}
+
+- (void)applyStaticCornerRepresentation:
+    (SmoothClipCanonicalGeometry)geometry {
+  CALayer *layer = _clipContainer.layer;
+  if (SmoothClipCornerRadiiAreUniform(geometry.radii)) {
+    layer.mask = nil;
+    layer.cornerRadius = geometry.radii.topLeft;
+    layer.cornerCurve = SmoothClipCALayerCornerCurve(geometry.curve);
+  } else {
+    layer.cornerRadius = 0;
+    layer.cornerCurve = kCACornerCurveCircular;
+    [self configureUnequalCornerMaskForGeometry:geometry];
+    layer.mask = _unequalCornerMask;
+  }
 }
 
-- (void)writeLayerRect:(CGRect)rect radius:(CGFloat)radius {
-  const BOOL rectChanged = !CGRectEqualToRect(_normalizedClip, rect);
-  const BOOL radiusChanged = _normalizedRadius != radius;
-  _normalizedClip = rect;
-  _normalizedRadius = radius;
-  if (!rectChanged && !radiusChanged) return;
+- (SmoothClipCanonicalGeometry)canonicalGeometryValue {
+  return {
+      .rect = _canonicalClip,
+      .radius = _canonicalRadius,
+      .radii = _canonicalRadii,
+      .curve = _canonicalCurve,
+  };
+}
+
+- (void)writeLayerGeometry:(SmoothClipCanonicalGeometry)geometry
+         hasExplicitRadii:(BOOL)hasExplicitRadii {
+  const BOOL rectChanged =
+      !CGRectEqualToRect(_canonicalClip, geometry.rect);
+  const BOOL radiiChanged =
+      !SmoothClipCornerRadiiEqual(_canonicalRadii, geometry.radii);
+  const BOOL curveChanged = _canonicalCurve != geometry.curve;
+  const BOOL representationChanged =
+      _canonicalHasExplicitRadii != hasExplicitRadii;
+  _canonicalClip = geometry.rect;
+  _canonicalRadius = geometry.radius;
+  _canonicalRadii = geometry.radii;
+  _canonicalCurve = geometry.curve;
+  _canonicalHasExplicitRadii = hasExplicitRadii;
+  if (!rectChanged && !radiiChanged && !curveChanged &&
+      !representationChanged) {
+    return;
+  }
 
 #if defined(SMOOTH_CLIP_ENABLE_SIGNPOSTS) && SMOOTH_CLIP_ENABLE_SIGNPOSTS
   const bool signpostsEnabled =
@@ -264,12 +666,13 @@ static std::array<double, 7> SmoothClipVelocityChannels(
 #endif
   CALayer *layer = _clipContainer.layer;
   if (rectChanged) {
-    layer.bounds = rect;
-    layer.position = CGPointMake(CGRectGetMidX(rect), CGRectGetMidY(rect));
-  }
-  if (radiusChanged) {
-    layer.cornerRadius = radius;
+    layer.bounds = geometry.rect;
+    layer.position = CGPointMake(
+        CGRectGetMidX(geometry.rect), CGRectGetMidY(geometry.rect));
   }
+  // The uniform common case stays on CALayer's compositor fast path and uses
+  // the platform's exact continuous-corner implementation.
+  [self applyStaticCornerRepresentation:geometry];
 #if defined(SMOOTH_CLIP_ENABLE_SIGNPOSTS) && SMOOTH_CLIP_ENABLE_SIGNPOSTS
   if (signpostsEnabled) {
     os_signpost_interval_end(
@@ -278,53 +681,101 @@ static std::array<double, 7> SmoothClipVelocityChannels(
 #endif
 }
 
-- (void)writeContentTranslation:(CGPoint)translation {
-  if (CGPointEqualToPoint(_normalizedContentTranslation, translation)) return;
-  _normalizedContentTranslation = translation;
+- (void)writeContentTranslation:(CGPoint)translation
+                           scale:(CGFloat)scale {
+  if (CGPointEqualToPoint(_canonicalContentTranslation, translation) &&
+      _canonicalContentScale == scale) {
+    return;
+  }
+  _canonicalContentTranslation = translation;
+  _canonicalContentScale = scale;
   _contentContainer.layer.affineTransform =
-      CGAffineTransformMakeTranslation(translation.x, translation.y);
+      SmoothClipContentTransform(scale, translation);
 }
 
 - (void)applyRequestedClip {
-  SmoothNormalizedClipGeometry geometry;
-  if (![self normalizedRequestedGeometry:&geometry]) return;
-
-  const BOOL visibilityChanged = _clipHidden != CGRectIsEmpty(geometry.rect);
-  if (CGRectEqualToRect(_normalizedClip, geometry.rect) &&
-      _normalizedRadius == geometry.radius &&
+  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) &&
+          _canonicalContentTranslation, _requestedContentTranslation) &&
+      _canonicalContentScale == _requestedContentScale &&
+      SmoothBoxShadowEqual(_canonicalShadow, _requestedShadow) &&
       !visibilityChanged) {
     return;
   }
-  [self writeLayerRect:geometry.rect radius:geometry.radius];
-  [self writeContentTranslation:_requestedContentTranslation];
+  [self writeLayerGeometry:geometry
+         hasExplicitRadii:_requestedHasExplicitRadii];
+  [self writeContentTranslation:_requestedContentTranslation
+                           scale:_requestedContentScale];
+  [self writeShadow:_requestedShadow geometry:geometry];
   [self syncVisibilityForRect:geometry.rect];
 }
 
 - (void)recordInteractiveRect:(CGRect)rect
-                       radius:(CGFloat)radius
-           contentTranslation:(CGPoint)contentTranslation {
+                        radii:(SmoothClipCornerRadii)radii
+           contentTranslation:(CGPoint)contentTranslation
+                 contentScale:(CGFloat)contentScale {
   // Identical-value dedupe and same-frame coalescing live in the shared
   // tracker; coalescing keeps a distinct re-record issued sub-frame after
   // the last one (e.g. a fused animateTo `from` seed at gesture release)
   // from exploding the inherited velocity.
   smoothclip::recordVelocitySample(
       _velocitySamples,
-      SmoothClipVelocityChannels(rect, radius, contentTranslation),
+      SmoothClipVelocityChannels(
+          rect, radii, contentTranslation, contentScale),
       CACurrentMediaTime());
 }
 
 - (CGFloat)inheritedVelocityToRect:(CGRect)target
-                            radius:(CGFloat)targetRadius
-                contentTranslation:(CGPoint)targetContentTranslation {
+                             radii:(SmoothClipCornerRadii)targetRadii
+                contentTranslation:(CGPoint)targetContentTranslation
+                      contentScale:(CGFloat)targetContentScale {
   return smoothclip::inheritedVelocity(
       _velocitySamples,
       SmoothClipVelocityChannels(
-          target, targetRadius, targetContentTranslation),
+          target,
+          targetRadii,
+          targetContentTranslation,
+          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];
 }
@@ -334,33 +785,72 @@ static std::array<double, 7> 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
-                         radius:_normalizedRadius
-             contentTranslation:_normalizedContentTranslation];
+    [self recordInteractiveRect:_canonicalClip
+                          radii:_canonicalRadii
+             contentTranslation:_canonicalContentTranslation
+                   contentScale:_canonicalContentScale];
   }
 }
 
 - (smoothclip::Presentation)smoothClipCurrentPresentation {
-  CGFloat visibleRadius = _normalizedRadius;
+  SmoothClipCornerRadii visibleRadii = _canonicalRadii;
   const CGRect visibleRect = _activeAnimationId != 0
-      ? [self presentationRectWithRadius:&visibleRadius]
-      : _normalizedClip;
+      ? [self presentationRectWithRadii:&visibleRadii]
+      : _canonicalClip;
   CALayer *contentLayer = _activeAnimationId != 0
       ? (CALayer *)_contentContainer.layer.presentationLayer
       : _contentContainer.layer;
   if (contentLayer == nil) contentLayer = _contentContainer.layer;
   const CGAffineTransform transform = contentLayer.affineTransform;
-  return {
-      {CGRectGetMinX(visibleRect),
-       CGRectGetMinY(visibleRect),
-       CGRectGetWidth(visibleRect),
-       CGRectGetHeight(visibleRect),
-       visibleRadius},
-      transform.tx,
-      transform.ty};
+  const BOOL uniform = SmoothClipCornerRadiiAreUniform(visibleRadii);
+  smoothclip::Geometry geometry{
+      CGRectGetMinX(visibleRect),
+      CGRectGetMinY(visibleRect),
+      CGRectGetWidth(visibleRect),
+      CGRectGetHeight(visibleRect),
+      uniform ? visibleRadii.topLeft : 0};
+  if (_canonicalHasExplicitRadii || !uniform) {
+    geometry.topLeftRadius = visibleRadii.topLeft;
+    geometry.topRightRadius = visibleRadii.topRight;
+    geometry.bottomRightRadius = visibleRadii.bottomRight;
+    geometry.bottomLeftRadius = visibleRadii.bottomLeft;
+  }
+  geometry.curve = _canonicalCurve == SmoothClipCornerCurveContinuous
+      ? smoothclip::ClipCurve::Continuous
+      : smoothclip::ClipCurve::Circular;
+  const CGFloat contentScale = hypot(transform.a, transform.b);
+  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 {
@@ -373,64 +863,54 @@ static std::array<double, 7> 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];
-  const CGRect visibleRect = CGRectMake(
-      visible.clip.x,
-      visible.clip.y,
-      visible.clip.width,
-      visible.clip.height);
-  const CGPoint visibleContentTranslation = CGPointMake(
-      visible.contentTranslateX,
-      visible.contentTranslateY);
   [self stopLayerAnimationWithoutCallback];
-  _requestedClip = visibleRect;
-  _requestedRadius = visible.clip.radius;
-  _requestedContentTranslation = visibleContentTranslation;
-  [self writeLayerRect:visibleRect radius:visible.clip.radius];
-  [self writeContentTranslation:visibleContentTranslation];
-  [self syncVisibilityForRect:visibleRect];
+  [self storeRequestedPresentation:visible];
+  [self applyRequestedClip];
   return visible;
 }
 
-- (CGRect)presentationRectWithRadius:(CGFloat *)radius {
+- (CGRect)presentationRectWithRadii:(SmoothClipCornerRadii *)radii {
   CALayer *layer = (CALayer *)_clipContainer.layer.presentationLayer;
   if (layer == nil) layer = _clipContainer.layer;
   const CGRect bounds = layer.bounds;
   const CGPoint position = layer.position;
-  if (radius != nullptr) *radius = layer.cornerRadius;
-  return CGRectMake(
+  const CGRect rect = CGRectMake(
       position.x - bounds.size.width * layer.anchorPoint.x,
       position.y - bounds.size.height * layer.anchorPoint.y,
       bounds.size.width,
       bounds.size.height);
+  if (radii != nullptr) {
+    if (_clipContainer.layer.mask == _unequalCornerMask) {
+      CAShapeLayer *mask =
+          (CAShapeLayer *)_unequalCornerMask.presentationLayer;
+      if (mask == nil) mask = _unequalCornerMask;
+      *radii = SmoothClipRadiiFromFixedPath(
+          mask.path, rect, _canonicalRadii);
+    } else {
+      *radii = {
+          layer.cornerRadius,
+          layer.cornerRadius,
+          layer.cornerRadius,
+          layer.cornerRadius,
+      };
+    }
+  }
+  return rect;
 }
 
 - (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
@@ -440,6 +920,9 @@ static std::array<double, 7> SmoothClipVelocityChannels(
   _ignoreAnimationCallback = YES;
   [_clipContainer.layer removeAnimationForKey:@"smoothClip.geometry"];
   [_contentContainer.layer removeAnimationForKey:@"smoothClip.content"];
+  [_unequalCornerMask removeAnimationForKey:@"smoothClip.mask"];
+  [_shadowLayer removeAnimationForKey:@"smoothClip.shadow"];
+  [self applyStaticCornerRepresentation:[self canonicalGeometryValue]];
   _ignoreAnimationCallback = NO;
   _activeAnimationId = 0;
   _activeAnimationKind = 0;
@@ -458,15 +941,19 @@ static std::array<double, 7> 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
@@ -486,13 +973,19 @@ static std::array<double, 7> SmoothClipVelocityChannels(
   return animation;
 }
 
-- (void)installAnimationFromRect:(CGRect)fromRect
-                      fromRadius:(CGFloat)fromRadius
-          fromContentTranslation:(CGPoint)fromContentTranslation
-                          toRect:(CGRect)toRect
-                        toRadius:(CGFloat)toRadius
-            toContentTranslation:(CGPoint)toContentTranslation
-                        duration:(CFTimeInterval)duration {
+- (void)installAnimationFromGeometry:
+            (SmoothClipCanonicalGeometry)fromGeometry
+                   fromContentTranslation:(CGPoint)fromContentTranslation
+                         fromContentScale:(CGFloat)fromContentScale
+                              fromShadow:(smoothclip::Shadow)fromShadow
+                               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;
   const NSInteger animationKind = _activeAnimationKind;
   [self stopLayerAnimationWithoutCallback];
@@ -500,50 +993,133 @@ static std::array<double, 7> SmoothClipVelocityChannels(
   _activeAnimationKind = animationKind;
   // Unhide while any animated frame can show content; an empty-to-empty
   // transition must stay hidden for accessibility.
-  if (!CGRectIsEmpty(toRect) || !CGRectIsEmpty(fromRect)) {
+  if (!CGRectIsEmpty(toGeometry.rect) ||
+      !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 = toRect;
+  const CGRect toBounds = toGeometry.rect;
   const CGPoint fromPosition =
-      CGPointMake(CGRectGetMidX(fromRect), CGRectGetMidY(fromRect));
+      CGPointMake(
+          CGRectGetMidX(fromGeometry.rect),
+          CGRectGetMidY(fromGeometry.rect));
   const CGPoint toPosition =
-      CGPointMake(CGRectGetMidX(toRect), CGRectGetMidY(toRect));
-  layer.bounds = toBounds;
-  layer.position = toPosition;
-  layer.cornerRadius = toRadius;
-  _contentContainer.layer.affineTransform = CGAffineTransformMakeTranslation(
-      toContentTranslation.x,
-      toContentTranslation.y);
-  _normalizedClip = toRect;
-  _normalizedRadius = toRadius;
-  _normalizedContentTranslation = toContentTranslation;
+      CGPointMake(
+          CGRectGetMidX(toGeometry.rect),
+          CGRectGetMidY(toGeometry.rect));
+  const BOOL usesMask =
+      !SmoothClipCornerRadiiAreUniform(fromGeometry.radii) ||
+      !SmoothClipCornerRadiiAreUniform(toGeometry.radii) ||
+      fromGeometry.curve != toGeometry.curve;
+  [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
+    // create a one-frame seam even though the underlying paths are compatible.
+    [self configureUnequalCornerMaskForGeometry:toGeometry];
+    layer.cornerRadius = 0;
+    layer.mask = _unequalCornerMask;
+  }
 
+  CGPathRef fromMaskPath = usesMask
+      ? SmoothClipCreateRoundedRectPath(
+            fromGeometry.rect, fromGeometry.radii, fromGeometry.curve)
+      : nil;
+  CGPathRef toMaskPath = usesMask
+      ? 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];
+  CAAnimationGroup *shadowGroup = animatesShadow
+      ? [CAAnimationGroup animation]
+      : nil;
+  CAAnimationGroup *maskAnimation = nil;
   if (_activeAnimationKind == 1) {
     CAMediaTimingFunction *timing = [CAMediaTimingFunction
         functionWithControlPoints:_timingAnimation.controlPoint1X
                                   :_timingAnimation.controlPoint1Y
                                   :_timingAnimation.controlPoint2X
                                   :_timingAnimation.controlPoint2Y];
-    group.animations = @[
+    NSMutableArray<CAAnimation *> *geometryAnimations = [NSMutableArray arrayWithArray:@[
       [self basicAnimationForKeyPath:@"bounds"
-                           fromValue:[NSValue valueWithCGRect:fromRect]
+                           fromValue:[NSValue valueWithCGRect:fromGeometry.rect]
                              toValue:[NSValue valueWithCGRect:toBounds]
                       timingFunction:timing],
       [self basicAnimationForKeyPath:@"position"
                            fromValue:[NSValue valueWithCGPoint:fromPosition]
                              toValue:[NSValue valueWithCGPoint:toPosition]
                       timingFunction:timing],
-      [self basicAnimationForKeyPath:@"cornerRadius"
-                           fromValue:@(fromRadius)
-                             toValue:@(toRadius)
-                      timingFunction:timing],
-    ];
+    ]];
+    if (usesMask) {
+      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"
+                               fromValue:@(fromGeometry.radii.topLeft)
+                                 toValue:@(toGeometry.radii.topLeft)
+                          timingFunction:timing]];
+    }
+    group.animations = geometryAnimations;
     group.duration = duration;
-    contentGroup.animations = @[
+    NSMutableArray<CAAnimation *> *contentAnimations = [NSMutableArray arrayWithArray:@[
       [self basicAnimationForKeyPath:@"transform.translation.x"
                            fromValue:@(fromContentTranslation.x)
                              toValue:@(toContentTranslation.x)
@@ -552,8 +1128,43 @@ static std::array<double, 7> SmoothClipVelocityChannels(
                            fromValue:@(fromContentTranslation.y)
                              toValue:@(toContentTranslation.y)
                       timingFunction:timing],
-    ];
+    ]];
+    if (fromContentScale != 1 || toContentScale != 1) {
+      [contentAnimations addObject:
+          [self basicAnimationForKeyPath:@"transform.scale"
+                               fromValue:@(fromContentScale)
+                                 toValue:@(toContentScale)
+                          timingFunction:timing]];
+    }
+    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
@@ -565,24 +1176,24 @@ static std::array<double, 7> SmoothClipVelocityChannels(
     const double velocity = _springAnimation.initialVelocity;
     const CFTimeInterval springDuration =
         [self springSettlingDurationWithVelocity:velocity];
-    group.animations = @[
+    NSMutableArray<CAAnimation *> *geometryAnimations = [NSMutableArray arrayWithArray:@[
       [self springAnimationForKeyPath:@"bounds.origin.x"
-                            fromValue:@(fromRect.origin.x)
+                            fromValue:@(fromGeometry.rect.origin.x)
                               toValue:@(toBounds.origin.x)
                              velocity:velocity
                              duration:springDuration],
       [self springAnimationForKeyPath:@"bounds.origin.y"
-                            fromValue:@(fromRect.origin.y)
+                            fromValue:@(fromGeometry.rect.origin.y)
                               toValue:@(toBounds.origin.y)
                              velocity:velocity
                              duration:springDuration],
       [self springAnimationForKeyPath:@"bounds.size.width"
-                            fromValue:@(fromRect.size.width)
+                            fromValue:@(fromGeometry.rect.size.width)
                               toValue:@(toBounds.size.width)
                              velocity:velocity
                              duration:springDuration],
       [self springAnimationForKeyPath:@"bounds.size.height"
-                            fromValue:@(fromRect.size.height)
+                            fromValue:@(fromGeometry.rect.size.height)
                               toValue:@(toBounds.size.height)
                              velocity:velocity
                              duration:springDuration],
@@ -596,17 +1207,59 @@ static std::array<double, 7> SmoothClipVelocityChannels(
                               toValue:@(toPosition.y)
                              velocity:velocity
                              duration:springDuration],
-      [self springAnimationForKeyPath:@"cornerRadius"
-                            fromValue:@(fromRadius)
-                              toValue:@(toRadius)
-                             velocity:velocity
-                             duration:springDuration],
-    ];
-    // 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.
+    ]];
+    if (usesMask) {
+      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"
+                                fromValue:@(fromGeometry.radii.topLeft)
+                                  toValue:@(toGeometry.radii.topLeft)
+                                 velocity:velocity
+                                 duration:springDuration]];
+    }
+    group.animations = geometryAnimations;
+    // Springs use their analytic settling time; a wall-clock duration would
+    // truncate oscillation and snap to the target.
     group.duration = springDuration;
-    contentGroup.animations = @[
+    NSMutableArray<CAAnimation *> *contentAnimations = [NSMutableArray arrayWithArray:@[
       [self springAnimationForKeyPath:@"transform.translation.x"
                             fromValue:@(fromContentTranslation.x)
                               toValue:@(toContentTranslation.x)
@@ -617,12 +1270,74 @@ static std::array<double, 7> SmoothClipVelocityChannels(
                               toValue:@(toContentTranslation.y)
                              velocity:velocity
                              duration:springDuration],
-    ];
+    ]];
+    if (fromContentScale != 1 || toContentScale != 1) {
+      [contentAnimations addObject:
+          [self springAnimationForKeyPath:@"transform.scale"
+                                fromValue:@(fromContentScale)
+                                  toValue:@(toContentScale)
+                                 velocity:velocity
+                                 duration:springDuration]];
+    }
+    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) {
+    maskAnimation.duration = group.duration;
+  }
+
+  if (sharedBeginTime > 0) {
+    // Each layer receives the same absolute media timestamp translated into
+    // its local clock. Group participants therefore advance from one epoch
+    // even though their animations are installed sequentially.
+    group.beginTime = [layer convertTime:sharedBeginTime fromLayer:nil];
+    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
+          fromLayer:nil];
+    }
   }
 
-  _animationDuration = group.duration;
-  _animationStartedAt = CACurrentMediaTime();
   _animationDelegate = [SmoothClipAnimationDelegate new];
   _animationDelegate.view = self;
   _animationDelegate.driverId = _driverId;
@@ -631,189 +1346,122 @@ static std::array<double, 7> SmoothClipVelocityChannels(
   [layer addAnimation:group forKey:@"smoothClip.geometry"];
   [_contentContainer.layer addAnimation:contentGroup
                                  forKey:@"smoothClip.content"];
-  _animationInstallGeneration += 1;
+  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);
+  if (fromShadowPath != nil) CGPathRelease(fromShadowPath);
+  if (toShadowPath != nil) CGPathRelease(toShadowPath);
 }
 
-- (BOOL)startAnimationToRequestedGeometryWithDuration:(CFTimeInterval)duration {
+- (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];
-  [self installAnimationFromRect:CGRectMake(
-                                     current.clip.x,
-                                     current.clip.y,
-                                     current.clip.width,
-                                     current.clip.height)
-                      fromRadius:current.clip.radius
-          fromContentTranslation:CGPointMake(
-                                     current.contentTranslateX,
-                                     current.contentTranslateY)
-                          toRect:target.rect
-                        toRadius:target.radius
-            toContentTranslation:_requestedContentTranslation
-                        duration:duration];
+  const SmoothClipCornerRadii currentRadii =
+      SmoothClipPresentationRadii(current.clip);
+  const SmoothClipCanonicalGeometry fromGeometry = {
+      .rect = CGRectMake(
+          current.clip.x,
+          current.clip.y,
+          current.clip.width,
+          current.clip.height),
+      .radius = SmoothClipCornerRadiiAreUniform(currentRadii)
+          ? currentRadii.topLeft
+          : 0,
+      .radii = currentRadii,
+      .curve = SmoothClipPresentationCurve(current.clip),
+  };
+  [self installAnimationFromGeometry:fromGeometry
+              fromContentTranslation:CGPointMake(
+                                         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;
 }
 
 - (BOOL)smoothClipAnimateTiming:(smoothclip::Presentation)presentation
                        animation:(smoothclip::TimingAnimation)animation
                      animationId:(int32_t)animationId {
+  return [self smoothClipAnimateTiming:presentation
+                              animation:animation
+                            animationId:animationId
+                        sharedBeginTime:0];
+}
+
+- (BOOL)smoothClipAnimateTiming:(smoothclip::Presentation)presentation
+                       animation:(smoothclip::TimingAnimation)animation
+                     animationId:(int32_t)animationId
+                 sharedBeginTime:(CFTimeInterval)sharedBeginTime {
   [self storeRequestedPresentation:presentation];
   _timingAnimation = animation;
   _activeAnimationKind = 1;
   _activeAnimationId = animationId;
   return [self startAnimationToRequestedGeometryWithDuration:
-                   MAX(0, animation.durationMs) / 1000.0];
+                   MAX(0, animation.durationMs) / 1000.0
+                                         sharedBeginTime:sharedBeginTime];
 }
 
 - (BOOL)smoothClipAnimateSpring:(smoothclip::Presentation)presentation
                        animation:(smoothclip::SpringAnimation)animation
                      animationId:(int32_t)animationId {
+  return [self smoothClipAnimateSpring:presentation
+                              animation:animation
+                            animationId:animationId
+                        sharedBeginTime:0];
+}
+
+- (BOOL)smoothClipAnimateSpring:(smoothclip::Presentation)presentation
+                       animation:(smoothclip::SpringAnimation)animation
+                     animationId:(int32_t)animationId
+                 sharedBeginTime:(CFTimeInterval)sharedBeginTime {
   [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
-                                  radius:target.radius
-                      contentTranslation:_requestedContentTranslation];
+                                   radii:target.radii
+                      contentTranslation:_requestedContentTranslation
+                            contentScale:_requestedContentScale];
     } else {
       _springAnimation.initialVelocity = 0;
     }
   }
   _activeAnimationKind = 2;
   _activeAnimationId = animationId;
-  return [self startAnimationToRequestedGeometryWithDuration:0];
-}
-
-- (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 {
-  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 *translateXValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  NSMutableArray *translateYValues =
-      [NSMutableArray arrayWithCapacity:frameCount];
-  for (const smoothclip::Keyframe &frame : keyframes) {
-    SmoothNormalizedClipGeometry normalized;
-    if (!SmoothClipNormalizeGeometry(
-            frame.presentation.clip.x,
-            frame.presentation.clip.y,
-            frame.presentation.clip.width,
-            frame.presentation.clip.height,
-            frame.presentation.clip.radius,
-            hostSize,
-            &normalized)) return NO;
-    [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)];
-  }
-
-  SmoothNormalizedClipGeometry target;
-  if (![self normalizedRequestedGeometry:&target]) return NO;
-  [self writeLayerRect:target.rect radius:target.radius];
-  [self writeContentTranslation:_requestedContentTranslation];
-  [self setClipContainerHidden:NO];
-
-  CAAnimationGroup *group = [CAAnimationGroup animation];
-  group.animations = @[
-    [self keyframeAnimationForKeyPath:@"bounds"
-                               values:boundsValues
-                             keyTimes:times],
-    [self keyframeAnimationForKeyPath:@"position"
-                               values:positionValues
-                             keyTimes:times],
-    [self keyframeAnimationForKeyPath:@"cornerRadius"
-                               values:radiusValues
-                             keyTimes:times],
-  ];
-  group.duration = MAX(0, durationMs) / 1000.0;
-  CAAnimationGroup *contentGroup = [CAAnimationGroup animation];
-  contentGroup.animations = @[
-    [self keyframeAnimationForKeyPath:@"transform.translation.x"
-                               values:translateXValues
-                             keyTimes:times],
-    [self keyframeAnimationForKeyPath:@"transform.translation.y"
-                               values:translateYValues
-                             keyTimes:times],
-  ];
-  contentGroup.duration = group.duration;
-
-  _animationDuration = group.duration;
-  _animationStartedAt = 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"];
-  _animationInstallGeneration += 1;
-  return YES;
+  return [self startAnimationToRequestedGeometryWithDuration:0
+                                              sharedBeginTime:sharedBeginTime];
 }
 
 - (void)smoothClipCancelAnimationUsingTarget:(BOOL)useTarget {
   if (_activeAnimationId == 0) return;
   const smoothclip::Presentation visible =
       [self smoothClipCurrentPresentation];
-  const CGRect visibleRect = CGRectMake(
-      visible.clip.x,
-      visible.clip.y,
-      visible.clip.width,
-      visible.clip.height);
-  const CGPoint visibleContentTranslation = CGPointMake(
-      visible.contentTranslateX,
-      visible.contentTranslateY);
   [self stopLayerAnimationWithoutCallback];
   if (useTarget) {
     [self applyRequestedClip];
   } else {
-    _requestedClip = visibleRect;
-    _requestedRadius = visible.clip.radius;
-    _requestedContentTranslation = visibleContentTranslation;
-    [self writeLayerRect:visibleRect radius:visible.clip.radius];
-    [self writeContentTranslation:visibleContentTranslation];
-    [self syncVisibilityForRect:visibleRect];
+    [self storeRequestedPresentation:visible];
+    [self applyRequestedClip];
   }
 }
 
@@ -824,7 +1472,12 @@ static std::array<double, 7> SmoothClipVelocityChannels(
   _activeAnimationId = 0;
   _activeAnimationKind = 0;
   _animationDelegate = nil;
-  [self syncVisibilityForRect:_normalizedClip];
+  [_unequalCornerMask removeAnimationForKey:@"smoothClip.mask"];
+  [_shadowLayer removeAnimationForKey:@"smoothClip.shadow"];
+  [self applyStaticCornerRepresentation:[self canonicalGeometryValue]];
+  [self writeShadow:_requestedShadow
+            geometry:[self canonicalGeometryValue]];
+  [self syncVisibilityForRect:_canonicalClip];
   smoothclip::viewAnimationDidStop(
       driverId, animationId, self, finished);
 }
@@ -834,19 +1487,40 @@ static std::array<double, 7> 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;
-  const smoothclip::Presentation initial{
-      {newProps.initialClipX,
-       newProps.initialClipY,
-       newProps.initialClipWidth,
-       newProps.initialClipHeight,
-       newProps.initialClipRadius},
-      newProps.initialContentTranslateX,
-      newProps.initialContentTranslateY};
+  smoothclip::Presentation initial{};
+  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;
+  }
 
   if (nextDriverId != _driverId) {
     if (_driverId != 0) {
@@ -872,160 +1546,95 @@ static std::array<double, 7> SmoothClipVelocityChannels(
 
 - (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
              oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
-  CGFloat visibleRadius = 0;
-  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};
-  const CGRect visibleRect = CGRectMake(
-      visible.clip.x,
-      visible.clip.y,
-      visible.clip.width,
-      visible.clip.height);
-  visibleRadius = visible.clip.radius;
-  const CGPoint visibleContentTranslation = CGPointMake(
-      visible.contentTranslateX,
-      visible.contentTranslateY);
-  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;
-    SmoothClipNormalizeGeometry(
-        CGRectGetMinX(visibleRect),
-        CGRectGetMinY(visibleRect),
-        CGRectGetWidth(visibleRect),
-        CGRectGetHeight(visibleRect),
-        visibleRadius,
-        self.bounds.size,
-        &current);
-    SmoothNormalizedClipGeometry target;
-    if ([self normalizedRequestedGeometry:&target]) {
-      [self installAnimationFromRect:current.rect
-                          fromRadius:current.radius
-              fromContentTranslation:visibleContentTranslation
-                              toRect:target.rect
-                            toRadius:target.radius
-                toContentTranslation:_requestedContentTranslation
-                            duration:remaining];
-    }
-  } 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;
-  CGFloat radius = 0;
+  SmoothClipCornerRadii radii = _canonicalRadii;
   const CGRect clip = _activeAnimationId != 0
-      ? [self presentationRectWithRadius:&radius]
-      : _normalizedClip;
-  if (_activeAnimationId == 0) radius = _normalizedRadius;
+      ? [self presentationRectWithRadii:&radii]
+      : _canonicalClip;
   if (CGRectIsEmpty(clip) || !CGRectContainsPoint(clip, point)) return NO;
-  if (radius <= 0) return YES;
-
-  const CGFloat innerLeft = CGRectGetMinX(clip) + radius;
-  const CGFloat innerRight = CGRectGetMaxX(clip) - radius;
-  const CGFloat innerTop = CGRectGetMinY(clip) + radius;
-  const CGFloat innerBottom = CGRectGetMaxY(clip) - radius;
-  if ((point.x >= innerLeft && point.x <= innerRight) ||
-      (point.y >= innerTop && point.y <= innerBottom)) {
-    return YES;
+  CGPathRef path = nil;
+  if (_clipContainer.layer.mask == _unequalCornerMask) {
+    CAShapeLayer *mask = _activeAnimationId != 0
+        ? (CAShapeLayer *)_unequalCornerMask.presentationLayer
+        : _unequalCornerMask;
+    if (mask == nil) mask = _unequalCornerMask;
+    path = mask.path;
+    return path != nil && CGPathContainsPoint(path, NULL, point, NO);
   }
-
-  const CGFloat centerX = point.x < innerLeft ? innerLeft : innerRight;
-  const CGFloat centerY = point.y < innerTop ? innerTop : innerBottom;
-  const CGFloat dx = point.x - centerX;
-  const CGFloat dy = point.y - centerY;
-  return dx * dx + dy * dy <= radius * radius;
+  path = SmoothClipCreateRoundedRectPath(clip, radii, _canonicalCurve);
+  const BOOL contains = CGPathContainsPoint(path, NULL, point, NO);
+  CGPathRelease(path);
+  return contains;
 }
 
-#pragma mark - Legacy native command (Android parity and benchmark baseline)
+#pragma mark - Native commands
 
 - (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
   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 {
+                            y:(double)y
+                        width:(double)width
+                       height:(double)height
+                topLeftRadius:(double)topLeftRadius
+               topRightRadius:(double)topRightRadius
+            bottomRightRadius:(double)bottomRightRadius
+             bottomLeftRadius:(double)bottomLeftRadius
+                    curveCode:(NSInteger)curveCode
+            contentTranslateX:(double)contentTranslateX
+            contentTranslateY:(double)contentTranslateY
+                 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 (!SmoothClipBuildPresentation(
+          x,
+          y,
+          width,
+          height,
+          topLeftRadius,
+          topRightRadius,
+          bottomRightRadius,
+          bottomLeftRadius,
+          curveCode,
+          contentTranslateX,
+          contentTranslateY,
+          contentScale,
+          shadowEnabled,
+          shadowRed,
+          shadowGreen,
+          shadowBlue,
+          shadowAlpha,
+          shadowOffsetX,
+          shadowOffsetY,
+          shadowBlurRadius,
+          shadowSpreadDistance,
+          &presentation)) {
+    return;
+  }
   _commandIsAuthoritative = YES;
-  [self smoothClipApplyPresentation:
-      {{x, y, width, height, radius},
-       contentTranslateX,
-       contentTranslateY}];
+  [self smoothClipApplyPresentation:presentation];
 }
 
 - (void)prepareForRecycle {
@@ -1034,15 +1643,24 @@ static std::array<double, 7> 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};
+  _canonicalRadii = {0, 0, 0, 0};
+  _requestedCurve = SmoothClipCornerCurveCircular;
+  _canonicalCurve = SmoothClipCornerCurveCircular;
+  _requestedHasExplicitRadii = NO;
+  _canonicalHasExplicitRadii = NO;
   _requestedContentTranslation = CGPointZero;
-  _normalizedContentTranslation = CGPointZero;
+  _canonicalContentTranslation = CGPointZero;
+  _requestedContentScale = 1;
+  _canonicalContentScale = 1;
+  _requestedShadow = {};
+  _canonicalShadow = {};
   _hasLayout = NO;
   _commandIsAuthoritative = NO;
 
@@ -1050,7 +1668,14 @@ static std::array<double, 7> SmoothClipVelocityChannels(
   layer.bounds = CGRectZero;
   layer.position = CGPointZero;
   layer.cornerRadius = 0;
+  layer.cornerCurve = kCACornerCurveCircular;
+  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];
 }