@lodev09/react-native-true-sheet 4.0.0-beta.0 → 4.0.0-beta.2

package/ios/TrueSheetViewController.mm

@@ -7,200 +7,642 @@
 //
 
 #import "TrueSheetViewController.h"
+#import "TrueSheetContainerView.h"
+#import "TrueSheetContentView.h"
+#import "core/TrueSheetBlurView.h"
+#import "core/TrueSheetDetentCalculator.h"
+#import "core/TrueSheetGrabberView.h"
+#import "utils/BlurUtil.h"
+#import "utils/GestureUtil.h"
+#import "utils/PlatformUtil.h"
 #import "utils/WindowUtil.h"
 
 #import <React/RCTLog.h>
 #import <React/RCTScrollViewComponentView.h>
-#import "TrueSheetContentView.h"
-#import "utils/GestureUtil.h"
+#import <objc/runtime.h>
+#import <react/renderer/components/TrueSheetSpec/Props.h>
+
+using namespace facebook::react;
+
+typedef struct {
+  CGFloat position;
+  CGFloat detent;
+  CGFloat index;
+} TrueSheetPositionState;
+
+static BOOL TrueSheetPositionStateEquals(TrueSheetPositionState a, TrueSheetPositionState b) {
+  return fabs(a.position - b.position) <= 0.01 && fabs(a.detent - b.detent) <= 0.01 && fabs(a.index - b.index) <= 0.01;
+}
+
+static char TrueSheetAccessibilityWindowOwnerKey;
+static char TrueSheetAccessibilityWindowPreviousElementsKey;
 
 @interface TrueSheetViewController ()
 
+- (UIViewController *)accessibilityPresentingViewController;
+- (void)setupTransitionTracker;
+- (void)settleAtDetentIndex:(NSInteger)index debug:(NSString *)debug;
+- (void)restoreWindowAccessibilityElements;
+- (void)setSheetAccessibilityElementsHidden:(BOOL)hidden;
+- (void)setAccessibilityContentElement:(UIView *)contentView;
+- (void)endInteractiveDismissState;
+- (void)animateInteractiveContainerToTransform:(CGAffineTransform)transform
+                                      duration:(NSTimeInterval)duration
+                          allowUserInteraction:(BOOL)allowUserInteraction
+                                    completion:(void (^)(void))completion;
+
 @end
 
 @implementation TrueSheetViewController {
-  CGFloat _lastPosition;
-  CGFloat _lastTransitionPosition;
-  UIVisualEffectView *_backgroundView;
-  CGFloat _bottomInset;
+  TrueSheetPositionState _lastEmittedPositionState;
+  CGSize _lastReportedSize;
+  CGFloat _autoDetentHeight;
+  CGFloat _peekDetentHeight;
+  NSInteger _pendingDetentIndex;
+
+  // Present/dismiss tracking: a display link scoped to the transition
+  // coordinator — started alongside the transition, stopped in its completion.
+  CADisplayLink *_transitionLink;
   BOOL _isTransitioning;
+
+  BOOL _pendingContentSizeChange;
+  BOOL _pendingDetentsChange;
   BOOL _isDragging;
-  BOOL _isTrackingPositionFromLayout;
-  UIView *_fakeTransitionView;
-  CADisplayLink *_displayLink;
+  BOOL _isWillDismissEmitted;
+
+  BOOL _isInteractiveDismiss;
+  CGFloat _interactiveStartPosition;
+  UIView *_interactiveContainerView;
+  NSUInteger _interactiveGeneration;
+  CADisplayLink *_interactivePositionLink;
+
+  __weak TrueSheetViewController *_parentSheetController;
+
+  UIView *_anchorView;
+
+  __weak UIWindow *_accessibilityWindow;
+
+  TrueSheetBlurView *_blurView;
+  TrueSheetGrabberView *_grabberView;
+  TrueSheetDetentCalculator *_detentCalculator;
 }
 
+#pragma mark - Initialization
+
 - (instancetype)init {
   if (self = [super initWithNibName:nil bundle:nil]) {
     _detents = @[ @0.5, @1 ];
     _contentHeight = @(0);
+    _headerHeight = @(0);
+    _footerHeight = @(0);
+    _peekContentHeight = @(0);
     _grabber = YES;
+    _draggable = YES;
+    _scrollingExpandsSheet = YES;
+    _dismissible = YES;
     _dimmed = YES;
-    _dimmedIndex = @(0);
-    _lastPosition = 0;
-    _lastTransitionPosition = 0;
-    _isTransitioning = NO;
+    _dimmedDetentIndex = @(0);
+    _presentation = facebook::react::TrueSheetViewPresentation::Page;
+    _lastEmittedPositionState = (TrueSheetPositionState){0, 0, 0};
     _isDragging = NO;
-    _isTrackingPositionFromLayout = NO;
-    _layoutTransitioning = NO;
     _isPresented = NO;
+    _isWillDismissEmitted = NO;
+    _isTransitioning = NO;
+    _pendingContentSizeChange = NO;
+    _pendingDetentsChange = NO;
     _activeDetentIndex = -1;
+    _pendingDetentIndex = -1;
 
-    _backgroundView = [[UIVisualEffectView alloc] init];
-    _backgroundView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-
-    // Initialize fake transition view for tracking position during animations
-    _fakeTransitionView = [[UIView alloc] init];
-    _fakeTransitionView.hidden = YES;
-    _fakeTransitionView.userInteractionEnabled = NO;
-
-    // Get bottom safe area inset from the window's safe area
-    // The sheet's view has smaller insets, so we need the actual device insets
-    UIWindow *window = [WindowUtil keyWindow];
-    _bottomInset = window ? window.safeAreaInsets.bottom : 0;
+    _blurInteraction = YES;
+    _insetAdjustment = TrueSheetViewInsetAdjustment::Automatic;
+    _detentCalculator = [[TrueSheetDetentCalculator alloc] init];
+    _detentCalculator.delegate = self;
   }
   return self;
 }
 
 - (void)dealloc {
+  [self restoreWindowAccessibilityElements];
+  [_transitionLink invalidate];
+  _transitionLink = nil;
+  [_interactivePositionLink invalidate];
+  _interactivePositionLink = nil;
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
-#pragma mark - Presentation State
+#pragma mark - Computed Properties
+
+- (UISheetPresentationController *)sheet {
+  return self.sheetPresentationController;
+}
 
 - (BOOL)isTopmostPresentedController {
-  // Check if we're in the window hierarchy and visible
   if (!self.isViewLoaded || self.view.window == nil) {
     return NO;
   }
-
-  // Check if another controller is presented on top of this sheet
   return self.presentedViewController == nil;
 }
 
-- (BOOL)isActiveAndVisible {
-  return self.isViewLoaded && self.view.window != nil && !self.isBeingDismissed;
+// YES while a child controller is stacked on top (e.g. a nested sheet) —
+// UIKit's push-back scaling mutates the frame while the sheet is backgrounded.
+- (BOOL)isStackedBehindChild {
+  UIViewController *presented = self.presentedViewController;
+  return presented != nil && !presented.isBeingDismissed;
 }
 
 - (UIView *)presentedView {
-  return self.sheetPresentationController.presentedView;
+  return self.sheet.presentedView;
+}
+
+- (CGFloat)currentPosition {
+  UIView *presentedView = self.presentedView;
+  return presentedView ? presentedView.frame.origin.y : 0.0;
+}
+
+// YES when any layer from the presented view up to the window has in-flight
+// animations (detent snap, present/dismiss transition, container settle).
+- (BOOL)isPresentedViewAnimating {
+  for (CALayer *layer = self.presentedView.layer; layer; layer = layer.superlayer) {
+    if (layer.animationKeys.count > 0) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+/**
+ * The sheet's live on-screen position. At rest and during drags (direct frame
+ * sets) this is the model position; during animations it adds the
+ * presentation-vs-model delta measured in window space, so ancestor animations
+ * compose and persistent transforms (e.g. floating-sheet inset) cancel out.
+ */
+- (CGFloat)livePosition {
+  UIView *presentedView = self.presentedView;
+  UIWindow *window = presentedView.window;
+  UIView *containerView = self.sheet.containerView;
+
+  // Direct (non-animated) translation applied during an interactive nav dismiss.
+  CGFloat containerTy = containerView ? containerView.transform.ty : 0;
+
+  if (!presentedView || !window || !self.isPresentedViewAnimating) {
+    return self.currentPosition + containerTy;
+  }
+
+  CALayer *modelLayer = presentedView.layer;
+  CALayer *presentationLayer = modelLayer.presentationLayer;
+  CALayer *rootModel = window.layer;
+  CALayer *rootPresentation = rootModel.presentationLayer;
+  if (!presentationLayer || !rootPresentation) {
+    return self.currentPosition + containerTy;
+  }
+
+  CGFloat modelY = [modelLayer convertPoint:CGPointZero toLayer:rootModel].y;
+  CGFloat presentationY = [presentationLayer convertPoint:CGPointZero toLayer:rootPresentation].y;
+  return self.currentPosition + (presentationY - modelY) + containerTy;
+}
+
+- (CGFloat)screenHeight {
+  UIWindow *window = self.view.window;
+  return window ? window.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
+}
+
+- (CGFloat)detentBottomAdjustmentForHeight:(CGFloat)height {
+  if (_insetAdjustment == TrueSheetViewInsetAdjustment::Automatic) {
+    return 0;
+  }
+
+  return [self bottomSafeAreaForHeight:height];
+}
+
+- (CGFloat)bottomSafeAreaForHeight:(CGFloat)height {
+  if (UIDevice.currentDevice.userInterfaceIdiom != UIUserInterfaceIdiomPhone) {
+    return 0;
+  }
+
+  // On iOS 26+, returns 0 for small detents (height <= 150)
+  // Floating sheets don't need adjustment
+  if (@available(iOS 26.0, *)) {
+    if (height <= 150) {
+      return 0;
+    }
+  }
+
+  UIWindow *window = [WindowUtil keyWindow];
+  return window ? window.safeAreaInsets.bottom : 0;
+}
+
+/**
+ * Bottom inset excluded from the auto detent. A relative footer owns the
+ * sheet's bottom edge, so it absorbs the inset — UIKit lays custom detents out
+ * above the safe area, which would otherwise gap the content from the footer.
+ */
+- (CGFloat)autoDetentBottomInsetForHeight:(CGFloat)height {
+  if (_insetAdjustment != TrueSheetViewInsetAdjustment::Automatic) {
+    // 'none' already excludes the inset for every detent
+    return 0;
+  }
+
+  if (_absoluteFooter || [self.footerHeight floatValue] <= 0) {
+    return 0;
+  }
+
+  return [self bottomSafeAreaForHeight:height];
+}
+
+// The inset the footer absorbs as padding. Uses the auto detent height when
+// available so it matches the auto detent's inset exclusion above.
+- (CGFloat)footerBottomInset {
+  if (_insetAdjustment != TrueSheetViewInsetAdjustment::Automatic) {
+    return 0;
+  }
+
+  return [self bottomSafeAreaForHeight:_autoDetentHeight > 0 ? _autoDetentHeight : self.screenHeight];
+}
+
+/**
+ * Bottom inset excluded from the peek detent. An absolute footer counts
+ * toward the peek height and absorbs the inset as padding, but UIKit already
+ * lays custom detents out above the safe area — subtract it so the inset
+ * isn't doubled.
+ */
+- (CGFloat)peekDetentBottomInsetForHeight:(CGFloat)height {
+  if (_insetAdjustment != TrueSheetViewInsetAdjustment::Automatic) {
+    return 0;
+  }
+
+  if (!_absoluteFooter || [self.footerHeight floatValue] <= 0) {
+    return 0;
+  }
+
+  return [self bottomSafeAreaForHeight:height];
+}
+
+- (BOOL)isDesignCompatibilityMode {
+  if (@available(iOS 26.0, *)) {
+    NSNumber *value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIDesignRequiresCompatibility"];
+    return value.boolValue;
+  }
+  return NO;
+}
+
+- (NSInteger)currentDetentIndex {
+  UISheetPresentationController *sheet = self.sheet;
+  if (!sheet)
+    return -1;
+
+  UISheetPresentationControllerDetentIdentifier selectedIdentifier = sheet.selectedDetentIdentifier;
+  if (!selectedIdentifier)
+    return -1;
+
+  NSArray<UISheetPresentationControllerDetent *> *detents = sheet.detents;
+  for (NSInteger i = 0; i < detents.count; i++) {
+    if (@available(iOS 16.0, *)) {
+      if ([detents[i].identifier isEqualToString:selectedIdentifier]) {
+        return i;
+      }
+    } else {
+      if ([selectedIdentifier isEqualToString:UISheetPresentationControllerDetentIdentifierMedium]) {
+        return 0;
+      } else if ([selectedIdentifier isEqualToString:UISheetPresentationControllerDetentIdentifierLarge]) {
+        return detents.count - 1;
+      }
+    }
+  }
+
+  return -1;
 }
 
+#pragma mark - View Lifecycle
+
 - (void)viewDidLoad {
   [super viewDidLoad];
-
   self.view.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
-  _backgroundView.frame = self.view.bounds;
-  [self.view insertSubview:self->_backgroundView atIndex:0];
+
+  _blurView = [[TrueSheetBlurView alloc] init];
+  [_blurView addToView:self.view];
+
+  _grabberView = [[TrueSheetGrabberView alloc] init];
+  _grabberView.hidden = YES;
+  [_grabberView addToView:self.view];
 }
 
 - (void)viewWillAppear:(BOOL)animated {
   [super viewWillAppear:animated];
 
-  // Only trigger willPresent on the initial presentation, not on repositioning
+  _blurView.alpha = 1;
+
   if (!_isPresented) {
-    if ([self.delegate respondsToSelector:@selector(viewControllerWillPresent)]) {
-      [self.delegate viewControllerWillPresent];
+    UIViewController *presenter = self.presentingViewController;
+    if ([presenter isKindOfClass:[TrueSheetViewController class]]) {
+      _parentSheetController = (TrueSheetViewController *)presenter;
+      [_parentSheetController.delegate viewControllerWillBlur];
+      [_parentSheetController setAccessibilityContentElement:self.accessibilityContentView ?: self.view];
     }
 
-    // Setup transition position tracking
-    [self setupTransitionPositionTracking];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      NSInteger index = self.currentDetentIndex;
+      CGFloat position = self.currentPosition;
+      CGFloat detent = [self detentValueForIndex:index];
+
+      [self.delegate viewControllerWillPresentAtIndex:index position:position detent:detent];
+      [self.delegate viewControllerWillFocus];
+    });
   }
+
+  [self setupTransitionTracker];
 }
 
 - (void)viewDidAppear:(BOOL)animated {
   [super viewDidAppear:animated];
+  [self setSheetAccessibilityElementsHidden:NO];
 
-  // Only trigger didPresent on the initial presentation, not on repositioning
   if (!_isPresented) {
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidPresent)]) {
-      [self.delegate viewControllerDidPresent];
-    }
+    [_parentSheetController.delegate viewControllerDidBlur];
 
-    // Setup gesture recognizer after view appears and React content is mounted
-    [self setupGestureRecognizer];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      NSInteger index = [self currentDetentIndex];
+      CGFloat detent = [self detentValueForIndex:index];
+      [self.delegate viewControllerDidPresentAtIndex:index position:self.currentPosition detent:detent];
+      [self.delegate viewControllerDidFocus];
 
+      [self->_grabberView updateAccessibilityValueWithIndex:index detentCount:self->_detents.count];
+      [self settleAtDetentIndex:index debug:@"did present"];
+    });
+
+    [self setupGestureRecognizer];
     _isPresented = YES;
   }
+
+  [self setupAccessibilityContainer];
 }
 
-- (void)viewWillDisappear:(BOOL)animated {
-  [super viewWillDisappear:animated];
+- (void)setupAccessibilityContainer {
+  UIView *contentView = self.accessibilityContentView;
+  if (!contentView) {
+    return;
+  }
+
+  [self setAccessibilityContentElement:contentView];
+}
+
+- (UIViewController *)accessibilityPresentingViewController {
+  UIViewController *presentingViewController = self.presentingViewController;
+  while ([presentingViewController isKindOfClass:[TrueSheetViewController class]] &&
+         presentingViewController.presentingViewController) {
+    presentingViewController = presentingViewController.presentingViewController;
+  }
+  return presentingViewController;
+}
+
+- (void)restoreWindowAccessibilityElements {
+  UIWindow *window = _accessibilityWindow;
+  if (window) {
+    // The active sheet may temporarily own window accessibility traversal. Only
+    // restore the previous value when this controller still owns that override.
+    NSValue *ownerValue = objc_getAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey);
+    if (ownerValue && ownerValue.nonretainedObjectValue == self) {
+      id previousElements = objc_getAssociatedObject(window, &TrueSheetAccessibilityWindowPreviousElementsKey);
+      window.accessibilityElements = previousElements == [NSNull null] ? nil : previousElements;
+      objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+      objc_setAssociatedObject(
+        window, &TrueSheetAccessibilityWindowPreviousElementsKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+
+    _accessibilityWindow = nil;
+  }
+}
+
+- (void)setSheetAccessibilityElementsHidden:(BOOL)hidden {
+  self.view.accessibilityElementsHidden = hidden;
+
+  UIView *presentedView = self.presentationController.presentedView;
+  if (presentedView) {
+    presentedView.accessibilityElementsHidden = hidden;
+  }
+}
+
+- (void)setAccessibilityContentElement:(UIView *)contentView {
+  BOOL hasAccessibilityFooterElements = [contentView isKindOfClass:[TrueSheetContainerView class]] &&
+                                        [(TrueSheetContainerView *)contentView hasAccessibilityFooterElements];
+  // Footer controls exposed as separate accessibility elements can be skipped
+  // by XCTest when the presented sheet is a hard modal accessibility boundary.
+  BOOL isAccessibilityModal = _dimmed && !hasAccessibilityFooterElements;
+
+  // At a hard modal boundary XCTest skips nested elements, so flatten the
+  // container's children into the array. Otherwise expose the container itself:
+  // its accessibilityElements getter recomputes live, so a footer/content subtree
+  // that remounts (e.g. swapping a footer button on a state change) stays
+  // discoverable instead of leaving this snapshot pointing at destroyed views.
+  NSArray *accessibilityElements;
+  if (isAccessibilityModal) {
+    NSArray *contentElements = contentView.accessibilityElements;
+    accessibilityElements = contentElements.count > 0 ? contentElements : @[ contentView ];
+  } else {
+    accessibilityElements = @[ contentView ];
+  }
+
+  self.view.isAccessibilityElement = NO;
+  self.view.accessibilityViewIsModal = YES;
+  self.view.accessibilityElements = accessibilityElements;
+
+  UIView *presentedView = self.presentationController.presentedView;
+  if (presentedView) {
+    presentedView.isAccessibilityElement = NO;
+    presentedView.accessibilityViewIsModal = isAccessibilityModal;
+    presentedView.accessibilityElements = accessibilityElements;
+
+    UIWindow *window = self.view.window;
+    UIViewController *presentingViewController = [self accessibilityPresentingViewController];
+    if (window && presentingViewController.view) {
+      if (!_accessibilityWindow) {
+        _accessibilityWindow = window;
+        id previousElements = objc_getAssociatedObject(window, &TrueSheetAccessibilityWindowPreviousElementsKey);
+        if (!previousElements) {
+          previousElements = window.accessibilityElements ?: [NSNull null];
+          objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowPreviousElementsKey, previousElements,
+            OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+        }
+      }
+      objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey, [NSValue valueWithNonretainedObject:self],
+        OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+      window.accessibilityElements =
+        isAccessibilityModal ? @[ presentedView ] : @[ presentingViewController.view, presentedView ];
+      return;
+    }
+  }
+
+  [self restoreWindowAccessibilityElements];
+}
+
+#pragma mark - Presentation
+
+- (void)presentViewController:(UIViewController *)viewControllerToPresent
+                     animated:(BOOL)flag
+                   completion:(void (^)(void))completion {
+  // A non-sheet controller (e.g. an action sheet, alert, or image picker) is about
+  // to present over us. Clear our window accessibility override so UIKit's default
+  // traversal surfaces it for XCTest and assistive technologies; we reclaim the
+  // override when it dismisses. Nested sheets claim their own override.
+  if (![viewControllerToPresent isKindOfClass:[TrueSheetViewController class]]) {
+    self.view.window.accessibilityElements = nil;
+  }
+
+  [super presentViewController:viewControllerToPresent animated:flag completion:completion];
+}
+
+- (void)dismissViewControllerAnimated:(BOOL)flag completion:(void (^)(void))completion {
+  [super dismissViewControllerAnimated:flag
+                            completion:^{
+                              if (completion) {
+                                completion();
+                              }
+
+                              // Reclaim the window accessibility override once nothing
+                              // else is presented over us.
+                              if (self.isPresented && self.presentedViewController == nil) {
+                                [self setupAccessibilityContainer];
+                              }
+                            }];
+}
+
+- (void)emitWillDismissEvents {
+  if (self.isBeingDismissed && !_isWillDismissEmitted) {
+    _isWillDismissEmitted = YES;
 
-  if ([self.delegate respondsToSelector:@selector(viewControllerWillDismiss)]) {
+    [self.delegate viewControllerWillBlur];
     [self.delegate viewControllerWillDismiss];
+    [_parentSheetController.delegate viewControllerWillFocus];
   }
+}
+
+- (void)emitDidDismissEvents {
+  if (self.isBeingDismissed) {
+    [self restoreWindowAccessibilityElements];
+    _isPresented = NO;
+    _isWillDismissEmitted = NO;
+
+    [_anchorView removeFromSuperview];
+    _anchorView = nil;
 
-  [self setupTransitionPositionTracking];
-  _isTrackingPositionFromLayout = NO;
+    [_parentSheetController.delegate viewControllerDidFocus];
+    [_parentSheetController setSheetAccessibilityElementsHidden:NO];
+    [_parentSheetController setupAccessibilityContainer];
+    _parentSheetController = nil;
+
+    [self.delegate viewControllerDidBlur];
+    [self.delegate viewControllerDidDismiss];
+  }
+}
+
+- (void)viewWillDisappear:(BOOL)animated {
+  [super viewWillDisappear:animated];
+  [self restoreWindowAccessibilityElements];
+  [self setSheetAccessibilityElementsHidden:YES];
+
+  // Dispatch to allow pan gesture to set _isDragging before checking;
+  // the transition tracker emits when the sheet is transitioning to dismiss
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (!self->_isDragging) {
+      [self emitWillDismissEvents];
+    }
+  });
+
+  [self setupTransitionTracker];
 }
 
 - (void)viewDidDisappear:(BOOL)animated {
   [super viewDidDisappear:animated];
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidDismiss)]) {
-    [self.delegate viewControllerDidDismiss];
+
+  // Backstop: if the sheet is torn down mid-gesture (e.g. owning view deallocated),
+  // the observer can't reach us through its weak delegate, so end here to invalidate
+  // _interactivePositionLink — which otherwise retains this controller indefinitely.
+  if (_isInteractiveDismiss) {
+    [self endInteractiveDismissState];
   }
 
-  _isTrackingPositionFromLayout = NO;
-  _isPresented = NO;
-  _activeDetentIndex = -1;
+  // Dismissing with the keyboard up skips the hide notification — don't let
+  // the stale flag block learning on the next present.
+  _keyboardSheetGrown = NO;
+
+  [self emitDidDismissEvents];
 }
 
-- (void)viewWillTransitionToSize:(CGSize)size
-       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
-  [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+- (void)viewWillLayoutSubviews {
+  [super viewWillLayoutSubviews];
 
-  // Handle rotation/size change
-  [coordinator
-    animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
-      // Animation block - updates happen here
-    }
-    completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
-      // After rotation completes
-      [self setupSheetDetents];
+  // Skip during transitions and nav swipes — their trackers own position then.
+  if (_isTransitioning || _isInteractiveDismiss) {
+    return;
+  }
 
-      // Notify delegate of size changes
-      if ([self.delegate respondsToSelector:@selector(viewControllerDidChangeSize:)]) {
-        [self.delegate viewControllerDidChangeSize:self.view.frame.size];
+  if (_pendingContentSizeChange || _pendingDetentsChange) {
+    _pendingContentSizeChange = NO;
+    _pendingDetentsChange = NO;
+    [self settleAtDetentIndex:self.currentDetentIndex debug:@"layout"];
+  } else if (!_isDragging) {
+    // Drags emit from the pan handler. A child on top moves this sheet two
+    // ways: an animated collapse/restore step (presenting/dismissing) — emit
+    // the target non-realtime so JS animates to it — or direct per-frame
+    // re-layouts while the child drags, which stay realtime.
+    BOOL realtime = self.presentedViewController == nil || !self.isPresentedViewAnimating;
+
+    // A layout pass at rest can nudge the frame by a sub-pixel amount
+    // (pixel-grid snapping after present), leaving the interpolated index
+    // slightly off the whole number. Re-learn when the frame is effectively
+    // at the current detent so the drift is absorbed instead of emitted.
+    // The tight threshold keeps real movement (e.g. scroll-driven expansion)
+    // from being absorbed.
+    if (self.presentedViewController == nil && !self.isPresentedViewAnimating) {
+      NSInteger index = self.currentDetentIndex;
+      CGFloat expectedHeight = [_detentCalculator resolvedHeightForIndex:index];
+      CGFloat actualHeight = self.screenHeight - self.currentPosition;
+      if (expectedHeight > 0 && fabs(actualHeight - expectedHeight) < 2) {
+        [self learnOffsetForDetentIndex:index];
       }
-    }];
+    }
+
+    [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:realtime debug:@"layout"];
+  }
 }
 
 - (void)viewDidLayoutSubviews {
   [super viewDidLayoutSubviews];
-  if (!_isTransitioning && self.isActiveAndVisible) {
-    // Flag that we are tracking position from layout
-    _isTrackingPositionFromLayout = YES;
-
-    // If another controller is presented on top, treat position changes as transitioning
-    // This prevents incorrect position notifications when overlays adjust our size
-    [self emitChangePositionDelegateWithPosition:self.currentPosition
-                                   transitioning:_layoutTransitioning || !self.isTopmostPresentedController];
-
-    // On IOS 26, this is called twice when we have a ScrollView
-    // Schedule flag reset after animation to avoid race condition
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
-      // Reset layout transitioning after sending notification
-      self->_layoutTransitioning = NO;
+
+  // Skip size reports while backgrounded behind a stacked child — the push-back
+  // scaling changes the frame and would needlessly resize content.
+  // _lastReportedSize stays stale so the restore pass re-reports any real change.
+  if (!self.isStackedBehindChild) {
+    // Report any size change (detent resize, keyboard, rotation) so Yoga
+    // relayouts the container synchronously with the sheet.
+    CGSize size = self.view.frame.size;
+    if (!CGSizeEqualToSize(_lastReportedSize, size)) {
+      _lastReportedSize = size;
+      [self.delegate viewControllerDidChangeSize:size];
+    }
+  }
+
+  if (_pendingDetentIndex >= 0) {
+    NSInteger pendingIndex = _pendingDetentIndex;
+    _pendingDetentIndex = -1;
+
+    // The presentedView frame isn't final until UIKit finishes the resize
+    // animation — no completion hook exists for it, hence the delay.
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+      CGFloat detent = [self detentValueForIndex:pendingIndex];
+      [self.delegate viewControllerDidChangeDetent:pendingIndex position:self.currentPosition detent:detent];
+      [self->_grabberView updateAccessibilityValueWithIndex:pendingIndex detentCount:self->_detents.count];
+      [self settleAtDetentIndex:pendingIndex debug:@"pending detent change"];
     });
   }
 }
 
-#pragma mark - Gesture Handling
+#pragma mark - Position & Gesture Handling
 
-/**
- * Finds the TrueSheetContentView in the hierarchy.
- *
- * @param view The presentedView to start searching from
- * @return The TrueSheetContentView found, or nil
- */
 - (TrueSheetContentView *)findContentView:(UIView *)view {
-  // Check if this view itself is TrueSheetContentView
   if ([view isKindOfClass:[TrueSheetContentView class]]) {
     return (TrueSheetContentView *)view;
   }
 
-  // Recursively search all subviews
   for (UIView *subview in view.subviews) {
     TrueSheetContentView *found = [self findContentView:subview];
     if (found) {
@@ -216,44 +658,60 @@
   if (!presentedView)
     return;
 
-  // Attach to presented view's pan gestures (sheet's own drag gesture from UIKit)
+  if (!self.draggable) {
+    [GestureUtil setPanGesturesEnabled:NO forView:presentedView];
+    return;
+  }
+
   [GestureUtil attachPanGestureHandler:presentedView target:self selector:@selector(handlePanGesture:)];
 
-  // Find and attach to the first ScrollView's pan gesture in the view hierarchy
-  // This handles cases where the sheet content includes a ScrollView
   TrueSheetContentView *contentView = [self findContentView:presentedView];
   if (contentView) {
     RCTScrollViewComponentView *scrollViewComponent = [contentView findScrollView];
-    if (scrollViewComponent) {
-      // Access the internal UIScrollView via the scrollView property
-      UIScrollView *scrollView = scrollViewComponent.scrollView;
-      if (scrollView) {
-        [GestureUtil attachPanGestureHandler:scrollView target:self selector:@selector(handlePanGesture:)];
-      }
+    if (scrollViewComponent && scrollViewComponent.scrollView) {
+      [GestureUtil attachPanGestureHandler:scrollViewComponent.scrollView
+                                    target:self
+                                  selector:@selector(handlePanGesture:)];
     }
   }
 }
 
+- (void)setupDraggable {
+  UIView *presentedView = self.presentedView;
+  if (!presentedView)
+    return;
+
+  [GestureUtil setPanGesturesEnabled:self.draggable forView:presentedView];
+}
+
 - (void)handlePanGesture:(UIPanGestureRecognizer *)gesture {
-  NSInteger index = [self currentDetentIndex];
+  NSInteger index = self.currentDetentIndex;
+  CGFloat detent = [self detentValueForIndex:index];
 
-  if ([self.delegate respondsToSelector:@selector(viewControllerDidDrag:index:position:)]) {
-    [self.delegate viewControllerDidDrag:gesture.state index:index position:self.currentPosition];
-  }
+  [self.delegate viewControllerDidDrag:gesture.state index:index position:self.currentPosition detent:detent];
 
   switch (gesture.state) {
     case UIGestureRecognizerStateBegan:
       _isDragging = YES;
       break;
     case UIGestureRecognizerStateChanged:
-      if (!_isTrackingPositionFromLayout)
-        [self emitChangePositionDelegateWithPosition:self.currentPosition transitioning:NO];
+      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:YES debug:@"drag change"];
       break;
     case UIGestureRecognizerStateEnded:
-    case UIGestureRecognizerStateCancelled:
+    case UIGestureRecognizerStateCancelled: {
+      if (!_isTransitioning) {
+        // Dispatch so UIKit picks the target detent first; the settle emit is
+        // non-realtime and JS animates alongside UIKit's snap spring.
+        dispatch_async(dispatch_get_main_queue(), ^{
+          NSInteger endIndex = self.currentDetentIndex;
+          [self->_grabberView updateAccessibilityValueWithIndex:endIndex detentCount:self->_detents.count];
+          [self settleAtDetentIndex:endIndex debug:@"drag end"];
+        });
+      }
+
       _isDragging = NO;
       break;
-
+    }
     default:
       break;
   }
@@ -262,165 +720,337 @@
 #pragma mark - Position Tracking
 
 /**
- * Emits position change to the delegate if the position has changed.
- * @param transitioning Whether the position change is part of a transition animation
+ * Tracks the sheet's live position through a present/dismiss transition. The
+ * link's lifetime is scoped to the transition coordinator: started alongside
+ * the transition, stopped in its completion — which fires for finished and
+ * cancelled (interactive) transitions alike.
  */
-- (void)emitChangePositionDelegateWithPosition:(CGFloat)position transitioning:(BOOL)transitioning {
-  if (_lastPosition != position) {
-    _lastPosition = position;
+- (void)setupTransitionTracker {
+  id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
 
-    // Emit position change delegate
-    NSInteger index = [self currentDetentIndex];
+  // A cancelled dismiss re-enters viewWillAppear with the same coordinator —
+  // the tracker from viewWillDisappear still owns it.
+  if (!coordinator || _isTransitioning) {
+    return;
+  }
+
+  _isTransitioning = YES;
 
-    if ([self.delegate respondsToSelector:@selector(viewControllerDidChangePosition:position:transitioning:)]) {
-      [self.delegate viewControllerDidChangePosition:index position:position transitioning:transitioning];
+  // Learn the resolver-vs-actual offset before emitting transition positions so
+  // the interpolated index lands exactly on the target detent. The presented
+  // frame is already final here (UIKit animates the layer, not the frame).
+  if (!self.isBeingDismissed) {
+    [self learnOffsetForDetentIndex:self.currentDetentIndex];
+  }
+
+  __weak __typeof(self) weakSelf = self;
+  [coordinator
+    animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+      __strong __typeof(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf)
+        return;
+
+      [strongSelf->_transitionLink invalidate];
+      strongSelf->_transitionLink = [CADisplayLink displayLinkWithTarget:strongSelf
+                                                                selector:@selector(handleTransitionTick)];
+      // Track at the display's native refresh rate — the default caps at 60Hz
+      // on ProMotion, dropping every other frame of a 120Hz animation.
+      strongSelf->_transitionLink.preferredFrameRateRange = CAFrameRateRangeMake(60, 120, 120);
+      [strongSelf->_transitionLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
     }
+    completion:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+      __strong __typeof(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf)
+        return;
+
+      [strongSelf->_transitionLink invalidate];
+      strongSelf->_transitionLink = nil;
+      strongSelf->_isTransitioning = NO;
+
+      // Settle after a present, cancelled dismiss, or detent-snap transition.
+      // Delayed because the presentedView frame isn't final until UIKit
+      // completes its layout pass after the transition animation — learning
+      // here absorbs any sub-pixel drift since the earlier learns.
+      if (strongSelf->_isPresented && !strongSelf.isBeingDismissed) {
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+          [strongSelf settleAtDetentIndex:strongSelf.currentDetentIndex debug:@"transition end"];
+        });
+      }
+    }];
+}
+
+- (void)handleTransitionTick {
+  // Interactive dismiss phase (finger down) — the pan handler emits.
+  if (!_isDragging) {
+    CGFloat position = self.livePosition;
+
+    if (self.isBeingDismissed) {
+      // Emit only once the dismiss is committed: on release UIKit moves the
+      // model frame off-screen, while a cancelled drag rewinds it back to the
+      // detent (isBeingDismissed stays YES during the rewind).
+      if (self.currentPosition >= self.screenHeight) {
+        [self emitWillDismissEvents];
+      }
+
+      // Hide blur at the end of dismiss to prevent UIVisualEffectView
+      // from causing a flicker/flash at the bottom edge of the sheet.
+      if (self.screenHeight - position < 1) {
+        _blurView.alpha = 0;
+      }
+    }
+
+    [self emitChangePositionDelegateWithPosition:position realtime:YES debug:@"transition"];
   }
 }
 
 /**
- * Sets up position tracking during view controller transitions using a fake view.
- *
- * This approach uses a hidden "fake" view added to the container that animates
- * alongside the actual presented view. By observing the presentation layer of this
- * fake view's frame, we can track smooth position changes during the native transition
- * animation without manually animating in JavaScript.
- *
- * The display link fires at screen refresh rate, allowing us to emit position updates
- * that match the native animation curve, providing smooth synchronized updates to JS.
+ * The sheet is at rest at a detent: learn the resolver-vs-actual offset and
+ * emit the settled position. Only valid when the presentedView frame is final
+ * — never mid-drag or mid-animation, where learning would store a bogus offset.
  */
-- (void)setupTransitionPositionTracking {
-  if (self.transitionCoordinator != nil) {
-    _isTransitioning = YES;
+- (void)settleAtDetentIndex:(NSInteger)index debug:(NSString *)debug {
+  // Don't learn while a child sits on top — the deck transform skews the
+  // measured frame; the next unobstructed settle learns.
+  if (self.presentedViewController == nil) {
+    [self learnOffsetForDetentIndex:index];
+  }
 
-    // Get the container view to add our fake transition view
-    UIView *containerView = self.sheetPresentationController.containerView;
-    UIView *presentedView = self.presentedView;
+  [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:debug];
+}
 
-    if (!containerView || !presentedView)
-      return;
+#pragma mark - Interactive Navigation Dismiss
 
-    CGRect frame = presentedView.frame;
+- (void)beginInteractiveDismiss {
+  if (_isInteractiveDismiss) {
+    // A settle animation from a prior gesture is still running. Stop it and reset so
+    // this gesture tracks from a clean state; its stale completion is ignored via the
+    // generation check in animateInteractiveContainerToTransform.
+    [_interactiveContainerView.layer removeAllAnimations];
+    [self endInteractiveDismissState];
+  }
 
-    // Determine if presenting or dismissing to set correct start position
-    BOOL isPresenting = self.isBeingPresented;
+  _interactiveGeneration += 1;
+  _isInteractiveDismiss = YES;
+  _interactiveStartPosition = self.currentPosition;
+  _interactiveContainerView = self.sheet.containerView;
 
-    // Set initial position based on transition type:
-    // - Presenting: Start from bottom (containerHeight) and animate up to detent
-    // - Dismissing: Start from current position and animate down to bottom
-    if (isPresenting) {
-      frame.origin.y = self.containerHeight;
-    } else {
-      frame.origin.y = presentedView.frame.origin.y;
-    }
+  // Emit position from the container's presentation layer for the whole gesture, so
+  // both the direct-set drag and the settle animation report a live, smooth position.
+  _interactivePositionLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(emitInteractivePosition)];
+  _interactivePositionLink.preferredFrameRateRange = CAFrameRateRangeMake(60, 120, 120);
+  [_interactivePositionLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+}
 
-    // Set fake view's initial frame before transition starts
-    _fakeTransitionView.frame = frame;
-
-    auto animation = ^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
-      // Add fake view to container so it participates in the transition
-      [[context containerView] addSubview:self->_fakeTransitionView];
-
-      // Animate fake view to the presented view's target position
-      // UIKit will animate this with the same timing curve as the sheet
-      CGRect finalFrame = presentedView.frame;
-      finalFrame.origin.y = presentedView.frame.origin.y;
-      self->_fakeTransitionView.frame = finalFrame;
-
-      // Set our last transition position so we can check if
-      // fake view's presentation layer has changed
-      // This value will not change if the sheet is being repositioned
-      // during a transition after a drag
-      self->_lastTransitionPosition = finalFrame.origin.y;
-
-      // Start display link to track position changes at screen refresh rate
-      // This fires at 60-120Hz and reads from the presentation layer
-      self->_displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(trackTransitionPosition:)];
-      [self->_displayLink addToRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
-    };
+- (void)emitInteractivePosition {
+  CALayer *presentation = _interactiveContainerView.layer.presentationLayer;
+  CGFloat offset = presentation ? presentation.affineTransform.ty : 0;
+  [self emitChangePositionDelegateWithPosition:_interactiveStartPosition + offset realtime:YES debug:@"nav swipe"];
+}
 
-    [self.transitionCoordinator
-      animateAlongsideTransition:animation
-                      completion:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
-                        // Clean up display link
-                        [self->_displayLink invalidate];
-                        self->_displayLink = nil;
+// Translate the presentation container, not the sheet's presentedView (whose transform
+// UISheetPresentationController owns for the floating-sheet inset). Only runs for undimmed
+// sheets — a dimmed sheet's dimming view intercepts the edge-swipe so the pop never starts.
+- (void)updateInteractiveDismiss:(CGFloat)progress {
+  if (!_isInteractiveDismiss) {
+    return;
+  }
+  CGFloat clamped = fmin(1, fmax(0, progress));
+  CGFloat dy = clamped * (self.screenHeight - _interactiveStartPosition);
+  _interactiveContainerView.transform = CGAffineTransformMakeTranslation(0, dy);
+}
 
-                        // Remove fake view from hierarchy
-                        [self->_fakeTransitionView removeFromSuperview];
-                        self->_isTransitioning = NO;
-                      }];
+- (void)cancelInteractiveDismissWithDuration:(NSTimeInterval)duration {
+  if (!_isInteractiveDismiss) {
+    return;
   }
+  [self animateInteractiveContainerToTransform:CGAffineTransformIdentity
+                                      duration:duration
+                          allowUserInteraction:YES
+                                    completion:nil];
 }
 
-- (void)trackTransitionPosition:(CADisplayLink *)displayLink {
-  UIView *presentedView = self.presentedView;
+- (void)finishInteractiveDismissWithDuration:(NSTimeInterval)duration completion:(void (^)(void))completion {
+  if (!_isInteractiveDismiss) {
+    if (completion) {
+      completion();
+    }
+    return;
+  }
+  // Leave the sheet translated off-screen; the caller tears it down non-animated
+  // from here so there is no second slide.
+  CGFloat dy = self.screenHeight - _interactiveStartPosition;
+  [self animateInteractiveContainerToTransform:CGAffineTransformMakeTranslation(0, dy)
+                                      duration:duration
+                          allowUserInteraction:NO
+                                    completion:completion];
+}
+
+- (void)animateInteractiveContainerToTransform:(CGAffineTransform)transform
+                                      duration:(NSTimeInterval)duration
+                          allowUserInteraction:(BOOL)allowUserInteraction
+                                    completion:(void (^)(void))completion {
+  UIView *container = _interactiveContainerView;
+  NSUInteger generation = _interactiveGeneration;
 
-  if (_isDragging || !_fakeTransitionView || !presentedView) {
+  UIViewAnimationOptions options = UIViewAnimationOptionCurveEaseOut | UIViewAnimationOptionBeginFromCurrentState;
+  if (allowUserInteraction) {
+    options |= UIViewAnimationOptionAllowUserInteraction;
+  }
+
+  [UIView animateWithDuration:fmax(duration, 0.2)
+    delay:0
+    options:options
+    animations:^{
+      container.transform = transform;
+    }
+    completion:^(BOOL finished) {
+      // A newer gesture superseded this settle and owns teardown now.
+      if (generation != self->_interactiveGeneration) {
+        return;
+      }
+      [self endInteractiveDismissState];
+      if (completion) {
+        completion();
+      }
+    }];
+}
+
+- (void)endInteractiveDismissState {
+  _isInteractiveDismiss = NO;
+  _interactiveContainerView = nil;
+  _interactiveStartPosition = 0;
+  [_interactivePositionLink invalidate];
+  _interactivePositionLink = nil;
+}
+
+- (void)emitChangePositionDelegateWithPosition:(CGFloat)position realtime:(BOOL)realtime debug:(NSString *)debug {
+  UIViewController *presented = self.presentedViewController;
+  if (presented) {
+    UIModalPresentationStyle style = presented.modalPresentationStyle;
+    if (style == UIModalPresentationFullScreen || style == UIModalPresentationOverFullScreen ||
+        style == UIModalPresentationCurrentContext || style == UIModalPresentationOverCurrentContext) {
+      return;
+    }
+  }
+
+  TrueSheetPositionState state = {
+    .position = position,
+    .detent = [self interpolatedDetentForPosition:position],
+    .index = [self interpolatedIndexForPosition:position],
+  };
+
+  // Settle (non-realtime) emits are authoritative and bypass the dedupe — a
+  // learn right before them can correct the interpolated index by less than
+  // the tolerance, and the corrected value must still reach JS.
+  if (!realtime || !TrueSheetPositionStateEquals(_lastEmittedPositionState, state)) {
+    _lastEmittedPositionState = state;
+
+    [self.delegate viewControllerDidChangePosition:state.index
+                                          position:state.position
+                                            detent:state.detent
+                                          realtime:realtime];
+  }
+}
+
+- (void)learnOffsetForDetentIndex:(NSInteger)index {
+  if (_keyboardSheetGrown) {
     return;
   }
+  [_detentCalculator learnOffsetForDetentIndex:index];
+}
 
-  // Get the presentation layer which contains the in-flight animated values
-  // Unlike the model layer (which has the final/target value), the presentation
-  // layer reflects the current state during animation
-  CALayer *presentationLayer = _fakeTransitionView.layer.presentationLayer;
+- (void)setKeyboardSheetGrown:(BOOL)keyboardSheetGrown {
+  BOOL wasGrown = _keyboardSheetGrown;
+  _keyboardSheetGrown = keyboardSheetGrown;
 
-  if (presentationLayer) {
-    BOOL transitioning = NO;
-    CGFloat position = presentationLayer.frame.origin.y;
+  // Settles are skipped or measure a mid-animation frame while the keyboard
+  // has the sheet grown (e.g. a drag-end during the shrink-back) — re-settle
+  // at the resting detent once the keyboard is fully away.
+  if (wasGrown && !keyboardSheetGrown && self.isPresented && !_isDragging) {
+    [self settleAtDetentIndex:self.currentDetentIndex debug:@"keyboard settled"];
+  }
+}
+
+- (BOOL)findSegmentForPosition:(CGFloat)position outIndex:(NSInteger *)outIndex outProgress:(CGFloat *)outProgress {
+  return [_detentCalculator findSegmentForPosition:position outIndex:outIndex outProgress:outProgress];
+}
 
-    // Our last transition position is nearly the same as fake view's layer position
-    // Sheet must've been repositioning after dragging at lowest detent
-    if (fabs(_lastTransitionPosition - position) < FLT_EPSILON) {
-      // Let's just flag it as transitioning to let JS manually animate
-      transitioning = YES;
+- (CGFloat)interpolatedIndexForPosition:(CGFloat)position {
+  return [_detentCalculator interpolatedIndexForPosition:position];
+}
 
-      // Use the target presented view's frame position to animate
-      position = presentedView.frame.origin.y;
-    } else {
-      // We are actually getting changes to our fake view's layer position
-      // Just update our last transition position
-      _lastTransitionPosition = position;
+- (CGFloat)interpolatedDetentForPosition:(CGFloat)position {
+  return [_detentCalculator interpolatedDetentForPosition:position];
+}
+
+- (CGFloat)detentValueForIndex:(NSInteger)index {
+  return [_detentCalculator detentValueForIndex:index];
+}
+
+#pragma mark - Sheet Configuration
+
+/**
+ * Applies a content/header/footer/peek size change to the already-built
+ * detents. Auto and peek detents resolve lazily from snapshots, so this only
+ * refreshes the snapshots and invalidates — never reassigns `sheet.detents`,
+ * which would force UIKit to re-layout the whole presentation stack (visibly
+ * perturbing a sheet behind this one).
+ */
+- (void)setupSheetDetentsForSizeChange {
+  if (@available(iOS 16.0, *)) {
+    CGFloat autoHeight = [_detentCalculator autoHeight];
+    CGFloat peekHeight = [_detentCalculator peekHeight];
+
+    if (fabs(autoHeight - _autoDetentHeight) < 0.5 && fabs(peekHeight - _peekDetentHeight) < 0.5) {
+      return;
     }
 
-    // Emit the current animated Y position to JS
-    // This provides smooth position updates that match the native animation curve
-    [self emitChangePositionDelegateWithPosition:position transitioning:transitioning];
+    _autoDetentHeight = autoHeight;
+    _peekDetentHeight = peekHeight;
+
+    [self.sheet animateChanges:^{
+      self->_pendingContentSizeChange = YES;
+      [self.sheet invalidateDetents];
+    }];
   }
+  // iOS 15: detents are fixed medium/large — size changes can't affect them.
 }
 
-#pragma mark - Sheet Configuration (iOS 15+)
+- (void)setupSheetDetentsForDetentsChange {
+  _pendingDetentsChange = YES;
+  [self setupSheetDetents];
+}
 
 - (void)setupSheetDetents {
-  UISheetPresentationController *sheet = self.sheetPresentationController;
-  if (!sheet)
+  UISheetPresentationController *sheet = self.sheet;
+  if (!sheet) {
+    RCTLogError(@"TrueSheet: sheetPresentationController is nil in setupSheetDetents");
     return;
+  }
 
   NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray array];
+  [_detentCalculator clearResolvedHeights];
 
-  // Subtract bottomInset from content height to account for safe area
-  // This prevents iOS from adding extra bottom insets automatically
-  CGFloat totalHeight = [self.contentHeight floatValue] - _bottomInset;
+  _autoDetentHeight = [_detentCalculator autoHeight];
+  _peekDetentHeight = [_detentCalculator peekHeight];
 
   for (NSInteger index = 0; index < self.detents.count; index++) {
     id detent = self.detents[index];
-    UISheetPresentationControllerDetent *sheetDetent = [self detentForValue:detent
-                                                                 withHeight:totalHeight
-                                                                    atIndex:index];
+    UISheetPresentationControllerDetent *sheetDetent = [self detentForValue:detent atIndex:index];
     [detents addObject:sheetDetent];
   }
 
+  [_detentCalculator setDetentCount:self.detents.count];
   sheet.detents = detents;
 
-  // Setup dimmed background
-  if (self.dimmed && [self.dimmedIndex integerValue] == 0) {
+  if (self.dimmed && [self.dimmedDetentIndex integerValue] == 0) {
     sheet.largestUndimmedDetentIdentifier = nil;
   } else {
     sheet.largestUndimmedDetentIdentifier = UISheetPresentationControllerDetentIdentifierLarge;
 
     if (@available(iOS 16.0, *)) {
-      if (self.dimmed && self.dimmedIndex) {
-        NSInteger dimmedIdx = [self.dimmedIndex integerValue];
+      if (self.dimmed && self.dimmedDetentIndex) {
+        NSInteger dimmedIdx = [self.dimmedDetentIndex integerValue];
         if (dimmedIdx > 0 && dimmedIdx - 1 < sheet.detents.count) {
           sheet.largestUndimmedDetentIdentifier = sheet.detents[dimmedIdx - 1].identifier;
         } else if (sheet.detents.lastObject) {
@@ -433,62 +1063,116 @@
   }
 }
 
-- (UISheetPresentationControllerDetent *)detentForValue:(id)detent withHeight:(CGFloat)height atIndex:(NSInteger)index {
+- (UISheetPresentationControllerDetent *)detentForValue:(id)detent atIndex:(NSInteger)index {
   if (![detent isKindOfClass:[NSNumber class]]) {
     return [UISheetPresentationControllerDetent mediumDetent];
   }
 
-  CGFloat value = [detent floatValue];
+  CGFloat value = [detent doubleValue];
 
-  // -1 represents "auto"
+  // Auto/peek resolve from height snapshots — refreshed only in
+  // setupSheetDetents and setupSheetDetentsForSizeChange — so size changes are
+  // picked up on invalidation, while UIKit's spontaneous re-resolutions (e.g.
+  // while a child sheet dismisses) read a stable value.
   if (value == -1) {
     if (@available(iOS 16.0, *)) {
-      NSString *detentId = @"custom-auto";
-      return [UISheetPresentationControllerDetent
-        customDetentWithIdentifier:detentId
-                          resolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> context) {
-                            CGFloat maxDetentValue = context.maximumDetentValue;
-                            CGFloat maxValue =
-                              self.maxHeight ? MIN(maxDetentValue, [self.maxHeight floatValue]) : maxDetentValue;
-                            CGFloat resolvedValue = MIN(height, maxValue);
-                            return resolvedValue;
-                          }];
+      return [self customDetentWithIdentifier:@"custom-auto"
+                                      atIndex:index
+                                  heightBlock:^CGFloat {
+                                    CGFloat height = self->_autoDetentHeight;
+                                    return height - [self autoDetentBottomInsetForHeight:height];
+                                  }];
+    } else {
+      return [UISheetPresentationControllerDetent mediumDetent];
+    }
+  }
+
+  if (value == -2) {
+    if (@available(iOS 16.0, *)) {
+      return [self customDetentWithIdentifier:@"custom-peek"
+                                      atIndex:index
+                                  heightBlock:^CGFloat {
+                                    CGFloat height = self->_peekDetentHeight;
+                                    return height - [self peekDetentBottomInsetForHeight:height];
+                                  }];
     } else {
       return [UISheetPresentationControllerDetent mediumDetent];
     }
   }
 
-  // Handle fraction (0-1)
-  // Fraction should only be > 0 and <= 1
   if (value <= 0 || value > 1) {
     RCTLogError(@"TrueSheet: detent fraction (%f) must be between 0 and 1", value);
     return [UISheetPresentationControllerDetent mediumDetent];
   }
 
-  NSString *detentId = [NSString stringWithFormat:@"custom-%f", value];
-
   if (@available(iOS 16.0, *)) {
-    return [UISheetPresentationControllerDetent
-      customDetentWithIdentifier:detentId
-                        resolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> context) {
-                          CGFloat maxDetentValue = context.maximumDetentValue;
-                          CGFloat maxValue =
-                            self.maxHeight ? MIN(maxDetentValue, [self.maxHeight floatValue]) : maxDetentValue;
-                          CGFloat resolvedValue = MIN(value * maxDetentValue, maxValue);
-                          return resolvedValue;
-                        }];
+    NSString *detentId = [NSString stringWithFormat:@"custom-%f", value];
+    CGFloat sheetHeight = value * self.screenHeight;
+    return [self customDetentWithIdentifier:detentId height:sheetHeight atIndex:index];
+  } else if (value >= 0.5) {
+    return [UISheetPresentationControllerDetent largeDetent];
   } else {
     return [UISheetPresentationControllerDetent mediumDetent];
   }
 }
 
+- (UISheetPresentationControllerDetent *)customDetentWithIdentifier:(NSString *)identifier
+                                                             height:(CGFloat)height
+                                                            atIndex:(NSInteger)index API_AVAILABLE(ios(16.0)) {
+  return [self customDetentWithIdentifier:identifier
+                                  atIndex:index
+                              heightBlock:^CGFloat {
+                                return height;
+                              }];
+}
+
+- (UISheetPresentationControllerDetent *)customDetentWithIdentifier:(NSString *)identifier
+                                                            atIndex:(NSInteger)index
+                                                        heightBlock:(CGFloat (^)(void))heightBlock
+  API_AVAILABLE(ios(16.0)) {
+  return [UISheetPresentationControllerDetent
+    customDetentWithIdentifier:identifier
+                      resolver:^CGFloat(id<UISheetPresentationControllerDetentResolutionContext> context) {
+                        CGFloat maxDetentValue = context.maximumDetentValue;
+                        self->_detentCalculator.maxDetentHeight = maxDetentValue;
+
+                        CGFloat height = heightBlock();
+                        CGFloat bottomAdjustment = [self detentBottomAdjustmentForHeight:height];
+                        CGFloat maxValue = self.maxContentHeight
+                                             ? fmin(maxDetentValue, [self.maxContentHeight floatValue])
+                                             : maxDetentValue;
+
+                        CGFloat adjustedHeight = height - bottomAdjustment;
+
+                        // Only the last detent may occupy the full maximum. Two detents
+                        // resolving to the same height (e.g. a capped auto and 1) make
+                        // UIKit skip the stack's deck animation when presenting a child
+                        // sheet and snap the sheet behind into place instead.
+                        NSInteger lastIndex = (NSInteger)self.detents.count - 1;
+                        if (adjustedHeight >= maxValue && index < lastIndex) {
+                          maxValue -= lastIndex - index;
+                        }
+
+                        CGFloat resolved = fmin(adjustedHeight, maxValue);
+
+                        NSMutableArray *heights = self->_detentCalculator.resolvedDetentHeights;
+                        if (heights && index >= 0 && index < (NSInteger)heights.count) {
+                          heights[index] = @(resolved);
+                        }
+
+                        return resolved;
+                      }];
+}
+
 - (UISheetPresentationControllerDetentIdentifier)detentIdentifierForIndex:(NSInteger)index {
-  UISheetPresentationController *sheet = self.sheetPresentationController;
-  if (!sheet)
+  UISheetPresentationController *sheet = self.sheet;
+  if (!sheet) {
+    RCTLogError(@"TrueSheet: sheetPresentationController is nil in detentIdentifierForIndex");
     return UISheetPresentationControllerDetentIdentifierMedium;
+  }
 
   UISheetPresentationControllerDetentIdentifier identifier = UISheetPresentationControllerDetentIdentifierMedium;
-  if (index < sheet.detents.count) {
+  if (index >= 0 && index < (NSInteger)sheet.detents.count) {
     UISheetPresentationControllerDetent *detent = sheet.detents[index];
     if (@available(iOS 16.0, *)) {
       identifier = detent.identifier;
@@ -503,17 +1187,15 @@
 }
 
 - (void)applyActiveDetent {
-  UISheetPresentationController *sheet = self.sheetPresentationController;
-  if (!sheet)
+  if (!self.sheet) {
+    RCTLogError(@"TrueSheet: sheetPresentationController is nil in applyActiveDetent");
     return;
+  }
 
-  // Validate and clamp activeDetentIndex to detents bounds
   NSInteger detentCount = _detents.count;
-  if (detentCount == 0) {
+  if (detentCount == 0)
     return;
-  }
 
-  // Clamp index to valid range
   NSInteger clampedIndex = _activeDetentIndex;
   if (clampedIndex < 0) {
     clampedIndex = 0;
@@ -521,14 +1203,13 @@
     clampedIndex = detentCount - 1;
   }
 
-  // Update the stored index if it was clamped
   if (clampedIndex != _activeDetentIndex) {
     _activeDetentIndex = clampedIndex;
   }
 
   UISheetPresentationControllerDetentIdentifier identifier = [self detentIdentifierForIndex:clampedIndex];
   if (identifier) {
-    sheet.selectedDetentIdentifier = identifier;
+    self.sheet.selectedDetentIdentifier = identifier;
   }
 }
 
@@ -537,113 +1218,232 @@
   [self applyActiveDetent];
 }
 
-- (NSInteger)currentDetentIndex {
-  UISheetPresentationController *sheet = self.sheetPresentationController;
-  if (!sheet)
-    return -1;
+- (void)resizeToDetentIndex:(NSInteger)index {
+  if (index == _activeDetentIndex) {
+    return;
+  }
 
-  UISheetPresentationControllerDetentIdentifier selectedIdentifier = sheet.selectedDetentIdentifier;
-  if (!selectedIdentifier)
-    return -1;
+  _pendingDetentIndex = index;
+  _activeDetentIndex = index;
+  [self applyActiveDetent];
+}
 
-  // Find the index by matching the identifier in the detents array
-  NSArray<UISheetPresentationControllerDetent *> *detents = sheet.detents;
-  for (NSInteger i = 0; i < detents.count; i++) {
-    if (@available(iOS 16.0, *)) {
-      if ([detents[i].identifier isEqualToString:selectedIdentifier]) {
-        return i;
-      }
-    } else {
-      // For iOS 15, we only support system detents (medium/large)
-      // Return the index based on the selected identifier
-      if ([selectedIdentifier isEqualToString:UISheetPresentationControllerDetentIdentifierMedium]) {
-        return 0;
-      } else if ([selectedIdentifier isEqualToString:UISheetPresentationControllerDetentIdentifierLarge]) {
-        return detents.count - 1;
+- (void)setupBackground {
+  auto effectiveBackgroundBlur = self.backgroundBlur;
+  if (@available(iOS 26.0, *)) {
+    // iOS 26+ has default liquid glass effect
+  } else if (effectiveBackgroundBlur == TrueSheetViewBackgroundBlur::None && !self.backgroundColor) {
+    effectiveBackgroundBlur = TrueSheetViewBackgroundBlur::SystemMaterial;
+  }
+
+  BOOL hasBlur = effectiveBackgroundBlur != TrueSheetViewBackgroundBlur::None;
+
+  _blurView.backgroundBlur = hasBlur ? effectiveBackgroundBlur : TrueSheetViewBackgroundBlur::None;
+  _blurView.blurIntensity = self.blurIntensity;
+  _blurView.blurInteraction = self.blurInteraction;
+  [_blurView applyBlurEffect];
+
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
+  if (@available(iOS 26.1, *)) {
+    if (!self.isDesignCompatibilityMode) {
+      if (self.backgroundColor || hasBlur) {
+        self.sheet.backgroundEffect = [UIColorEffect effectWithColor:[UIColor clearColor]];
+      } else {
+        self.sheet.backgroundEffect = nil;
       }
     }
   }
+#endif
 
-  return -1;
+  self.view.backgroundColor = self.backgroundColor;
 }
 
-- (CGFloat)currentPosition {
-  UIView *presentedView = self.presentedView;
-  if (!presentedView)
-    return 0.0;
+- (void)setupGrabber {
+  BOOL showGrabber = self.grabber && self.draggable;
+
+  if (self.grabberOptions) {
+    self.sheet.prefersGrabberVisible = NO;
+
+    GrabberOptions *options = self.grabberOptions;
+    _grabberView.accessibilityOptions = self.accessibilityOptions;
+    _grabberView.grabberWidth = options.width;
+    _grabberView.grabberHeight = options.height;
+    _grabberView.topMargin = options.topMargin;
+    _grabberView.cornerRadius = options.cornerRadius;
+    _grabberView.color = options.color;
+    _grabberView.adaptive = @(options.adaptive);
+    [_grabberView applyConfiguration];
+    _grabberView.hidden = !showGrabber;
+
+    __weak __typeof(self) weakSelf = self;
+    _grabberView.onTap = ^{
+      [weakSelf handleGrabberTap];
+    };
+    _grabberView.onIncrement = ^{
+      __strong __typeof(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf)
+        return;
+      NSInteger current = strongSelf.currentDetentIndex;
+      NSInteger count = strongSelf->_detents.count;
+      if (current >= 0 && current < count - 1) {
+        [strongSelf.sheet animateChanges:^{
+          [strongSelf resizeToDetentIndex:current + 1];
+        }];
+      }
+    };
+    _grabberView.onDecrement = ^{
+      __strong __typeof(weakSelf) strongSelf = weakSelf;
+      if (!strongSelf)
+        return;
+      NSInteger current = strongSelf.currentDetentIndex;
+      if (current > 0) {
+        [strongSelf.sheet animateChanges:^{
+          [strongSelf resizeToDetentIndex:current - 1];
+        }];
+      } else if (strongSelf.dismissible) {
+        [strongSelf.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+      }
+    };
+
+    [self.view bringSubviewToFront:_grabberView];
+  } else {
+    self.sheet.prefersGrabberVisible = showGrabber;
+    _grabberView.hidden = YES;
+    _grabberView.onTap = nil;
+    _grabberView.onIncrement = nil;
+    _grabberView.onDecrement = nil;
+  }
+}
+
+- (void)handleGrabberTap {
+  NSInteger detentCount = _detents.count;
+  if (detentCount == 0)
+    return;
 
-  return presentedView.frame.origin.y;
+  NSInteger currentIndex = self.currentDetentIndex;
+  if (currentIndex < 0)
+    return;
+
+  NSInteger nextIndex = (currentIndex + 1) % detentCount;
+  if (nextIndex == 0 && detentCount == 1 && self.dismissible) {
+    [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  } else {
+    [self.sheet animateChanges:^{
+      [self resizeToDetentIndex:nextIndex];
+    }];
+  }
 }
 
-- (CGFloat)currentHeight {
-  return self.containerHeight - self.currentPosition - _bottomInset;
+- (BOOL)isAnchored {
+  return self.anchor == TrueSheetViewAnchor::Left || self.anchor == TrueSheetViewAnchor::Right;
 }
 
-- (CGFloat)containerHeight {
-  UIView *containerView = self.sheetPresentationController.containerView;
-  if (!containerView)
-    return 0.0;
+- (void)setupAnchorViewInView:(UIView *)parentView {
+  if (!parentView)
+    return;
+
+  [_anchorView removeFromSuperview];
+  _anchorView = nil;
+
+  if (!self.isAnchored) {
+    self.sheetPresentationController.sourceView = nil;
+    return;
+  }
+
+  _anchorView = [[UIView alloc] init];
+  _anchorView.userInteractionEnabled = NO;
+  _anchorView.translatesAutoresizingMaskIntoConstraints = NO;
+  [parentView addSubview:_anchorView];
+
+  NSLayoutAnchor *horizontalAnchor =
+    self.anchor == TrueSheetViewAnchor::Right ? parentView.trailingAnchor : parentView.leadingAnchor;
 
-  return containerView.frame.size.height;
+  [NSLayoutConstraint activateConstraints:@[
+    [_anchorView.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor],
+    [horizontalAnchor constraintEqualToAnchor:_anchorView.leadingAnchor],
+  ]];
+
+  self.sheetPresentationController.sourceView = _anchorView;
 }
 
-- (void)setupSheetProps {
-  UISheetPresentationController *sheet = self.sheetPresentationController;
-  if (!sheet) {
+- (void)setupSheetSizing {
+  UISheetPresentationController *sheet = self.sheet;
+  if (!sheet)
     return;
+
+  // `presentation` is absolute on the form side: 'form' always renders a
+  // centered form sheet and ignores `maxContentWidth`. For 'page' with a
+  // custom `maxContentWidth`, prefersPageSizing has to flip to NO since
+  // `widthFollowsPreferredContentSizeWhenEdgeAttached` only takes effect
+  // when the sheet is edge-attached (Apple API constraint).
+  BOOL formSheet = self.presentation == facebook::react::TrueSheetViewPresentation::Form;
+  BOOL hasMaxWidth = self.maxContentWidth != nil && !formSheet;
+
+  if (@available(iOS 17.0, *)) {
+    sheet.prefersPageSizing = !formSheet && !hasMaxWidth;
   }
 
+  sheet.widthFollowsPreferredContentSizeWhenEdgeAttached = hasMaxWidth;
+
+  if (hasMaxWidth) {
+    CGFloat height = self.maxContentHeight ? [self.maxContentHeight floatValue] : self.screenHeight;
+    self.preferredContentSize = CGSizeMake([self.maxContentWidth floatValue], height);
+  } else {
+    self.preferredContentSize = CGSizeZero;
+  }
+}
+
+- (void)setupSheetProps {
+  UISheetPresentationController *sheet = self.sheet;
+  if (!sheet)
+    return;
+
   sheet.delegate = self;
   sheet.prefersEdgeAttachedInCompactHeight = YES;
-  sheet.prefersGrabberVisible = self.grabber;
-  // Only set preferredCornerRadius if explicitly provided, otherwise use system default
+  sheet.prefersScrollingExpandsWhenScrolledToEdge = self.draggable && self.scrollingExpandsSheet;
+
   if (self.cornerRadius) {
     sheet.preferredCornerRadius = [self.cornerRadius floatValue];
-  }
-
-  // Setup blur effect if blurTint is provided
-  if (self.blurTint && self.blurTint.length > 0) {
-    UIBlurEffectStyle style = UIBlurEffectStyleLight;
-
-    if ([self.blurTint isEqualToString:@"dark"]) {
-      style = UIBlurEffectStyleDark;
-    } else if ([self.blurTint isEqualToString:@"light"]) {
-      style = UIBlurEffectStyleLight;
-    } else if ([self.blurTint isEqualToString:@"extraLight"]) {
-      style = UIBlurEffectStyleExtraLight;
-    } else if ([self.blurTint isEqualToString:@"regular"]) {
-      style = UIBlurEffectStyleRegular;
-    } else if ([self.blurTint isEqualToString:@"prominent"]) {
-      style = UIBlurEffectStyleProminent;
-    } else if ([self.blurTint isEqualToString:@"systemThinMaterial"]) {
-      style = UIBlurEffectStyleSystemThinMaterial;
-    } else if ([self.blurTint isEqualToString:@"systemMaterial"]) {
-      style = UIBlurEffectStyleSystemMaterial;
-    } else if ([self.blurTint isEqualToString:@"systemThickMaterial"]) {
-      style = UIBlurEffectStyleSystemThickMaterial;
-    } else if ([self.blurTint isEqualToString:@"systemChromeMaterial"]) {
-      style = UIBlurEffectStyleSystemChromeMaterial;
-    } else if ([self.blurTint isEqualToString:@"systemUltraThinMaterial"]) {
-      style = UIBlurEffectStyleSystemUltraThinMaterial;
-    }
-
-    _backgroundView.effect = [UIBlurEffect effectWithStyle:style];
-    _backgroundView.backgroundColor = nil;
   } else {
-    // No blur effect, use solid background color
-    _backgroundView.effect = nil;
-    _backgroundView.backgroundColor = self.backgroundColor;
+    sheet.preferredCornerRadius = UISheetPresentationControllerAutomaticDimension;
   }
+
+  [self setupBackground];
+  [self setupGrabber];
 }
 
 #pragma mark - UISheetPresentationControllerDelegate
 
+- (BOOL)presentationControllerShouldDismiss:(UIPresentationController *)presentationController {
+  return self.dismissible;
+}
+
 - (void)sheetPresentationControllerDidChangeSelectedDetentIdentifier:
   (UISheetPresentationController *)sheetPresentationController {
-  NSInteger index = [self currentDetentIndex];
-  if (index >= 0 && [self.delegate respondsToSelector:@selector(viewControllerDidChangeDetent:position:)]) {
-    [self.delegate viewControllerDidChangeDetent:index position:self.currentPosition];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    NSInteger index = self.currentDetentIndex;
+    if (index >= 0) {
+      CGFloat detent = [self detentValueForIndex:index];
+      [self.delegate viewControllerDidChangeDetent:index position:self.currentPosition detent:detent];
+    }
+  });
+}
+
+#pragma mark - RNSDismissibleModalProtocol
+
+#if RNS_DISMISSIBLE_MODAL_PROTOCOL_AVAILABLE
+- (BOOL)isDismissible {
+  return NO;
+}
+
+- (UIViewController *)newPresentingViewController {
+  UIViewController *topmost = self;
+  while (topmost.presentedViewController != nil && !topmost.presentedViewController.isBeingDismissed &&
+         [topmost.presentedViewController isKindOfClass:[TrueSheetViewController class]]) {
+    topmost = topmost.presentedViewController;
   }
+  return topmost;
 }
+#endif
 
 @end