@lodev09/react-native-true-sheet 4.0.0-beta.3 → 4.0.0-beta.30

package/ios/TrueSheetViewController.mm

@@ -9,12 +9,15 @@
 #import "TrueSheetViewController.h"
 #import "TrueSheetContainerView.h"
 #import "TrueSheetContentView.h"
+#import "TrueSheetOverlayView.h"
 #import "core/TrueSheetBlurView.h"
 #import "core/TrueSheetDetentCalculator.h"
+#import "core/TrueSheetDimView.h"
 #import "core/TrueSheetGrabberView.h"
 #import "utils/BlurUtil.h"
 #import "utils/GestureUtil.h"
 #import "utils/PlatformUtil.h"
+#import "utils/UIView+FirstResponder.h"
 #import "utils/WindowUtil.h"
 
 #import <React/RCTLog.h>
@@ -45,7 +48,12 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 - (void)restoreWindowAccessibilityElements;
 - (void)setSheetAccessibilityElementsHidden:(BOOL)hidden;
 - (void)setAccessibilityContentElement:(UIView *)contentView;
+- (NSArray *)accessibilityGrabberElements;
 - (void)endInteractiveDismissState;
+- (void)updateHingeState;
+- (void)correctHingeOffsetForIndex:(NSInteger)index;
+- (CGFloat)tabletopHingeEdge;
+- (CGFloat)hingeOffsetForHeight:(CGFloat)height;
 - (void)animateInteractiveContainerToTransform:(CGAffineTransform)transform
                                       duration:(NSTimeInterval)duration
                           allowUserInteraction:(BOOL)allowUserInteraction
@@ -53,17 +61,39 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 
 @end
 
+// VoiceOver delivers the two-finger Z (escape) gesture by walking up the view
+// hierarchy from the focused element, so the sheet's root view handles it.
+@interface TrueSheetControllerView : UIView
+@property (nonatomic, weak) TrueSheetViewController *controller;
+@end
+
+@implementation TrueSheetControllerView
+
+- (BOOL)accessibilityPerformEscape {
+  return [self.controller accessibilityPerformEscape];
+}
+
+@end
+
 @implementation TrueSheetViewController {
   TrueSheetPositionState _lastEmittedPositionState;
   CGSize _lastReportedSize;
+  // Net of the footer's baked-in inset, snapshotted together: the inset updates
+  // with the footer's layout, but a size change mid-present is deferred to
+  // didPresent, so subtracting it live pairs a new inset with a stale height.
   CGFloat _autoDetentHeight;
   CGFloat _peekDetentHeight;
   NSInteger _pendingDetentIndex;
+  NSInteger _displayedBackgroundIndex;
+  BOOL _usesBackgroundEffects;
+  BOOL _refusedPanDismiss;
 
   // Present/dismiss tracking: a display link scoped to the transition
   // coordinator — started alongside the transition, stopped in its completion.
   CADisplayLink *_transitionLink;
   BOOL _isTransitioning;
+  // Where the sheet rests during the transition: the target on present, the start on dismiss
+  CGFloat _transitionRestPosition;
 
   BOOL _pendingContentSizeChange;
   BOOL _pendingDetentsChange;
@@ -74,6 +104,7 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   // for the next present (beats the float-threshold guess for re-presents).
   BOOL _hasObservedBottomInset;
   CGFloat _observedBottomInset;
+  BOOL _isRefreshingSafeArea;
 
   BOOL _isInteractiveDismiss;
   CGFloat _interactiveStartPosition;
@@ -82,14 +113,28 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   CADisplayLink *_interactivePositionLink;
 
   __weak TrueSheetViewController *_parentSheetController;
+  __weak UIView *_presenterFirstResponder;
 
   UIView *_anchorView;
 
   __weak UIWindow *_accessibilityWindow;
+  BOOL _appliedAccessibilityFooterElements;
 
   TrueSheetBlurView *_blurView;
   TrueSheetGrabberView *_grabberView;
   TrueSheetDetentCalculator *_detentCalculator;
+  TrueSheetDimView *_dimView;
+
+  // Foldable hinge (iOS 27.1+). Tabletop resolves on demand from the window's
+  // division region; these track the last applied posture to detect changes.
+  BOOL _hingeStateKnown;
+  CGFloat _hingeEdge;
+  NSInteger _hingeRestoreIndex;
+  NSInteger _hingeCorrections;
+  // Offset learned at the hinge, shared by every hinge-placed detent
+  CGFloat _hingeOffset;
+  // Offset each hinge-placed detent last resolved with, checked on settle
+  NSMutableDictionary<NSNumber *, NSNumber *> *_hingeOffsets;
 }
 
 #pragma mark - Initialization
@@ -97,6 +142,8 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
 - (instancetype)init {
   if (self = [super initWithNibName:nil bundle:nil]) {
     _detents = @[ @0.5, @1 ];
+    _detentBackgrounds = @[];
+    _displayedBackgroundIndex = 0;
     _contentHeight = @(0);
     _headerHeight = @(0);
     _footerHeight = @(0);
@@ -104,8 +151,11 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _grabber = YES;
     _draggable = YES;
     _scrollingExpandsSheet = YES;
+    _footerAvoidsKeyboard = YES;
     _dismissible = YES;
     _dimmed = YES;
+    _dimColor = nil;
+    _dimOpacity = nil;
     _dimmedDetentIndex = @(0);
     _presentation = facebook::react::TrueSheetViewPresentation::Page;
     _lastEmittedPositionState = (TrueSheetPositionState){0, 0, 0};
@@ -118,10 +168,16 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
     _activeDetentIndex = -1;
     _pendingDetentIndex = -1;
 
-    _blurInteraction = YES;
     _insetAdjustment = TrueSheetViewInsetAdjustment::Automatic;
+    _hingeRestoreIndex = -1;
+    _hingeOffsets = [NSMutableDictionary dictionary];
     _detentCalculator = [[TrueSheetDetentCalculator alloc] init];
     _detentCalculator.delegate = self;
+
+    [[NSNotificationCenter defaultCenter] addObserver:self
+                                             selector:@selector(overlayWindowDidChange)
+                                                 name:TrueSheetOverlayWindowDidChangeNotification
+                                               object:nil];
   }
   return self;
 }
@@ -206,11 +262,22 @@ static char TrueSheetAccessibilityWindowPreviousElementsKey;
   return self.currentPosition + (presentationY - modelY) + containerTy;
 }
 
+// Some callers run before this controller's view is attached (e.g. mid-presentation
+// detent resolution), so fall back to the presenter's window.
+- (UIWindow *)hostWindow {
+  return self.view.window ?: self.presentingViewController.view.window;
+}
+
 - (CGFloat)screenHeight {
-  UIWindow *window = self.view.window;
+  // In a windowed iPad app (Stage Manager, iPadOS 26 windowing) the window can be shorter than
+  // UIScreen.mainScreen, so prefer the window's height.
+  UIWindow *window = self.hostWindow;
   return window ? window.bounds.size.height : UIScreen.mainScreen.bounds.size.height;
 }
 
+// Gap UIKit leaves between a floating sheet (iOS 26+) and the screen's bottom edge
+static const CGFloat TrueSheetFloatingSheetInset = 8;
+
 // Only phone sheets absorb the bottom safe-area inset — non-phone idioms
 // (iPad form sheets) are inset from the screen edge by UIKit.
 static BOOL TrueSheetIsPhoneIdiom(void) {
@@ -250,7 +317,6 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
  * unpadded.
  */
 - (CGFloat)maxNaturalDetentHeight {
-  CGFloat applied = [self.footerHeight floatValue] > 0 ? _appliedFooterBottomInset : 0;
   CGFloat maxHeight = 0;
 
   for (id detent in self.detents) {
@@ -261,11 +327,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     CGFloat value = [detent doubleValue];
     CGFloat height = 0;
     if (value == -1) {
-      // Auto counts a relative footer's (padded) height
-      height = [_detentCalculator autoHeight] - (_absoluteFooter ? 0 : applied);
+      height = [_detentCalculator autoHeightForKeyboardHeight:0] - [self autoDetentBottomInset];
     } else if (value == -2) {
-      // Peek counts an absolute footer's (padded) height
-      height = [_detentCalculator peekHeight] - (_absoluteFooter ? applied : 0);
+      height = [_detentCalculator peekHeight] - [self peekDetentBottomInset];
     } else if (value > 0 && value <= 1) {
       height = value * self.screenHeight;
     }
@@ -297,6 +361,12 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // wrong leaves the safe-area region unfilled (gap) or double-padded.
   UIView *view = self.viewIfLoaded;
   if (view.window) {
+    // Mid-present, hold the expected inset over a stale zero so the footer
+    // doesn't shrink and regrow — viewDidAppear forces the real value.
+    if (!_isPresented && [self hasStaleBottomSafeArea]) {
+      return [self bottomSafeAreaForHeight:view.bounds.size.height];
+    }
+
     _hasObservedBottomInset = YES;
     _observedBottomInset = view.safeAreaInsets.bottom;
     return _observedBottomInset;
@@ -313,14 +383,27 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   return [self bottomSafeAreaForHeight:[self maxNaturalDetentHeight]];
 }
 
+// Re-resolve alongside the keyboard animation as its overlap with the pinned
+// footer changes, including keyboard height changes while already visible.
+- (void)setKeyboardHeight:(CGFloat)keyboardHeight {
+  if (_keyboardHeight == keyboardHeight) {
+    return;
+  }
+  _keyboardHeight = keyboardHeight;
+
+  if (_footerInsetAdjustment && !_footerAvoidsKeyboard && self.isPresented) {
+    [self setupSheetDetentsForSizeChange];
+  }
+}
+
 /**
- * Bottom inset excluded from the auto detent. A relative footer owns the
- * sheet's bottom edge and carries the inset in its height (see
- * footerBottomInset) — subtract exactly what was baked in so UIKit's own
- * safe-area layout doesn't double it.
+ * Bottom inset excluded from the auto detent. A relative footer (or an
+ * absolute one padding the scrollable) owns the sheet's bottom edge and
+ * carries the inset in its height (see footerBottomInset) — subtract exactly
+ * what was baked in so UIKit's own safe-area layout doesn't double it.
  */
 - (CGFloat)autoDetentBottomInset {
-  if (_absoluteFooter || [self.footerHeight floatValue] <= 0) {
+  if ((_absoluteFooter && !self.footerInsetAdjustment) || [self.footerHeight floatValue] <= 0) {
     return 0;
   }
 
@@ -341,6 +424,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 }
 
 - (BOOL)isDesignCompatibilityMode {
+  if (@available(iOS 27.0, *)) {
+    return NO;
+  }
   if (@available(iOS 26.0, *)) {
     NSNumber *value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIDesignRequiresCompatibility"];
     return value.boolValue;
@@ -377,6 +463,12 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
 #pragma mark - View Lifecycle
 
+- (void)loadView {
+  TrueSheetControllerView *view = [[TrueSheetControllerView alloc] init];
+  view.controller = self;
+  self.view = view;
+}
+
 - (void)viewDidLoad {
   [super viewDidLoad];
   self.view.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
@@ -387,6 +479,81 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   _grabberView = [[TrueSheetGrabberView alloc] init];
   _grabberView.hidden = YES;
   [_grabberView addToView:self.view];
+
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_1)
+  if (@available(iOS 27.1, *)) {
+    __weak __typeof(self) weakSelf = self;
+    UIHingeInteraction *hingeInteraction =
+      [[UIHingeInteraction alloc] initWithUpdateHandler:^(UIHingeInteraction *_, UIHingeInteractionUpdate *__) {
+        // Next run loop, so the division region reflects the new posture
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf updateHingeState];
+        });
+      }];
+    [self.view addInteraction:hingeInteraction];
+  }
+#endif
+}
+
+#pragma mark - Custom Dimming
+
+// UISheetPresentationController has no API for the dim's color or opacity, so a custom
+// color/opacity turns the native dim off and fades in our own view behind the sheet.
+- (BOOL)useCustomDimming {
+  return self.dimmed && (self.dimColor != nil || self.dimOpacity != nil);
+}
+
+- (BOOL)isDimmedAtEveryDetent {
+  return self.dimmed && [self.dimmedDetentIndex integerValue] == 0;
+}
+
+// Like the system dim, fades in between the detent below `dimmedDetentIndex` and the dimmed detent.
+- (CGFloat)dimAlphaForIndex:(CGFloat)index {
+  if (![self useCustomDimming]) {
+    return 0;
+  }
+
+  CGFloat progress = index - [self.dimmedDetentIndex integerValue] + 1;
+  return fmax(0, fmin(1, progress));
+}
+
+// Present and dismiss fade the dim over the whole travel below the resting position.
+- (CGFloat)dimAlphaForPosition:(CGFloat)position index:(CGFloat)index {
+  if (!_isTransitioning || position <= _transitionRestPosition) {
+    return [self dimAlphaForIndex:index];
+  }
+
+  CGFloat travel = self.screenHeight - _transitionRestPosition;
+  CGFloat progress = travel > 0 ? fmax(0, (self.screenHeight - position) / travel) : 0;
+  return [self dimAlphaForIndex:[self interpolatedIndexForPosition:_transitionRestPosition]] * progress;
+}
+
+- (void)setupDimView {
+  UIView *container = self.presentationController.containerView;
+  if (!container || (!_dimView && ![self useCustomDimming])) {
+    return;
+  }
+
+  if (!_dimView) {
+    _dimView = [[TrueSheetDimView alloc] init];
+
+    __weak __typeof(self) weakSelf = self;
+    _dimView.onTap = ^{
+      [weakSelf handleDimViewTap];
+    };
+  }
+
+  // Keep opacity in the color so a transparent dim still receives touches.
+  UIColor *color = self.dimColor ?: [UIColor blackColor];
+  CGFloat opacity = self.dimOpacity ? [self.dimOpacity doubleValue] : 0.5;
+  _dimView.backgroundColor = [color colorWithAlphaComponent:CGColorGetAlpha(color.CGColor) * opacity];
+  [_dimView addToView:container];
+}
+
+- (void)handleDimViewTap {
+  if (self.dismissible) {
+    [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  }
 }
 
 - (void)viewWillAppear:(BOOL)animated {
@@ -402,6 +569,22 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       [_parentSheetController setAccessibilityContentElement:self.accessibilityContentView ?: self.view];
     }
 
+    [self setupDimView];
+
+    // A new presentation records the posture it starts in
+    _hingeStateKnown = NO;
+    _hingeRestoreIndex = -1;
+    _hingeOffset = 0;
+
+    // UIKit hides the presenter's keyboard under a sheet dimmed at every detent and
+    // brings it back on dismiss, but custom dimming leaves the native sheet undimmed.
+    if ([self useCustomDimming] && [self isDimmedAtEveryDetent]) {
+      UIView *firstResponder = [presenter.view findFirstResponder];
+      if ([firstResponder resignFirstResponder]) {
+        _presenterFirstResponder = firstResponder;
+      }
+    }
+
     dispatch_async(dispatch_get_main_queue(), ^{
       NSInteger index = self.currentDetentIndex;
       CGFloat position = self.currentPosition;
@@ -430,15 +613,48 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
       [self->_grabberView updateAccessibilityValueWithIndex:index detentCount:self->_detents.count];
       [self settleAtDetentIndex:index debug:@"did present"];
+
+      // Apply a posture change that happened while presenting
+      [self updateHingeState];
     });
 
     [self setupGestureRecognizer];
     _isPresented = YES;
+    [self refreshStaleBottomSafeArea];
   }
 
   [self setupAccessibilityContainer];
 }
 
+/**
+ * A present that overlaps another transition (e.g. re-presenting while a
+ * native stack pops) can leave the root view's bottom safe area at zero, and
+ * UIKit doesn't recompute it until the sheet's frame next changes. Suspect a
+ * zero the presented height says shouldn't be there — a small floating sheet
+ * legitimately has none.
+ */
+- (BOOL)hasStaleBottomSafeArea {
+  UIView *view = self.viewIfLoaded;
+  return view.window && view.safeAreaInsets.bottom <= 0 && [self bottomSafeAreaForHeight:view.bounds.size.height] > 0;
+}
+
+// Toggling additionalSafeAreaInsets forces UIKit to recompute the safe area.
+// The toggle's intermediate value isn't reported, so the footer only sees the
+// settled one.
+- (void)refreshStaleBottomSafeArea {
+  if (![self hasStaleBottomSafeArea]) {
+    return;
+  }
+
+  _isRefreshingSafeArea = YES;
+  UIEdgeInsets insets = self.additionalSafeAreaInsets;
+  self.additionalSafeAreaInsets = UIEdgeInsetsMake(insets.top, insets.left, insets.bottom + 1, insets.right);
+  self.additionalSafeAreaInsets = insets;
+  _isRefreshingSafeArea = NO;
+
+  [self.delegate viewControllerSafeAreaInsetsDidChange];
+}
+
 - (void)setupAccessibilityContainer {
   UIView *contentView = self.accessibilityContentView;
   if (!contentView) {
@@ -448,6 +664,43 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [self setAccessibilityContentElement:contentView];
 }
 
+// Only the topmost sheet may refresh, or it would steal the window
+// accessibility override from the child presented over it.
+- (BOOL)canRefreshAccessibilityContainer {
+  return _isPresented && !self.isBeingDismissed && self.isTopmostPresentedController;
+}
+
+- (void)refreshAccessibilityContainer {
+  if (self.canRefreshAccessibilityContainer) {
+    [self setupAccessibilityContainer];
+  }
+}
+
+- (void)refreshAccessibilityContainerIfFooterChanged {
+  // Only a dimmed sheet's boundary depends on the footer
+  if (!_dimmed || !self.canRefreshAccessibilityContainer) {
+    return;
+  }
+
+  UIView *contentView = self.accessibilityContentView;
+  if (![contentView isKindOfClass:[TrueSheetContainerView class]] ||
+      [(TrueSheetContainerView *)contentView hasAccessibilityFooterElements] == _appliedAccessibilityFooterElements) {
+    return;
+  }
+
+  [self setAccessibilityContentElement:contentView];
+  UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, nil);
+}
+
+- (void)overlayWindowDidChange {
+  if (!self.canRefreshAccessibilityContainer) {
+    return;
+  }
+
+  [self setupAccessibilityContainer];
+  UIAccessibilityPostNotification(UIAccessibilityLayoutChangedNotification, nil);
+}
+
 - (UIViewController *)accessibilityPresentingViewController {
   UIViewController *presentingViewController = self.presentingViewController;
   while ([presentingViewController isKindOfClass:[TrueSheetViewController class]] &&
@@ -484,24 +737,56 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 }
 
+- (NSArray *)accessibilityGrabberElements {
+  if (_grabberView && !_grabberView.hidden) {
+    return @[ _grabberView ];
+  }
+
+  // The system grabber is an accessibility element UIKit adds to the presented view
+  // (a sibling of our root view). Expose it so VoiceOver can resize or dismiss with it.
+  // UIKit also keeps a transparent bottom grabber there, so skip invisible views.
+  NSMutableArray *elements = [NSMutableArray array];
+  for (UIView *subview in self.presentationController.presentedView.subviews) {
+    if (subview != self.view && subview.isAccessibilityElement && !subview.hidden && subview.alpha > 0) {
+      [elements addObject:subview];
+    }
+  }
+  return elements;
+}
+
+- (BOOL)accessibilityPerformEscape {
+  if (!_isPresented) {
+    return NO;
+  }
+
+  if (!self.dismissible) {
+    [self.delegate viewControllerDidAttemptDismiss];
+    return NO;
+  }
+
+  [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  return YES;
+}
+
 - (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;
+  _appliedAccessibilityFooterElements = 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;
+  NSMutableArray *accessibilityElements = [[self accessibilityGrabberElements] mutableCopy];
   if (isAccessibilityModal) {
     NSArray *contentElements = contentView.accessibilityElements;
-    accessibilityElements = contentElements.count > 0 ? contentElements : @[ contentView ];
+    [accessibilityElements addObjectsFromArray:contentElements.count > 0 ? contentElements : @[ contentView ]];
   } else {
-    accessibilityElements = @[ contentView ];
+    [accessibilityElements addObject:contentView];
   }
 
   self.view.isAccessibilityElement = NO;
@@ -514,6 +799,15 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     presentedView.accessibilityViewIsModal = isAccessibilityModal;
     presentedView.accessibilityElements = accessibilityElements;
 
+    // The system grabber is a sibling of our root view, so an escape performed while it
+    // is focused walks presentedView → window and never reaches TrueSheetControllerView.
+    if (@available(iOS 17.0, *)) {
+      __weak __typeof(self) weakSelf = self;
+      presentedView.accessibilityPerformEscapeBlock = ^BOOL {
+        return [weakSelf accessibilityPerformEscape];
+      };
+    }
+
     UIWindow *window = self.view.window;
     UIViewController *presentingViewController = [self accessibilityPresentingViewController];
     if (window && presentingViewController.view) {
@@ -528,8 +822,12 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       }
       objc_setAssociatedObject(window, &TrueSheetAccessibilityWindowOwnerKey, [NSValue valueWithNonretainedObject:self],
         OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-      window.accessibilityElements =
+      NSArray *sheetElements =
         isAccessibilityModal ? @[ presentedView ] : @[ presentingViewController.view, presentedView ];
+      // Overlays render above every sheet. Listed first, since accessibility
+      // hit testing takes the first element containing the point.
+      window.accessibilityElements =
+        [[TrueSheetOverlayView overlayContainersInWindow:window] arrayByAddingObjectsFromArray:sheetElements];
       return;
     }
   }
@@ -575,6 +873,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     [self.delegate viewControllerWillBlur];
     [self.delegate viewControllerWillDismiss];
     [_parentSheetController.delegate viewControllerWillFocus];
+
+    // Restored once the dismiss commits, like UIKit's own keyboard preservation.
+    UIView *firstResponder = _presenterFirstResponder;
+    _presenterFirstResponder = nil;
+    if (!self.presentingViewController.isBeingDismissed) {
+      [firstResponder becomeFirstResponder];
+    }
   }
 }
 
@@ -585,6 +890,9 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _isWillDismissEmitted = NO;
     _hasObservedBottomInset = NO;
 
+    [_dimView removeFromSuperview];
+    _dimView = nil;
+
     [_anchorView removeFromSuperview];
     _anchorView = nil;
 
@@ -603,13 +911,29 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [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];
-    }
-  });
+  // Dismissing with a child on top only animates the child out — this sheet
+  // doesn't move and isn't part of that transition, so fade its dim over it.
+  if (self.isBeingDismissed && self.presentedViewController) {
+    [UIView animateWithDuration:self.transitionCoordinator.transitionDuration
+                     animations:^{
+                       self->_dimView.alpha = 0;
+                     }];
+  }
+
+  // A swipe can still be cancelled, so emit once it commits on release. Any
+  // other dismiss (programmatic, outside tap, navigation) is already committed.
+  id<UIViewControllerTransitionCoordinator> coordinator = self.transitionCoordinator;
+  if (coordinator.isInteractive) {
+    __weak __typeof(self) weakSelf = self;
+    [coordinator
+      notifyWhenInteractionChangesUsingBlock:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
+        if (!context.isCancelled) {
+          [weakSelf emitWillDismissEvents];
+        }
+      }];
+  } else {
+    [self emitWillDismissEvents];
+  }
 
   [self setupTransitionTracker];
 }
@@ -625,8 +949,11 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 
   // Dismissing with the keyboard up skips the hide notification — don't let
-  // the stale flag block learning on the next present.
+  // the stale flag block learning on the next present, or a stale height keep
+  // the footer out of the auto detent.
   _keyboardSheetGrown = NO;
+  _keyboardHeight = 0;
+  _minimizedKeyboardOverlap = 0;
 
   [self emitDidDismissEvents];
 }
@@ -639,24 +966,26 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     return;
   }
 
-  if (_pendingContentSizeChange || _pendingDetentsChange) {
+  // Mid-drag the frame tracks the finger — never settle or learn from it;
+  // pending changes keep their flags and settle on the first post-drag layout.
+  if ((_pendingContentSizeChange || _pendingDetentsChange) && !_isDragging) {
     _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.
+  } else {
+    // 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. Mid-drag no child is on top, so drags emit 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) {
+    // The tight threshold keeps real movement (e.g. scroll-driven expansion
+    // or a drag hovering near the detent) from being absorbed.
+    if (!_isDragging && self.presentedViewController == nil && !self.isPresentedViewAnimating) {
       NSInteger index = self.currentDetentIndex;
       CGFloat expectedHeight = [_detentCalculator resolvedHeightForIndex:index];
       CGFloat actualHeight = self.screenHeight - self.currentPosition;
@@ -669,6 +998,25 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 }
 
+// Rotation or an iPad window resize changes the height fractional detents
+// resolve against — re-resolve alongside the transition so the sheet lands on
+// the new height instead of waiting for a content-driven rebuild.
+- (void)viewWillTransitionToSize:(CGSize)size
+       withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
+  [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+
+  if (@available(iOS 16.0, *)) {
+    [coordinator
+      animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+        [self.sheet invalidateDetents];
+      }
+      completion:^(id<UIViewControllerTransitionCoordinatorContext> context) {
+        // Rotating a half-open foldable swaps between book and tabletop
+        [self updateHingeState];
+      }];
+  }
+}
+
 // Fires when UIKit resolves the sheet's float/anchored placement (present,
 // detent resize crossing the float threshold, rotation). The footer's
 // absorbed inset follows the observed safe area — repush it right away so
@@ -678,7 +1026,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   // Mid-dismiss the frame moves off-screen and reports transient insets —
   // don't let them pollute the observed value (matches viewDidLayoutSubviews).
-  if (!self.isBeingDismissed) {
+  if (!self.isBeingDismissed && !_isRefreshingSafeArea) {
     [self.delegate viewControllerSafeAreaInsetsDidChange];
   }
 }
@@ -706,6 +1054,10 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     }
   }
 
+  // The hinge callback can run before the division region updates; the
+  // relayout UIKit does for the posture change always sees the new region.
+  [self updateHingeState];
+
   if (_pendingDetentIndex >= 0) {
     NSInteger pendingIndex = _pendingDetentIndex;
     _pendingDetentIndex = -1;
@@ -780,7 +1132,14 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       _isDragging = YES;
       break;
     case UIGestureRecognizerStateChanged:
-      [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:YES debug:@"drag change"];
+      // Layout owns the emit while the sheet resizes with the finger (a
+      // layout pass is already queued), and the transition tick owns it
+      // during an interactive dismiss. Translation-only movement (e.g.
+      // dragging down to the first detent) triggers neither — emit here as
+      // the backup.
+      if (!_isTransitioning && !self.presentedView.layer.needsLayout && !self.viewIfLoaded.layer.needsLayout) {
+        [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:YES debug:@"drag change"];
+      }
       break;
     case UIGestureRecognizerStateEnded:
     case UIGestureRecognizerStateCancelled: {
@@ -820,6 +1179,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 
   _isTransitioning = YES;
+  _transitionRestPosition = self.isBeingDismissed ? self.livePosition : self.currentPosition;
 
   // Learn the resolver-vs-actual offset before emitting transition positions so
   // the interpolated index lands exactly on the target detent. The presented
@@ -855,37 +1215,32 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       // 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.
+      // here absorbs any sub-pixel drift since the earlier learns. A dismiss
+      // cancelled mid-drag leaves the finger down, so the drag end settles instead.
       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"];
+          if (!strongSelf->_isDragging) {
+            [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];
-      }
+  // Also covers the interactive dismiss phase (finger down) — layout passes
+  // are skipped while transitioning, so the tick owns position there too.
+  CGFloat position = self.livePosition;
 
-      // 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;
-      }
+  if (self.isBeingDismissed) {
+    // 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"];
   }
+
+  [self emitChangePositionDelegateWithPosition:position realtime:YES debug:@"transition"];
 }
 
 /**
@@ -898,6 +1253,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   // measured frame; the next unobstructed settle learns.
   if (self.presentedViewController == nil) {
     [self learnOffsetForDetentIndex:index];
+    [self correctHingeOffsetForIndex:index];
   }
 
   [self emitChangePositionDelegateWithPosition:self.currentPosition realtime:NO debug:debug];
@@ -1018,12 +1374,31 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     }
   }
 
+  if (self.isPresented && !self.isBeingDismissed && !_isWillDismissEmitted && !_usesBackgroundEffects) {
+    NSInteger index = [_detentCalculator backgroundIndexForPosition:position displayedIndex:_displayedBackgroundIndex];
+    if (index != _displayedBackgroundIndex) {
+      _displayedBackgroundIndex = index;
+      [UIView animateWithDuration:0.2
+                            delay:0
+                          options:UIViewAnimationOptionBeginFromCurrentState | UIViewAnimationOptionAllowUserInteraction
+                       animations:^{
+                         [self setupBackground];
+                       }
+                       completion:nil];
+    }
+  }
+
   TrueSheetPositionState state = {
     .position = position,
     .detent = [self interpolatedDetentForPosition:position],
     .index = [self interpolatedIndexForPosition:position],
   };
 
+  // A child on top only pushes this sheet back, its detent stays.
+  if (!presented) {
+    _dimView.alpha = [self dimAlphaForPosition:position index:state.index];
+  }
+
   // 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.
@@ -1038,7 +1413,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 }
 
 - (void)learnOffsetForDetentIndex:(NSInteger)index {
-  if (_keyboardSheetGrown) {
+  if (_keyboardSheetGrown || _minimizedKeyboardOverlap > 0) {
     return;
   }
   [_detentCalculator learnOffsetForDetentIndex:index];
@@ -1072,6 +1447,146 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   return [_detentCalculator detentValueForIndex:index];
 }
 
+#pragma mark - Hinge
+
+/**
+ * Bottom edge (window coordinates) of an active horizontal fold, or 0 when the
+ * device isn't in tabletop. The division region is only active while the hinge
+ * is partially open, so this also excludes flat and closed postures.
+ */
+- (CGFloat)tabletopHingeEdge {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_1)
+  if (@available(iOS 27.1, *)) {
+    UIWindow *window = self.hostWindow;
+    for (UIViewReservedRegion *region in [window reservedRegionsOfKind:[UIViewReservedRegionKind divisionRegionKind]]) {
+      CGRect frame = region.frame;
+      if (region.isActive && frame.size.width > frame.size.height) {
+        return CGRectGetMaxY(frame);
+      }
+    }
+  }
+#endif
+  return 0;
+}
+
+/**
+ * Gap between a hinge-placed detent's resolved height and the sheet's actual top
+ * edge: UIKit adds the bottom safe area, plus the floating sheet's inset. Every
+ * hinge-placed detent rests at the same height, so they share one offset — the
+ * first settle at the hinge learns it.
+ */
+- (CGFloat)hingeOffsetForHeight:(CGFloat)height {
+  if (_hingeOffset > 0) {
+    return _hingeOffset;
+  }
+
+  return [self bottomSafeAreaForHeight:height] + TrueSheetFloatingSheetInset;
+}
+
+// A hinge-placed detent resolved with an off estimate lands a few points off
+// the hinge — re-resolve once the settle has learned the real offset.
+- (void)correctHingeOffsetForIndex:(NSInteger)index {
+  NSNumber *usedOffset = _hingeOffsets[@(index)];
+  if (!usedOffset || _hingeCorrections >= 2) {
+    return;
+  }
+
+  CGFloat learnedOffset = [_detentCalculator learnedOffsetForIndex:index];
+  if (learnedOffset == 0 || fabs(learnedOffset - usedOffset.doubleValue) <= 1) {
+    return;
+  }
+
+  _hingeOffset = learnedOffset;
+  _hingeCorrections++;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self invalidateDetentsAnimated];
+  });
+}
+
+- (void)invalidateDetentsAnimated {
+  if (@available(iOS 16.0, *)) {
+    [self.sheet animateChanges:^{
+      self->_pendingContentSizeChange = YES;
+      [self.sheet invalidateDetents];
+    }];
+  }
+}
+
+/**
+ * Re-resolves hinge-placed detents when the posture changes, and runs 'snap':
+ * entering tabletop moves the sheet to the hinge detent, leaving it restores the
+ * previous detent if the sheet is still on the hinge. The posture a presentation
+ * starts in only records state, so presenting while already in tabletop doesn't
+ * jump the sheet. A change while presenting, dismissing, or dragging stays
+ * pending until the sheet is at rest again.
+ */
+- (void)updateHingeState {
+  NSInteger hingeIndex = self.foldOptions.hingeDetentIndex;
+  if (hingeIndex < 0 && self.foldOptions.hingeBehavior == TrueSheetViewHingeBehavior::None) {
+    return;
+  }
+
+  // Covered by a full-screen presentation, the sheet has no window to read the posture from
+  if (!self.viewIfLoaded.window) {
+    return;
+  }
+
+  CGFloat edge = [self tabletopHingeEdge];
+  if (!_hingeStateKnown) {
+    _hingeStateKnown = YES;
+    _hingeEdge = edge;
+    return;
+  }
+
+  if (!self.isPresented || self.isBeingDismissed || _isDragging || fabs(edge - _hingeEdge) < 0.5) {
+    return;
+  }
+
+  BOOL entered = edge > 0 && _hingeEdge == 0;
+  BOOL left = edge == 0 && _hingeEdge > 0;
+  _hingeEdge = edge;
+  _hingeOffset = 0;
+  _hingeCorrections = 0;
+
+  NSInteger targetIndex = -1;
+  NSInteger detentCount = (NSInteger)self.detents.count;
+  BOOL snaps =
+    self.foldOptions.hingeBehavior == TrueSheetViewHingeBehavior::Snap && hingeIndex >= 0 && hingeIndex < detentCount;
+  if (entered && snaps) {
+    _hingeRestoreIndex = self.currentDetentIndex;
+    targetIndex = hingeIndex;
+  } else if (left && _hingeRestoreIndex >= 0) {
+    // Keep a detent the user picked while folded
+    if (snaps && self.currentDetentIndex == hingeIndex) {
+      targetIndex = MIN(_hingeRestoreIndex, detentCount - 1);
+    }
+    _hingeRestoreIndex = -1;
+  }
+
+  // A resize settles through the pending detent change
+  BOOL resizes = targetIndex >= 0 && targetIndex != self.activeDetentIndex;
+
+  if (@available(iOS 16.0, *)) {
+    [self.sheet animateChanges:^{
+      [self.sheet invalidateDetents];
+      if (resizes) {
+        [self resizeToDetentIndex:targetIndex];
+      }
+    }];
+  }
+
+  // UIKit often re-resolves detents for the posture change on its own before
+  // this runs, so the invalidation above triggers no layout pass to settle in.
+  // Settle once the frame is final, same as a pending detent change.
+  if (!resizes) {
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+      if (self.isPresented && !self.isBeingDismissed && !self->_isDragging && !self->_isTransitioning) {
+        [self settleAtDetentIndex:self.currentDetentIndex debug:@"hinge"];
+      }
+    });
+  }
+}
+
 #pragma mark - Sheet Configuration
 
 /**
@@ -1083,8 +1598,8 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
  */
 - (void)setupSheetDetentsForSizeChange {
   if (@available(iOS 16.0, *)) {
-    CGFloat autoHeight = [_detentCalculator autoHeight];
-    CGFloat peekHeight = [_detentCalculator peekHeight];
+    CGFloat autoHeight = [_detentCalculator autoHeightForKeyboardHeight:_keyboardHeight] - [self autoDetentBottomInset];
+    CGFloat peekHeight = [_detentCalculator peekHeight] - [self peekDetentBottomInset];
 
     if (fabs(autoHeight - _autoDetentHeight) < 0.5 && fabs(peekHeight - _peekDetentHeight) < 0.5) {
       return;
@@ -1093,12 +1608,19 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _autoDetentHeight = autoHeight;
     _peekDetentHeight = peekHeight;
 
+    [self invalidateDetentsAnimated];
+  }
+  // iOS 15: detents are fixed medium/large — size changes can't affect them.
+}
+
+// Re-resolves the detents in place, e.g. when an input to the resolver
+// changes after UIKit has already laid out the sheet.
+- (void)invalidateDetents {
+  if (@available(iOS 16.0, *)) {
     [self.sheet animateChanges:^{
-      self->_pendingContentSizeChange = YES;
       [self.sheet invalidateDetents];
     }];
   }
-  // iOS 15: detents are fixed medium/large — size changes can't affect them.
 }
 
 - (void)setupSheetDetentsForDetentsChange {
@@ -1115,9 +1637,10 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray array];
   [_detentCalculator clearResolvedHeights];
+  _hingeCorrections = 0;
 
-  _autoDetentHeight = [_detentCalculator autoHeight];
-  _peekDetentHeight = [_detentCalculator peekHeight];
+  _autoDetentHeight = [_detentCalculator autoHeightForKeyboardHeight:_keyboardHeight] - [self autoDetentBottomInset];
+  _peekDetentHeight = [_detentCalculator peekHeight] - [self peekDetentBottomInset];
 
   for (NSInteger index = 0; index < self.detents.count; index++) {
     id detent = self.detents[index];
@@ -1126,9 +1649,25 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 
   [_detentCalculator setDetentCount:self.detents.count];
+  _usesBackgroundEffects = [self canUseBackgroundEffects:detents];
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
+  if (@available(iOS 26.1, *)) {
+    if (_usesBackgroundEffects) {
+      for (NSInteger index = 0; index < detents.count; index++) {
+        NSDictionary *entry = [self backgroundForIndex:index];
+        auto blur = entry[@"blur"] ? static_cast<TrueSheetViewBackgroundBlur>([entry[@"blur"] intValue])
+                                   : TrueSheetViewBackgroundBlur::None;
+        detents[index].backgroundEffect = [self backgroundEffectForColor:entry[@"color"] blur:blur];
+      }
+    }
+  }
+#endif
+
   sheet.detents = detents;
 
-  if (self.dimmed && [self.dimmedDetentIndex integerValue] == 0) {
+  if ([self useCustomDimming]) {
+    sheet.largestUndimmedDetentIdentifier = sheet.detents.lastObject.identifier;
+  } else if ([self isDimmedAtEveryDetent]) {
     sheet.largestUndimmedDetentIdentifier = nil;
   } else {
     sheet.largestUndimmedDetentIdentifier = UISheetPresentationControllerDetentIdentifierLarge;
@@ -1164,7 +1703,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       return [self customDetentWithIdentifier:@"custom-auto"
                                       atIndex:index
                                   heightBlock:^CGFloat {
-                                    return self->_autoDetentHeight - [self autoDetentBottomInset];
+                                    return self->_autoDetentHeight;
                                   }];
     } else {
       return [UISheetPresentationControllerDetent mediumDetent];
@@ -1176,7 +1715,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
       return [self customDetentWithIdentifier:@"custom-peek"
                                       atIndex:index
                                   heightBlock:^CGFloat {
-                                    return self->_peekDetentHeight - [self peekDetentBottomInset];
+                                    return self->_peekDetentHeight;
                                   }];
     } else {
       return [UISheetPresentationControllerDetent mediumDetent];
@@ -1190,8 +1729,13 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   if (@available(iOS 16.0, *)) {
     NSString *detentId = [NSString stringWithFormat:@"custom-%f", value];
-    CGFloat sheetHeight = value * self.screenHeight;
-    return [self customDetentWithIdentifier:detentId height:sheetHeight atIndex:index];
+    // Resolve lazily — detents are built before presentation (no window yet), and
+    // UIKit re-resolves on container size changes (rotation, windowed iPad resize).
+    return [self customDetentWithIdentifier:detentId
+                                    atIndex:index
+                                heightBlock:^CGFloat {
+                                  return value * self.screenHeight;
+                                }];
   } else if (value >= 0.5) {
     return [UISheetPresentationControllerDetent largeDetent];
   } else {
@@ -1199,16 +1743,6 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   }
 }
 
-- (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
@@ -1226,24 +1760,66 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
                                              : maxDetentValue;
 
                         CGFloat adjustedHeight = height - bottomAdjustment;
+                        NSInteger lastIndex = (NSInteger)self.detents.count - 1;
+
+                        // Tabletop: the hinge detent rests on the hinge, and 'avoid'/'snap'
+                        // cap every detent there.
+                        BOOL avoidsHinge = self.foldOptions.hingeBehavior != TrueSheetViewHingeBehavior::None;
+                        NSInteger hingeIndex = self.foldOptions.hingeDetentIndex;
+                        BOOL hasHingeDetent = hingeIndex >= 0 && hingeIndex <= lastIndex;
+                        CGFloat hingeEdge = (hasHingeDetent || avoidsHinge) ? [self tabletopHingeEdge] : 0;
+                        CGFloat hingeOffset = 0;
+                        CGFloat hingeHeight = 0;
+                        if (hingeEdge > 0) {
+                          CGFloat panelHeight = self.screenHeight - hingeEdge;
+                          hingeOffset = [self hingeOffsetForHeight:panelHeight];
+                          hingeHeight = panelHeight - hingeOffset;
+                          if (hasHingeDetent) {
+                            // Lower detents stay below the hinge detent and higher ones above
+                            // it, so the detents keep their order
+                            CGFloat hingeDetentHeight =
+                              avoidsHinge ? hingeHeight - (lastIndex - hingeIndex) : hingeHeight;
+                            if (index == hingeIndex) {
+                              adjustedHeight = hingeHeight;
+                            } else if (index < hingeIndex) {
+                              adjustedHeight = fmin(adjustedHeight, hingeDetentHeight - (hingeIndex - index));
+                            } else {
+                              adjustedHeight = fmax(adjustedHeight, hingeDetentHeight + (index - hingeIndex));
+                            }
+                          }
+                          if (avoidsHinge) {
+                            maxValue = fmin(maxValue, hingeHeight);
+                          }
+                        }
 
                         // 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);
 
+                        // Detents within the collapse spacing of the hinge are hinge-placed.
+                        // They rest with the hinge offset, so position events map them right
+                        // before the first settle there.
+                        if (hingeHeight > 0 && fabs(resolved - hingeHeight) <= lastIndex + 0.5) {
+                          self->_hingeOffsets[@(index)] = @(hingeOffset);
+                          [self->_detentCalculator assumeOffset:hingeOffset forIndex:index];
+                        } else {
+                          [self->_hingeOffsets removeObjectForKey:@(index)];
+                        }
+
                         NSMutableArray *heights = self->_detentCalculator.resolvedDetentHeights;
                         if (heights && index >= 0 && index < (NSInteger)heights.count) {
                           heights[index] = @(resolved);
                         }
 
-                        return resolved;
+                        // Recorded uncompensated above: UIKit adds the overlap back on
+                        // top. A sheet shorter than the overlap still grows by the rest.
+                        return fmax(resolved - self.minimizedKeyboardOverlap, 0);
                       }];
 }
 
@@ -1298,6 +1874,8 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
 - (void)setupActiveDetentWithIndex:(NSInteger)index {
   _activeDetentIndex = index;
+  _displayedBackgroundIndex = index;
+  [self setupBackground];
   [self applyActiveDetent];
 }
 
@@ -1311,34 +1889,72 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [self applyActiveDetent];
 }
 
-- (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)canUseBackgroundEffects:(NSArray<UISheetPresentationControllerDetent *> *)detents {
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(26_1) && !TARGET_OS_MACCATALYST
+  if (@available(iOS 26.1, *)) {
+    // Some 26.1 builds omit setters declared in the SDK.
+    if (self.isDesignCompatibilityMode || ![self.sheet respondsToSelector:@selector(setBackgroundEffect:)]) {
+      return NO;
+    }
+    for (UISheetPresentationControllerDetent *detent in detents) {
+      if (![detent respondsToSelector:@selector(setBackgroundEffect:)]) {
+        return NO;
+      }
+    }
+    return YES;
   }
+#endif
+  return NO;
+}
 
-  BOOL hasBlur = effectiveBackgroundBlur != TrueSheetViewBackgroundBlur::None;
+- (NSDictionary *)backgroundForIndex:(NSInteger)index {
+  return index >= 0 && index < self.detentBackgrounds.count ? self.detentBackgrounds[index] : nil;
+}
 
-  _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
+- (UIVisualEffect *)backgroundEffectForColor:(UIColor *)color
+                                        blur:(TrueSheetViewBackgroundBlur)blur API_AVAILABLE(ios(26.1)) {
+  if (blur != TrueSheetViewBackgroundBlur::None) {
+    return [UIBlurEffect effectWithStyle:[BlurUtil blurEffectStyleFromEnum:blur]];
+  }
+  return color ? [UIColorEffect effectWithColor:color] : nil;
+}
+#endif
 
+- (void)setupBackground {
 #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;
-      }
+    if (_usesBackgroundEffects) {
+      self.sheet.backgroundEffect = [self backgroundEffectForColor:self.backgroundColor blur:self.backgroundBlur];
+      self.view.backgroundColor = nil;
+      _blurView.hidden = YES;
+      _blurView.backgroundBlur = TrueSheetViewBackgroundBlur::None;
+      [_blurView applyBlurEffect];
+      return;
     }
   }
 #endif
 
-  self.view.backgroundColor = self.backgroundColor;
+  NSDictionary *entry = [self backgroundForIndex:_displayedBackgroundIndex];
+  BOOL hasEntry = entry[@"color"] || entry[@"blur"];
+  UIColor *color = hasEntry ? entry[@"color"] : self.backgroundColor;
+  auto effectiveBackgroundBlur =
+    hasEntry ? (entry[@"blur"] ? static_cast<TrueSheetViewBackgroundBlur>([entry[@"blur"] intValue])
+                               : TrueSheetViewBackgroundBlur::None)
+             : self.backgroundBlur;
+  if (@available(iOS 26.0, *)) {
+    // iOS 26+ has default liquid glass effect
+  } else if (effectiveBackgroundBlur == TrueSheetViewBackgroundBlur::None && !color) {
+    effectiveBackgroundBlur = TrueSheetViewBackgroundBlur::SystemMaterial;
+  }
+
+  BOOL hasBlur = effectiveBackgroundBlur != TrueSheetViewBackgroundBlur::None;
+
+  _blurView.hidden = NO;
+  _blurView.backgroundBlur = effectiveBackgroundBlur;
+  [_blurView applyBlurEffect];
+
+  self.view.backgroundColor = hasBlur ? nil : color;
 }
 
 - (void)setupGrabber {
@@ -1385,6 +2001,8 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
         }];
       } else if (strongSelf.dismissible) {
         [strongSelf.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+      } else {
+        [strongSelf.delegate viewControllerDidAttemptDismiss];
       }
     };
 
@@ -1396,6 +2014,8 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     _grabberView.onIncrement = nil;
     _grabberView.onDecrement = nil;
   }
+
+  [self refreshAccessibilityContainer];
 }
 
 - (void)handleGrabberTap {
@@ -1408,8 +2028,12 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
     return;
 
   NSInteger nextIndex = (currentIndex + 1) % detentCount;
-  if (nextIndex == 0 && detentCount == 1 && self.dismissible) {
-    [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+  if (nextIndex == 0 && detentCount == 1) {
+    if (self.dismissible) {
+      [self.presentingViewController dismissViewControllerAnimated:YES completion:nil];
+    } else {
+      [self.delegate viewControllerDidAttemptDismiss];
+    }
   } else {
     [self.sheet animateChanges:^{
       [self resizeToDetentIndex:nextIndex];
@@ -1418,9 +2042,24 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 }
 
 - (BOOL)isAnchored {
-  return self.anchor == TrueSheetViewAnchor::Left || self.anchor == TrueSheetViewAnchor::Right;
+  return self.placement == TrueSheetViewPlacement::Leading || self.placement == TrueSheetViewPlacement::Trailing;
 }
 
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_0)
+- (UISheetPresentationControllerPlacement)preferredPlacement API_AVAILABLE(ios(27.0)) {
+  switch (self.placement) {
+    case TrueSheetViewPlacement::Leading:
+      return UISheetPresentationControllerPlacementLeading;
+    case TrueSheetViewPlacement::Center:
+      return UISheetPresentationControllerPlacementCenter;
+    case TrueSheetViewPlacement::Trailing:
+      return UISheetPresentationControllerPlacementTrailing;
+    case TrueSheetViewPlacement::Automatic:
+      return UISheetPresentationControllerPlacementAutomatic;
+  }
+}
+#endif
+
 - (void)setupAnchorViewInView:(UIView *)parentView {
   if (!parentView)
     return;
@@ -1428,6 +2067,18 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [_anchorView removeFromSuperview];
   _anchorView = nil;
 
+#if RNTS_IPHONE_OS_VERSION_AVAILABLE(27_0)
+  // iOS 27 exposes native placement. `sourceView` must stay nil since it overrides `preferredPlacement`.
+  if (@available(iOS 27.0, *)) {
+    if ([self.sheetPresentationController respondsToSelector:@selector(setPreferredPlacement:)]) {
+      self.sheetPresentationController.sourceView = nil;
+      self.sheetPresentationController.preferredPlacement = [self preferredPlacement];
+      return;
+    }
+  }
+#endif
+
+  // Pre-27 has no explicit center, so `center` falls back to the system default like `automatic`.
   if (!self.isAnchored) {
     self.sheetPresentationController.sourceView = nil;
     return;
@@ -1439,7 +2090,7 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
   [parentView addSubview:_anchorView];
 
   NSLayoutAnchor *horizontalAnchor =
-    self.anchor == TrueSheetViewAnchor::Right ? parentView.trailingAnchor : parentView.leadingAnchor;
+    self.placement == TrueSheetViewPlacement::Trailing ? parentView.trailingAnchor : parentView.leadingAnchor;
 
   [NSLayoutConstraint activateConstraints:@[
     [_anchorView.bottomAnchor constraintEqualToAnchor:parentView.bottomAnchor],
@@ -1493,12 +2144,56 @@ static BOOL TrueSheetIsPhoneIdiom(void) {
 
   [self setupBackground];
   [self setupGrabber];
+
+  // Dim props changed while presented. A hidden custom dim stays until dismiss;
+  // at alpha 0 it no longer takes touches.
+  if (_isPresented) {
+    [self setupDimView];
+    _dimView.alpha = [self dimAlphaForIndex:self.currentDetentIndex];
+  }
 }
 
 #pragma mark - UISheetPresentationControllerDelegate
 
 - (BOOL)presentationControllerShouldDismiss:(UIPresentationController *)presentationController {
-  return self.dismissible;
+  // A sheet that can't be dragged can't be swiped away either, including by
+  // pulling down its scroll view: refuse a dismissal while any pan is under
+  // way, and keep the one from a tap outside the sheet. Reset on every call:
+  // UIKit skips didAttemptToDismiss for a short pull.
+  _refusedPanDismiss =
+    self.dismissible && !self.draggable && [self hasActivePanInView:presentationController.containerView];
+  return self.dismissible && !_refusedPanDismiss;
+}
+
+- (BOOL)hasActivePanInView:(UIView *)view {
+  if (!view) {
+    return NO;
+  }
+  for (UIGestureRecognizer *recognizer in view.gestureRecognizers ?: @[]) {
+    if ([recognizer isKindOfClass:[UIPanGestureRecognizer class]] &&
+        (recognizer.state == UIGestureRecognizerStateBegan || recognizer.state == UIGestureRecognizerStateChanged)) {
+      return YES;
+    }
+  }
+  for (UIView *subview in view.subviews) {
+    if ([self hasActivePanInView:subview]) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+// UIKit calls this after shouldDismiss returns NO — the sheet has already
+// bounced back, so JS can confirm and dismiss programmatically (Apple's
+// unsaved-changes pattern).
+- (void)presentationControllerDidAttemptToDismiss:(UIPresentationController *)presentationController {
+  // A swipe refused only because the sheet can't be dragged isn't an attempt
+  // to dismiss a non-dismissible sheet.
+  if (_refusedPanDismiss) {
+    _refusedPanDismiss = NO;
+    return;
+  }
+  [self.delegate viewControllerDidAttemptDismiss];
 }
 
 - (void)sheetPresentationControllerDidChangeSelectedDetentIdentifier: