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

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewController.kt

@@ -1,17 +1,18 @@
 package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
-import android.graphics.Color
-import android.graphics.drawable.ShapeDrawable
-import android.graphics.drawable.shapes.RoundRectShape
+import android.graphics.Canvas
+import android.os.Build
 import android.view.MotionEvent
 import android.view.View
-import android.view.WindowManager
+import android.view.ViewGroup
+import android.view.accessibility.AccessibilityEvent
 import android.view.accessibility.AccessibilityNodeInfo
-import android.widget.FrameLayout
+import android.widget.ImageView
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.graphics.createBitmap
 import androidx.core.view.isNotEmpty
 import com.facebook.react.R
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.uimanager.JSPointerDispatcher
 import com.facebook.react.uimanager.JSTouchDispatcher
 import com.facebook.react.uimanager.PixelUtil.dpToPx
@@ -19,837 +20,1637 @@ import com.facebook.react.uimanager.PixelUtil.pxToDp
 import com.facebook.react.uimanager.RootView
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.util.RNLog
 import com.facebook.react.views.view.ReactViewGroup
 import com.google.android.material.bottomsheet.BottomSheetBehavior
-import com.google.android.material.bottomsheet.BottomSheetDialog
+import com.lodev09.truesheet.core.AccessibilityOptions
+import com.lodev09.truesheet.core.GrabberOptions
+import com.lodev09.truesheet.core.TrueSheetBottomSheetBehavior
+import com.lodev09.truesheet.core.TrueSheetBottomSheetView
+import com.lodev09.truesheet.core.TrueSheetBottomSheetViewDelegate
+import com.lodev09.truesheet.core.TrueSheetCoordinatorLayout
+import com.lodev09.truesheet.core.TrueSheetCoordinatorLayoutDelegate
+import com.lodev09.truesheet.core.TrueSheetDetentCalculator
+import com.lodev09.truesheet.core.TrueSheetDetentCalculatorDelegate
+import com.lodev09.truesheet.core.TrueSheetDimView
+import com.lodev09.truesheet.core.TrueSheetDimViewDelegate
+import com.lodev09.truesheet.core.TrueSheetKeyboardObserver
+import com.lodev09.truesheet.core.TrueSheetKeyboardObserverDelegate
+import com.lodev09.truesheet.core.TrueSheetStackManager
+import com.lodev09.truesheet.utils.Insets
+import com.lodev09.truesheet.utils.KeyboardUtils
 import com.lodev09.truesheet.utils.ScreenUtils
+import com.lodev09.truesheet.utils.TouchEventDeduper
+
+// =============================================================================
+// MARK: - Data Types & Delegate Protocol
+// =============================================================================
 
 data class DetentInfo(val index: Int, val position: Float)
 
-/**
- * Delegate protocol for TrueSheetViewController lifecycle and interaction events.
- * Similar to iOS TrueSheetViewControllerDelegate pattern.
- */
 interface TrueSheetViewControllerDelegate {
-  fun viewControllerWillPresent(index: Int, position: Float)
-  fun viewControllerDidPresent(index: Int, position: Float)
+  val eventDispatcher: EventDispatcher?
+  fun findRootContainerView(): ViewGroup?
+  fun viewControllerWillPresent(index: Int, position: Float, detent: Float)
+  fun viewControllerDidPresent(index: Int, position: Float, detent: Float)
   fun viewControllerWillDismiss()
-  fun viewControllerDidDismiss()
-  fun viewControllerDidChangeDetent(index: Int, position: Float)
-  fun viewControllerDidDragBegin(index: Int, position: Float)
-  fun viewControllerDidDragChange(index: Int, position: Float)
-  fun viewControllerDidDragEnd(index: Int, position: Float)
-  fun viewControllerDidChangePosition(index: Int, position: Float, transitioning: Boolean)
+  fun viewControllerDidDismiss(parent: TrueSheetView?)
+  fun viewControllerDidAttemptDismiss()
+  fun viewControllerDidChangeDetent(index: Int, position: Float, detent: Float)
+  fun viewControllerDidDragBegin(index: Int, position: Float, detent: Float)
+  fun viewControllerDidDragChange(index: Int, position: Float, detent: Float)
+  fun viewControllerDidDragEnd(index: Int, position: Float, detent: Float)
+  fun viewControllerDidChangePosition(index: Float, position: Float, detent: Float, realtime: Boolean)
   fun viewControllerDidChangeSize(width: Int, height: Int)
+  fun viewControllerWillFocus()
+  fun viewControllerDidFocus()
+  fun viewControllerWillBlur()
+  fun viewControllerDidBlur()
+  fun viewControllerDidChangeVisibility(visible: Boolean)
 }
 
+// =============================================================================
+// MARK: - TrueSheetViewController
+// =============================================================================
+
 /**
- * TrueSheetViewController manages the bottom sheet dialog lifecycle and properties.
- * Similar to iOS TrueSheetViewController pattern.
+ * Controls the presentation and behavior of a bottom sheet.
  *
- * This view acts as both the RootView (handles touch events) and the controller (manages dialog).
+ * Uses CoordinatorLayout with BottomSheetBehavior to manage the sheet within the activity window,
+ * enabling touch pass-through to underlying views. Handles detent configuration, drag interactions,
+ * keyboard avoidance, dimmed backgrounds, back button, and lifecycle events for stacked sheets.
  */
+enum class TrueSheetAnchor {
+  LEFT,
+  CENTER,
+  RIGHT;
+
+  companion object {
+    fun fromString(value: String?): TrueSheetAnchor =
+      when (value) {
+        "left" -> LEFT
+        "right" -> RIGHT
+        else -> CENTER
+      }
+  }
+}
+
+enum class TrueSheetInsetAdjustment {
+  AUTOMATIC,
+  NEVER;
+
+  companion object {
+    fun fromString(value: String?): TrueSheetInsetAdjustment =
+      when (value) {
+        "never" -> NEVER
+        else -> AUTOMATIC
+      }
+  }
+}
+
 @SuppressLint("ClickableViewAccessibility", "ViewConstructor")
 class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   ReactViewGroup(reactContext),
-  RootView {
+  RootView,
+  TrueSheetDetentCalculatorDelegate,
+  TrueSheetDimViewDelegate,
+  TrueSheetCoordinatorLayoutDelegate,
+  TrueSheetBottomSheetViewDelegate {
 
   companion object {
-    private const val TAG_NAME = "TrueSheet"
+    private const val DEFAULT_MAX_WIDTH = 640 // dp
+    private const val DEFAULT_CORNER_RADIUS = 16 // dp
+    private const val DEFAULT_ANCHOR_OFFSET = 16 // dp
+    private const val TRANSLATE_ANIMATION_DURATION = 200L
+    private const val DISMISS_DURATION = 200L
+    private const val SCREEN_FADE_DURATION = 150L
+
+    // Mirrors BottomSheetBehavior.HIDE_THRESHOLD — how far past the lowest stop,
+    // as a fraction of its height, a release hides a dismissible sheet
+    private const val HIDE_THRESHOLD = 0.5f
   }
 
-  // ==================== RootView Touch Handling ====================
+  // =============================================================================
+  // MARK: - Types
+  // =============================================================================
 
-  internal var eventDispatcher: EventDispatcher? = null
+  private sealed class InteractionState {
+    data object Idle : InteractionState()
+    data class Dragging(val startTop: Int) : InteractionState()
+    data object Reconfiguring : InteractionState()
+  }
 
-  private val jSTouchDispatcher = JSTouchDispatcher(this)
-  private var jSPointerDispatcher: JSPointerDispatcher? = null
+  // =============================================================================
+  // MARK: - Properties
+  // =============================================================================
 
-  /**
-   * Delegate for handling view controller events
-   */
   var delegate: TrueSheetViewControllerDelegate? = null
 
-  /**
-   * The BottomSheetDialog instance - created lazily when container mounts
-   */
-  private var dialog: BottomSheetDialog? = null
-
-  /**
-   * The sheet behavior from the dialog
-   */
-  private val behavior: BottomSheetBehavior<FrameLayout>?
-    get() = dialog?.behavior
+  // CoordinatorLayout components (replaces DialogFragment)
+  internal var sheetView: TrueSheetBottomSheetView? = null
+  internal var coordinatorLayout: TrueSheetCoordinatorLayout? = null
+  private var dimView: TrueSheetDimView? = null
+  private var parentDimView: TrueSheetDimView? = null
 
-  /**
-   * The sheet container view from Material BottomSheetDialog (our parent)
-   */
-  private val sheetContainer: FrameLayout?
-    get() = this.parent as? FrameLayout
+  // Presentation State
+  var isPresented = false
+    private set
 
-  /**
-   * The actual bottom sheet view used by Material BottomSheetBehavior
-   * This is the view whose position changes during drag
-   */
-  private val bottomSheetView: FrameLayout?
-    get() = dialog?.findViewById(com.google.android.material.R.id.design_bottom_sheet)
+  var isSheetVisible = false
+    private set
 
-  /**
-   * Our sheet container view from this root view's only child
-   */
-  private val containerView: TrueSheetContainerView?
-    get() = if (this.isNotEmpty()) {
-      this.getChildAt(0) as? TrueSheetContainerView
-    } else {
-      null
-    }
+  var currentDetentIndex: Int = -1
+    private set
 
-  /**
-   * Footer view from the container
-   */
-  private val footerView: TrueSheetFooterView?
-    get() = containerView?.footerView
+  // Target detent index during an in-flight resize animation. -1 when idle.
+  // Used by setupSheetDetents so a layout-driven reconfigure during the
+  // animation doesn't snap the sheet back to the stale currentDetentIndex.
+  private var pendingDetentIndex: Int = -1
 
-  /**
-   * Track if the dialog is currently being dragged
-   */
-  private var isDragging = false
+  private var interactionState: InteractionState = InteractionState.Idle
 
-  /**
-   * Track if the sheet has been presented (after onShow callback)
-   */
-  var isPresented = false
+  // A content/header/footer size change arrived mid-drag — reconfiguring then
+  // would reset behavior state and kill the gesture, so it's applied on settle.
+  private var hasPendingSizeChange = false
+  internal var isBeingDismissed = false
     private set
+  var wasHiddenByScreen = false
+  private var shouldAnimatePresent = false
+  private var isPresentAnimating = false
 
-  private val edgeToEdgeEnabled: Boolean
-    get() {
-      // Auto-enable edge-to-edge for Android 16+ (API level 36) if not explicitly set
-      val defaultEnabled = android.os.Build.VERSION.SDK_INT >= 36
-      return BuildConfig.EDGE_TO_EDGE_ENABLED || dialog?.edgeToEdgeEnabled == true || defaultEnabled
-    }
+  private var lastStateWidth: Int = 0
+  private var lastStateHeight: Int = 0
+  private var lastEmittedPositionPx: Int = -1
 
-  /**
-   * Whether to allow the sheet to extend behind the status bar in edge-to-edge mode
-   */
-  var edgeToEdgeFullScreen: Boolean = false
-
-  /**
-   * Top inset to apply to sheet max height calculation (only when not edgeToEdgeFullScreen)
-   */
-  private val sheetTopInset: Int
-    get() = if (edgeToEdgeEnabled && !edgeToEdgeFullScreen) ScreenUtils.getStatusBarHeight(reactContext) else 0
+  // Keyboard State
+  private var detentIndexBeforeKeyboard: Int = -1
+  private var isKeyboardDismissProgrammatic = false
 
-  /**
-   * Current active detent index
-   */
-  var currentDetentIndex: Int = -1
-    private set
+  // Sheet top when a keyboard-floor drag was released; -1 once the settle target is known
+  private var keyboardSettleStartTop = -1
+  private var focusedViewBeforeBlur: View? = null
 
-  /**
-   * Promise callback to be invoked after present is called
-   */
+  // Promises
   var presentPromise: (() -> Unit)? = null
-
-  /**
-   * Promise callback to be invoked after dismiss is called
-   */
+  var resizePromise: (() -> Unit)? = null
   var dismissPromise: (() -> Unit)? = null
 
-  // ==================== Properties ====================
+  // For stacked sheets
+  var parentSheetView: TrueSheetView? = null
 
-  /**
-   * Specify whether the sheet background is dimmed.
-   * Set to `false` to allow interaction with the background components.
-   */
-  var dimmed = true
+  // Helper Objects
+  private var keyboardObserver: TrueSheetKeyboardObserver? = null
+  internal val detentCalculator = TrueSheetDetentCalculator(reactContext).apply {
+    delegate = this@TrueSheetViewController
+  }
 
-  /**
-   * The detent index that the sheet should start to dim the background.
-   * This is ignored if `dimmed` is set to `false`.
-   */
-  var dimmedIndex = 0
+  // Touch Dispatchers
+  private val jsTouchDispatcher = JSTouchDispatcher(this)
+  private val jsPointerDispatcher = JSPointerDispatcher(this)
 
-  /**
-   * The maximum window height
-   */
-  var maxScreenHeight = 0
+  // True when the active touch stream began inside the footer. Latched on
+  // ACTION_DOWN so subsequent MOVE events keep routing to the footer even if
+  // the finger drifts outside the footer's rect mid-gesture.
+  private var footerOwnsTouchStream = false
 
-  var maxSheetHeight: Int? = null
+  private val touchDeduper = TouchEventDeduper()
 
-  /**
-   * The content height from the container view.
-   * Set by the host view when content size changes.
-   */
-  var contentHeight: Int = 0
+  private val eventDispatcher
+    get() = delegate?.eventDispatcher
+
+  // Detent Configuration
+  override var maxContentHeight: Int? = null
+  override var maxContentWidth: Int? = null
+  override var anchor: TrueSheetAnchor = TrueSheetAnchor.CENTER
+  override var anchorOffset: Int = DEFAULT_ANCHOR_OFFSET.dpToPx().toInt()
+  override var detents: MutableList<Double> = mutableListOf(0.5, 1.0)
+
+  // Appearance Configuration
+  var dimmed = true
+  var dimmedDetentIndex = 0
+  override var grabber: Boolean = true
+  override var grabberOptions: GrabberOptions? = null
+  override var accessibilityOptions: AccessibilityOptions? = null
+  override var sheetBackgroundColor: Int? = null
+  var insetAdjustment: TrueSheetInsetAdjustment = TrueSheetInsetAdjustment.AUTOMATIC
+
+  var scrollableOptions: ScrollableOptions? = null
+    set(value) {
+      field = value
+      behavior?.scrollingExpandsSheet = value?.scrollingExpandsSheet ?: true
+    }
+
+  // React tag of the user-provided scrollable within the content (see the scrollableRef prop)
+  var scrollableHandle: Int = -1
+
+  override var sheetCornerRadius: Float = DEFAULT_CORNER_RADIUS.dpToPx()
+    set(value) {
+      field = if (value < 0) DEFAULT_CORNER_RADIUS.dpToPx() else value
+      if (isPresented) sheetView?.setupBackground()
+    }
+
+  override var sheetElevation: Float = -1f
+    set(value) {
+      field = value
+      if (isPresented) sheetView?.setupElevation()
+    }
 
   var dismissible: Boolean = true
     set(value) {
       field = value
-      dialog?.apply {
-        setCanceledOnTouchOutside(value)
-        setCancelable(value)
-        behavior.isHideable = value
+      behavior?.isHideable = value
+    }
+
+  override var draggable: Boolean = true
+    set(value) {
+      field = value
+      behavior?.isDraggable = value
+      if (isPresented) sheetView?.setupGrabber()
+    }
+
+  // =============================================================================
+  // MARK: - Computed Properties
+  // =============================================================================
+
+  // Behavior
+  private val behavior: TrueSheetBottomSheetBehavior<TrueSheetBottomSheetView>?
+    get() = sheetView?.behavior
+
+  internal val containerView: TrueSheetContainerView?
+    get() = if (this.isNotEmpty()) getChildAt(0) as? TrueSheetContainerView else null
+
+  // Screen Measurements
+  override val screenHeight: Int
+    get() = ScreenUtils.getScreenHeight(reactContext)
+
+  val screenWidth: Int
+    get() = ScreenUtils.getScreenWidth(reactContext)
+
+  // Cached per layout/configuration pass — the WindowManager and
+  // rootWindowInsets queries behind these allocate, and they're read many
+  // times per animation frame (position emission, detent interpolation,
+  // stacked sheet sync)
+  private var cachedRealScreenHeight: Int = 0
+  private var cachedInsets: Insets? = null
+
+  private fun invalidateScreenMetrics() {
+    cachedRealScreenHeight = 0
+    cachedInsets = null
+  }
+
+  // Includes system bars for accurate positioning
+  override val realScreenHeight: Int
+    get() {
+      if (cachedRealScreenHeight == 0) {
+        cachedRealScreenHeight = ScreenUtils.getRealScreenHeight(reactContext)
       }
+      return cachedRealScreenHeight
     }
 
-  var cornerRadius: Float = 0f
-  var sheetBackgroundColor: Int = Color.WHITE
-  var detents = mutableListOf(0.5, 1.0)
+  private val insets: Insets
+    get() = cachedInsets ?: ScreenUtils.getInsets(reactContext).also { cachedInsets = it }
+
+  // Content Measurements
+  // Cached values used during dismiss when container is unmounted
+  private var cachedContentHeight: Int = 0
+  private var cachedHeaderHeight: Int = 0
+  private var cachedFooterHeight: Int = 0
+  private var cachedPeekContentHeight: Int = 0
 
-  private var windowAnimation: Int = 0
+  override val contentHeight: Int
+    get() = containerView?.contentHeight ?: cachedContentHeight
 
-  init {
-    maxScreenHeight = ScreenUtils.getScreenHeight(reactContext, edgeToEdgeEnabled)
-    jSPointerDispatcher = JSPointerDispatcher(this)
+  override val headerHeight: Int
+    get() = containerView?.headerHeight ?: cachedHeaderHeight
+
+  override var absoluteHeader: Boolean = false
+
+  override val footerHeight: Int
+    get() = containerView?.footerHeight ?: cachedFooterHeight
+
+  override var absoluteFooter: Boolean = false
+
+  override val peekContentHeight: Int
+    get() = containerView?.peekContentHeight ?: cachedPeekContentHeight
+
+  // Insets
+  // Target keyboard height used for detent calculations
+  override val keyboardInset: Int
+    get() = keyboardObserver?.targetHeight ?: 0
+
+  // Current animated keyboard height for positioning
+  private val currentKeyboardInset: Int
+    get() = keyboardObserver?.currentHeight ?: 0
+
+  private val isKeyboardTransitioning: Boolean
+    get() = keyboardObserver?.isTransitioning ?: false
+
+  // Keyboard is up or animating — detents are (or are about to be) keyboard-shifted
+  val isKeyboardActive: Boolean
+    get() = keyboardInset > 0 || isKeyboardTransitioning
+
+  // While the keyboard holds the sheet up, the keyboard-free first detent is the
+  // collapsed stop — landing there dismisses the keyboard, and (when dismissible)
+  // dragging more than half its height below it hides the sheet too, like iOS.
+  override val hasKeyboardFloor: Boolean
+    get() = keyboardInset > 0
+
+  // The detent JS last heard about — the keyboard expansion is never reported
+  private val knownDetentIndex: Int
+    get() = if (detentIndexBeforeKeyboard >= 0) detentIndexBeforeKeyboard else currentDetentIndex
+
+  fun isFocusedViewWithinSheet(): Boolean {
+    val sheet = sheetView ?: return false
+    return keyboardObserver?.isFocusedViewWithinSheet(sheet) ?: false
   }
 
-  // ==================== Lifecycle ====================
+  val bottomInset: Int
+    get() = if (edgeToEdgeEnabled) insets.bottom else 0
 
-  /**
-   * Creates the dialog instance. Should be called when container view is mounted.
-   */
-  fun createDialog() {
-    if (dialog != null) return
+  override val topInset: Int
+    get() = if (edgeToEdgeEnabled) insets.top else 0
 
-    val style = if (edgeToEdgeEnabled) {
-      com.lodev09.truesheet.R.style.TrueSheetEdgeToEdgeEnabledDialog
-    } else {
-      0
+  override val contentBottomInset: Int
+    get() = if (insetAdjustment == TrueSheetInsetAdjustment.AUTOMATIC) bottomInset else 0
+
+  @Suppress("KotlinConstantConditions", "SimplifyBooleanWithConstants")
+  private val edgeToEdgeEnabled: Boolean
+    get() {
+      val defaultEnabled = Build.VERSION.SDK_INT >= 36
+      return BuildConfig.EDGE_TO_EDGE_ENABLED || defaultEnabled
     }
 
-    dialog = BottomSheetDialog(reactContext, style).apply {
-      setContentView(this@TrueSheetViewController)
+  // Sheet State
+  val isSettling: Boolean
+    get() = behavior?.state == BottomSheetBehavior.STATE_SETTLING
 
-      // Setup window params
-      window?.apply {
-        // Store current windowAnimation value to toggle later
-        windowAnimation = attributes.windowAnimations
-      }
+  val isExpanded: Boolean
+    get() {
+      val sheetTop = sheetView?.top ?: return false
+      return sheetTop <= topInset
+    }
 
-      // Setup dialog lifecycle listeners
-      setupDialogListeners(this)
+  val currentTranslationY: Int
+    get() = sheetView?.translationY?.toInt() ?: 0
 
-      // Setup bottom sheet behavior callbacks
-      setupBottomSheetBehavior(this)
+  override val isTopmostSheet: Boolean
+    get() {
+      val hostView = delegate as? TrueSheetView ?: return true
+      return TrueSheetStackManager.isTopmostSheet(hostView)
+    }
+
+  private val dimViews: List<TrueSheetDimView>
+    get() = listOfNotNull(dimView, parentDimView)
+
+  val isDimmedAtCurrentDetent: Boolean
+    get() = isDimmedAtDetentIndex(currentDetentIndex)
+
+  fun isDimmedAtDetentIndex(index: Int): Boolean = dimmed && index >= dimmedDetentIndex
 
-      // Apply initial properties
-      setCanceledOnTouchOutside(dismissible)
-      setCancelable(dismissible)
-      behavior.isHideable = dismissible
+  // =============================================================================
+  // MARK: - Sheet Creation & Cleanup
+  // =============================================================================
 
-      // Apply background color and corner radius
-      setupBackground()
+  fun createSheet() {
+    if (coordinatorLayout != null) return
+
+    // Create coordinator layout
+    coordinatorLayout = TrueSheetCoordinatorLayout(reactContext).apply {
+      delegate = this@TrueSheetViewController
     }
-  }
 
-  /**
-   * Cleans up the dialog instance. Called when dismissed to ensure clean state.
-   */
-  private fun cleanupDialog() {
-    dialog?.apply {
-      setOnShowListener(null)
-      setOnCancelListener(null)
-      setOnDismissListener(null)
+    sheetView = TrueSheetBottomSheetView(reactContext).apply {
+      delegate = this@TrueSheetViewController
     }
+  }
+
+  private fun cleanupSheet() {
+    cleanupKeyboardObserver()
+    sheetView?.animate()?.cancel()
+
+    // Cleanup dim views
+    dimView?.detach()
+    dimView = null
+    parentDimView?.detach()
+    parentDimView = null
 
-    // Remove this view from its parent to allow re-attachment on next presentation
-    sheetContainer?.removeView(this)
+    // Cleanup snapshot
+    removeSheetSnapshot()
 
-    dialog = null
-    isDragging = false
+    // Detach content from sheet
+    sheetView?.removeView(this)
+
+    containerView?.cleanupKeyboardHandler()
+    coordinatorLayout = null
+    sheetView = null
+
+    interactionState = InteractionState.Idle
+    hasPendingSizeChange = false
+    isBeingDismissed = false
     isPresented = false
+    isSheetVisible = false
+    wasHiddenByScreen = false
+    cachedContentHeight = 0
+    cachedHeaderHeight = 0
+    isPresentAnimating = false
+    lastEmittedPositionPx = -1
+    detentIndexBeforeKeyboard = -1
+    pendingDetentIndex = -1
+    isKeyboardDismissProgrammatic = false
+    focusedViewBeforeBlur = null
+    shouldAnimatePresent = true
   }
 
-  /**
-   * Setup dialog lifecycle listeners
-   */
-  private fun setupDialogListeners(dialog: BottomSheetDialog) {
-    // Setup listener when the dialog has been presented
-    dialog.setOnShowListener {
-      isPresented = true
-
-      // Re-enable animation
-      resetAnimation()
-
-      // Wait for the sheet to settle before notifying didPresent
-      // The sheet animates to its final position after onShow fires
-      sheetContainer?.post {
-        // Notify delegate with the settled position
-        val detentInfo = getDetentInfoForIndex(currentDetentIndex)
-        delegate?.viewControllerDidPresent(detentInfo.index, detentInfo.position)
-
-        // Emit position change with transitioning=true so Reanimated can animate it
-        delegate?.viewControllerDidChangePosition(detentInfo.index, detentInfo.position, transitioning = true)
-
-        // Resolve the present promise
-        presentPromise?.let { promise ->
-          promise()
-          presentPromise = null
-        }
+  private var snapshotView: View? = null
 
-        // Initialize footer position after layout is complete
-        positionFooter()
-      }
+  fun createSheetSnapshot() {
+    if (!isPresented) return
+    val sheet = sheetView ?: return
+    if (sheet.width <= 0 || sheet.height <= 0) return
+
+    val bitmap = createBitmap(sheet.width, sheet.height)
+    val canvas = Canvas(bitmap)
+    sheet.draw(canvas)
+
+    val snapshot = ImageView(reactContext).apply {
+      setImageBitmap(bitmap)
+      layoutParams = LayoutParams(sheet.width, sheet.height)
     }
 
-    // Setup listener when the dialog is about to be dismissed
-    dialog.setOnCancelListener {
-      // Notify delegate
-      delegate?.viewControllerWillDismiss()
+    sheet.addView(snapshot, 0)
+    snapshotView = snapshot
+  }
+
+  fun removeSheetSnapshot() {
+    snapshotView?.let {
+      (it as? ImageView)?.setImageDrawable(null)
+      sheetView?.removeView(it)
     }
+    snapshotView = null
+  }
 
-    // Setup listener when the dialog has been dismissed
-    dialog.setOnDismissListener {
-      // Resolve the dismiss promise
-      dismissPromise?.let { promise ->
-        promise()
-        dismissPromise = null
-      }
+  // =============================================================================
+  // MARK: - TrueSheetCoordinatorLayout.Delegate
+  // =============================================================================
 
-      // Notify delegate
-      delegate?.viewControllerDidDismiss()
+  override fun coordinatorLayoutDidLayout(changed: Boolean) {
+    if (changed) invalidateScreenMetrics()
 
-      // Clean up the dialog for next presentation
-      cleanupDialog()
+    // Reposition footer when layout changes
+    if (isPresented && changed) {
+      positionFooter()
     }
   }
 
-  /**
-   * Setup bottom sheet behavior callbacks
-   */
-  private fun setupBottomSheetBehavior(dialog: BottomSheetDialog) {
-    dialog.behavior.addBottomSheetCallback(
-      object : BottomSheetBehavior.BottomSheetCallback() {
-        override fun onSlide(sheetView: View, slideOffset: Float) {
-          val behavior = behavior ?: return
-
-          // Emit position change event continuously during slide
-          // Set transitioning=false during drag to get real-time position updates
-          val detentInfo = getCurrentDetentInfo(sheetView)
-          delegate?.viewControllerDidChangePosition(detentInfo.index, detentInfo.position, transitioning = false)
-
-          when (behavior.state) {
-            // For consistency with iOS, we consider SETTLING as dragging change
-            BottomSheetBehavior.STATE_DRAGGING,
-            BottomSheetBehavior.STATE_SETTLING -> handleDragChange(sheetView)
-
-            else -> { }
-          }
+  override fun coordinatorLayoutDidChangeConfiguration() {
+    invalidateScreenMetrics()
+    if (!isPresented) return
 
-          // Update footer position during slide
-          positionFooter(slideOffset)
-        }
+    sheetView?.updateGravity()
+    updateBehaviorMaxWidth()
+    updateStateDimensions()
+    sheetView?.let { emitChangePositionDelegate(it.top, realtime = false) }
+  }
 
-        override fun onStateChanged(sheetView: View, newState: Int) {
-          // Handle STATE_HIDDEN before checking isPresented
-          // This ensures we can dismiss even if dialog state gets out of sync
-          if (newState == BottomSheetBehavior.STATE_HIDDEN) {
-            dismiss()
-            return
-          }
+  override fun findScrollView(): ViewGroup? = containerView?.contentView?.findScrollView()
+  override fun findSheetView(): TrueSheetBottomSheetView? = sheetView
 
-          if (!isPresented) return
+  override fun coordinatorLayoutDidPullDown(overdragPx: Int, keyboardWasVisible: Boolean) {
+    if (!isPresented || dismissible || !draggable) return
+    val sheet = sheetView ?: return
 
-          when (newState) {
-            // When changed to dragging, we know that the drag has started
-            BottomSheetBehavior.STATE_DRAGGING -> handleDragBegin(sheetView)
+    // Only a pull clamped at the lowest stop is a blocked drag-to-dismiss — a
+    // child that swallowed the gesture higher up isn't
+    val lowestTop = detentCalculator.getLowestSheetTop()
+    if (sheet.top < lowestTop) return
 
-            // Either of the following state determines drag end
-            BottomSheetBehavior.STATE_EXPANDED,
-            BottomSheetBehavior.STATE_COLLAPSED,
-            BottomSheetBehavior.STATE_HALF_EXPANDED -> handleDragEnd(newState)
+    if (keyboardWasVisible) {
+      // A sheet that couldn't move at all (first detent already full height) never
+      // began a drag, so the keyboard is still up — dismiss it here
+      if (hasKeyboardFloor && !isKeyboardDismissProgrammatic) commitDetentAndDismissKeyboard(0, sheet)
 
-            else -> {}
-          }
-        }
-      }
-    )
+      // Past the floor by the distance that would hide a dismissible sheet, like iOS
+      val floorHeight = realScreenHeight - lowestTop
+      if (overdragPx < floorHeight * HIDE_THRESHOLD) return
+    }
+
+    delegate?.viewControllerDidAttemptDismiss()
   }
 
-  // ==================== Presentation ====================
+  // =============================================================================
+  // MARK: - TrueSheetDimViewDelegate
+  // =============================================================================
 
-  /**
-   * Present the sheet.
-   */
-  fun present(detentIndex: Int, animated: Boolean = true) {
-    val dialog = this.dialog ?: run {
-      // Dialog not created yet - this shouldn't happen but handle gracefully
+  override fun dimViewDidTap() {
+    val hostView = delegate as? TrueSheetView ?: return
+
+    val children = TrueSheetStackManager.getSheetsAbove(hostView)
+    val topmostChild = children.firstOrNull()?.viewController
+
+    // If topmost child is dimmed, only handle that child
+    if (topmostChild?.isDimmedAtCurrentDetent == true) {
+      if (topmostChild.dismissible) {
+        topmostChild.dismiss(animated = true)
+      }
       return
     }
 
-    currentDetentIndex = detentIndex
-    setupDimmedBackground(detentIndex)
+    // Pass through to parent - dismiss all if possible
+    val allDismissible = dismissible && children.all { it.viewController.dismissible }
+    if (allDismissible) {
+      children.forEach { it.viewController.dismiss(animated = true) }
+    }
 
-    if (isPresented) {
-      // For consistency with iOS, we notify detent change immediately
-      // when already presented (not waiting for state to change)
-      val detentInfo = getDetentInfoForIndex(detentIndex)
-      delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position)
+    if (dismissible) {
+      dismiss(animated = true)
+    } else if (parentSheetView == null && isDimmedAtCurrentDetent && dimmedDetentIndex > 0) {
+      setStateForDetentIndex(dimmedDetentIndex - 1)
+    }
+  }
 
-      // Note: onSlide will be called during resize animation, no need to emit position change here
-      setStateForDetentIndex(detentIndex)
+  // =============================================================================
+  // MARK: - TrueSheetBottomSheetViewDelegate - Grabber Tap
+  // =============================================================================
+
+  override fun bottomSheetViewDidTapGrabber() {
+    val nextIndex = (currentDetentIndex + 1) % detents.size
+    if (nextIndex == 0 && detents.size == 1) {
+      if (dismissible) {
+        dismiss(animated = true)
+      } else {
+        delegate?.viewControllerDidAttemptDismiss()
+      }
     } else {
-      // Reset drag state before presenting
-      isDragging = false
+      setStateForDetentIndex(nextIndex)
+    }
+  }
 
-      setupSheetDetents()
-      setStateForDetentIndex(detentIndex)
+  override fun bottomSheetViewDidAccessibilityIncrement() {
+    if (currentDetentIndex < detents.size - 1) {
+      setStateForDetentIndex(currentDetentIndex + 1)
+    }
+  }
 
-      // Notify delegate before showing
-      val detentInfo = getDetentInfoForIndex(detentIndex)
-      delegate?.viewControllerWillPresent(detentInfo.index, detentInfo.position)
+  override fun bottomSheetViewDidAccessibilityDecrement() {
+    if (currentDetentIndex > 0) {
+      setStateForDetentIndex(currentDetentIndex - 1)
+    } else if (dismissible) {
+      dismiss(animated = true)
+    } else {
+      delegate?.viewControllerDidAttemptDismiss()
+    }
+  }
 
-      if (!animated) {
-        // Disable animation
-        dialog.window?.setWindowAnimations(0)
-      }
+  // =============================================================================
+  // MARK: - BottomSheetCallback
+  // =============================================================================
 
-      dialog.show()
+  private val sheetCallback = object : BottomSheetBehavior.BottomSheetCallback() {
+    override fun onStateChanged(sheetView: View, newState: Int) {
+      handleStateChanged(sheetView, newState)
+    }
+
+    override fun onSlide(sheetView: View, slideOffset: Float) {
+      handleSlide(sheetView)
     }
   }
 
-  /**
-   * Dismiss the sheet.
-   */
-  fun dismiss() {
-    this.post {
-      // Emit position change with transitioning=true to animate dismissal
-      // Use maxScreenHeight as the off-screen position (sheet slides down off screen)
-      val offScreenPosition = maxScreenHeight.pxToDp()
-      delegate?.viewControllerDidChangePosition(currentDetentIndex, offScreenPosition, transitioning = true)
+  private fun handleStateChanged(sheetView: View, newState: Int) {
+    if (newState == BottomSheetBehavior.STATE_HIDDEN) {
+      if (isBeingDismissed) return
+      isBeingDismissed = true
+      dismissKeyboard()
+      emitWillDismissEvents()
+      finishDismiss()
+      return
     }
 
-    dialog?.dismiss()
+    if (!isPresented) return
+
+    when (newState) {
+      BottomSheetBehavior.STATE_DRAGGING -> handleDragBegin(sheetView)
+
+      BottomSheetBehavior.STATE_SETTLING -> handleSettling(sheetView)
+
+      BottomSheetBehavior.STATE_EXPANDED,
+      BottomSheetBehavior.STATE_COLLAPSED,
+      BottomSheetBehavior.STATE_HALF_EXPANDED -> handleStateSettled(sheetView, newState)
+
+      else -> {}
+    }
   }
 
-  // ==================== Configuration ====================
+  private fun handleSlide(sheetView: View) {
+    // Skip during dismiss animation
+    if (isBeingDismissed) return
 
-  /**
-   * Setup sheet detents based on the detent preference.
-   */
-  fun setupSheetDetents() {
-    val behavior = this.behavior ?: return
+    val behavior = behavior ?: return
 
-    // Configure sheet sizes
-    behavior.apply {
-      skipCollapsed = false
-      isFitToContents = true
+    when (behavior.state) {
+      BottomSheetBehavior.STATE_DRAGGING -> handleDragChange(sheetView)
 
-      // m3 max width 640dp
-      maxWidth = 640.0.dpToPx().toInt()
+      BottomSheetBehavior.STATE_SETTLING -> {
+        handleDragChange(sheetView)
+        dismissKeyboardForSettleTarget(sheetView)
+      }
 
-      when (detents.size) {
-        1 -> {
-          val detentHeight = getDetentHeight(detents[0])
-          maxHeight = detentHeight
-          skipCollapsed = true
-        }
+      else -> { }
+    }
 
-        2 -> {
-          val peekHeight = getDetentHeight(detents[0])
-          val maxHeightValue = getDetentHeight(detents[1])
-          maxHeight = maxHeightValue
-          setPeekHeight(peekHeight, isPresented)
-        }
+    emitChangePositionDelegate(sheetView.top)
 
-        3 -> {
-          // Enables half expanded
-          isFitToContents = false
+    // Drive the parent's stack translation from our actual frame position —
+    // an independently-timed animation lags behind (e.g. auto detent shrink)
+    // and reveals the parent above this sheet's top edge. Skipped while
+    // dragging so the parent stays put during drag-to-dismiss, and while the
+    // keyboard is active so growing for it doesn't move the parent (like iOS).
+    if (!isPresentAnimating && interactionState !is InteractionState.Dragging && !isKeyboardActive) {
+      syncParentTranslation(sheetView.top)
+    }
 
-          val peekHeightValue = getDetentHeight(detents[0])
-          val middleDetentHeight = getDetentHeight(detents[1])
-          val maxHeightValue = getDetentHeight(detents[2])
+    // Position on every slide frame — during keyboard transitions the IME
+    // animation callbacks are sparser than the sheet's settle frames, and the
+    // footer rides the sheet between them, jittering against the keyboard.
+    // positionFooter derives from current state, so double-driving it with
+    // keyboardDidChangeHeight is harmless.
+    positionFooter()
 
-          setPeekHeight(peekHeightValue, isPresented)
-          maxHeight = maxHeightValue
-          expandedOffset = sheetTopInset
-          halfExpandedRatio = minOf(middleDetentHeight.toFloat() / maxScreenHeight.toFloat(), 1.0f)
+    if (!isKeyboardTransitioning) {
+      updateDimAmount(sheetView.top)
+    }
+  }
+
+  private fun handleStateSettled(sheetView: View, newState: Int) {
+    if (interactionState is InteractionState.Reconfiguring) return
+
+    // A release already at a stop settles without a slide frame
+    keyboardSettleStartTop = -1
+
+    // Sheet has reached a stable state — any in-flight resize target is now stale,
+    // whether settled at the target, interrupted by drag, or superseded.
+    pendingDetentIndex = -1
+
+    val index = detentCalculator.getDetentIndexForState(newState) ?: run {
+      // Unmapped settle — end any drag anyway so deferred size changes aren't
+      // dropped forever (a leaked Dragging state skips every reconfigure)
+      if (interactionState is InteractionState.Dragging) {
+        interactionState = InteractionState.Idle
+      }
+      flushPendingSizeChange()
+      return
+    }
+    val position = getPositionDpForView(sheetView)
+    val detentInfo = DetentInfo(index, position)
+
+    // Handle present animation completion
+    if (isPresentAnimating) {
+      isPresentAnimating = false
+      finishPresent()
+      return
+    }
+
+    val wasDragging = interactionState is InteractionState.Dragging
+
+    when (interactionState) {
+      is InteractionState.Dragging -> {
+        val detent = detentCalculator.getDetentValueForIndex(detentInfo.index)
+        delegate?.viewControllerDidDragEnd(detentInfo.index, detentInfo.position, detent)
+
+        // Skip detent change if keyboard inset is still active — the keyboard floor
+        // landing below commits the detent instead.
+        if (keyboardInset == 0) {
+          val changed = detentInfo.index != knownDetentIndex
+          detentIndexBeforeKeyboard = -1
+          if (detentInfo.index != currentDetentIndex) {
+            currentDetentIndex = detentInfo.index
+            setupDimmedBackground()
+          }
+          if (changed) {
+            delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+            this@TrueSheetViewController.sheetView?.updateGrabberAccessibilityValue(detentInfo.index, detents.size)
+          }
         }
+
+        interactionState = InteractionState.Idle
       }
 
-      // Force a layout update when sheet is presented (e.g., during rotation)
-      // This ensures the container respects the new maxHeight constraint
-      if (isPresented) {
-        sheetContainer?.apply {
-          val params = layoutParams
-          params.height = maxHeight
-          layoutParams = params
+      else -> {
+        if (detentInfo.index != currentDetentIndex) {
+          currentDetentIndex = detentInfo.index
+          if (!isKeyboardTransitioning) {
+            val detent = detentCalculator.getDetentValueForIndex(detentInfo.index)
+            delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+          }
+          this@TrueSheetViewController.sheetView?.updateGrabberAccessibilityValue(detentInfo.index, detents.size)
         }
       }
     }
+
+    if (hasKeyboardFloor && wasDragging && newState != BottomSheetBehavior.STATE_EXPANDED) {
+      // Dragged down onto a keyboard-free stop (the floor or the keyboard detent) —
+      // dismiss the keyboard and commit that detent. keyboardWillHide reconfigures
+      // the detents (and the container) to it.
+      commitDetentAndDismissKeyboard(index, sheetView)
+    } else {
+      // Settled — resize the container to the settled detent (applies deferred shrinks)
+      updateStateDimensions()
+    }
+
+    if (!isKeyboardTransitioning) {
+      updateDimAmount(animated = true)
+    }
+
+    TrueSheetStackManager.updateBackgroundAccessibility()
+
+    flushPendingSizeChange()
   }
 
-  /**
-   * Setup background color and corner radius.
-   */
-  fun setupBackground() {
-    sheetContainer?.apply {
-      val outerRadii = floatArrayOf(
-        cornerRadius,
-        cornerRadius,
-        cornerRadius,
-        cornerRadius,
-        0f,
-        0f,
-        0f,
-        0f
-      )
+  private fun flushPendingSizeChange() {
+    if (!hasPendingSizeChange) return
+    hasPendingSizeChange = false
+    setupSheetDetentsForSizeChange()
+  }
+
+  // =============================================================================
+  // MARK: - Screen Visibility
+  // =============================================================================
 
-      val background = ShapeDrawable(RoundRectShape(outerRadii, null, null))
-      background.paint.color = sheetBackgroundColor
+  private fun setSheetVisibility(visible: Boolean) {
+    coordinatorLayout?.visibility = if (visible) VISIBLE else GONE
+    dimViews.forEach { it.visibility = if (visible) VISIBLE else INVISIBLE }
+  }
 
-      this.background = background
-      this.clipToOutline = true
+  internal fun hideForScreen() {
+    val sheet = sheetView ?: run {
+      RNLog.e(reactContext, "TrueSheet: sheetView is null in hideForScreen")
+      return
     }
+
+    isSheetVisible = false
+    wasHiddenByScreen = true
+    TrueSheetStackManager.updateBackgroundAccessibility()
+    delegate?.viewControllerDidChangeVisibility(false)
+    dimViews.forEach { it.animate().alpha(0f).setDuration(SCREEN_FADE_DURATION).start() }
+    sheet.animate()
+      .alpha(0f)
+      .setDuration(SCREEN_FADE_DURATION)
+      .withEndAction {
+        setSheetVisibility(false)
+      }
+      .start()
+
+    // This will hide parent sheets first
+    parentSheetView?.viewController?.hideForScreen()
+  }
+
+  internal fun showAfterScreen() {
+    isSheetVisible = true
+    delegate?.viewControllerDidChangeVisibility(true)
+    setSheetVisibility(true)
+    sheetView?.alpha = 1f
+    updateDimAmount(animated = true)
+    TrueSheetStackManager.updateBackgroundAccessibility()
   }
 
   /**
-   * Setup dimmed sheet.
-   * `dimmedIndex` will further customize the dimming behavior.
+   * Re-applies hidden state after returning from background.
+   * Android may restore visibility on activity resume, so we need to hide it again.
    */
-  fun setupDimmedBackground(detentIndex: Int) {
-    val dialog = this.dialog ?: return
-    dialog.window?.apply {
-      val view = findViewById<View>(com.google.android.material.R.id.touch_outside)
-
-      if (dimmed && detentIndex >= dimmedIndex) {
-        // Remove touch listener
-        view.setOnTouchListener(null)
-
-        // Add the dimmed background
-        setFlags(
-          WindowManager.LayoutParams.FLAG_DIM_BEHIND,
-          WindowManager.LayoutParams.FLAG_DIM_BEHIND
-        )
-
-        dialog.setCanceledOnTouchOutside(dismissible)
-      } else {
-        // Override the background touch and pass it to the components outside
-        view.setOnTouchListener { v, event ->
-          event.setLocation(event.rawX - v.x, event.rawY - v.y)
-          reactContext.currentActivity?.dispatchTouchEvent(event)
-          false
-        }
+  fun reapplyHiddenState() {
+    if (!wasHiddenByScreen) return
+    setSheetVisibility(false)
+  }
+
+  // =============================================================================
+  // MARK: - Presentation
+  // =============================================================================
+
+  fun present(detentIndex: Int, animated: Boolean = true) {
+    val coordinator = this.coordinatorLayout ?: return
+    val sheet = this.sheetView ?: return
+    if (isPresented) return
+
+    invalidateScreenMetrics()
+    shouldAnimatePresent = animated
+    currentDetentIndex = detentIndex
+    interactionState = InteractionState.Idle
+
+    // Setup sheet in coordinator layout
+    setupSheetInCoordinator(coordinator, sheet)
 
-        // Remove the dimmed background
-        clearFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND)
+    emitWillPresentEvents()
 
-        dialog.setCanceledOnTouchOutside(false)
+    setupSheetDetents()
+    setupDimmedBackground()
+    setupKeyboardObserver()
+
+    sheet.setupBackground()
+    sheet.setupElevation()
+    sheet.setupGrabber()
+    sheet.setupAccessibility()
+
+    if (shouldAnimatePresent) {
+      isPresentAnimating = true
+      post { setStateForDetentIndex(currentDetentIndex) }
+    } else {
+      setStateForDetentIndex(currentDetentIndex)
+      post {
+        emitChangePositionDelegate(detentCalculator.getSheetTopForDetentIndex(currentDetentIndex))
+        updateDimAmount()
+        finishPresent()
       }
     }
+
+    isPresented = true
+    isSheetVisible = true
   }
 
-  fun resetAnimation() {
-    dialog?.window?.apply {
-      setWindowAnimations(windowAnimation)
+  fun resize(detentIndex: Int) {
+    if (!isPresented) return
+
+    // Commit the new index so keyboardWillHide restores to it instead of the stale
+    // one; the sheet keeps avoiding the keyboard meanwhile
+    if (detentIndexBeforeKeyboard >= 0) {
+      detentIndexBeforeKeyboard = detentIndex
+      if (hasKeyboardFloor) {
+        resizePromise?.invoke()
+        resizePromise = null
+        return
+      }
     }
+
+    pendingDetentIndex = detentIndex
+    updateStateDimensions(deferShrink = true)
+    setupDimmedBackground()
+    setStateForDetentIndex(detentIndex)
+    resizePromise?.invoke()
+    resizePromise = null
   }
 
-  fun positionFooter(slideOffset: Float? = null) {
-    val footer = footerView ?: return
-    val bottomSheet = bottomSheetView ?: return
-    val footerHeight = footer.height
+  private fun setupSheetInCoordinator(coordinator: TrueSheetCoordinatorLayout, sheet: TrueSheetBottomSheetView) {
+    // Add this controller as content to the sheet
+    (parent as? ViewGroup)?.removeView(this)
+    sheet.addView(this)
+
+    // Create layout params with behavior
+    val params = sheet.createLayoutParams()
 
-    val bottomSheetY = ScreenUtils.getScreenY(bottomSheet)
+    @Suppress("UNCHECKED_CAST")
+    val behavior = params.behavior as TrueSheetBottomSheetBehavior<TrueSheetBottomSheetView>
 
-    // Calculate footer Y position based on bottom sheet position
-    var footerY = (maxScreenHeight - bottomSheetY - footerHeight).toFloat()
+    // Configure behavior
+    behavior.isHideable = true
+    behavior.isDraggable = draggable
+    behavior.scrollingExpandsSheet = scrollableOptions?.scrollingExpandsSheet ?: true
+    behavior.state = BottomSheetBehavior.STATE_HIDDEN
+    behavior.addBottomSheetCallback(sheetCallback)
 
-    // Animate footer down with sheet when below peek height
-    if (slideOffset != null && slideOffset < 0) {
-      footerY -= (footerHeight * slideOffset)
+    // Add sheet to coordinator
+    coordinator.addView(sheet, params)
+  }
+
+  fun dismiss(animated: Boolean = true) {
+    if (isBeingDismissed) return
+
+    isBeingDismissed = true
+    dismissKeyboard()
+    emitWillDismissEvents()
+
+    if (animated) {
+      animateDismiss()
+    } else {
+      emitChangePositionDelegate(realScreenHeight)
+      finishDismiss()
     }
+  }
+
+  private fun dismissKeyboard() {
+    isKeyboardDismissProgrammatic = true
+    KeyboardUtils.dismiss(reactContext)
 
-    // Clamp footer position to prevent it from going off screen when positioning at the top
-    // This happens when fullScreen is enabled in edge-to-edge mode
-    val statusBarHeight = ScreenUtils.getStatusBarHeight(reactContext)
-    val maxAllowedY = (maxScreenHeight - statusBarHeight - footerHeight).toFloat()
-    footer.y = minOf(footerY, maxAllowedY)
+    // Clear focus from any focused view within the sheet to prevent
+    // Android from autofocusing the next focusable view on the main
+    // screen when the sheet is removed from the hierarchy.
+    sheetView?.findFocus()?.clearFocus()
   }
 
-  /**
-   * Set the state based for the given detent index.
-   */
-  fun setStateForDetentIndex(index: Int) {
-    behavior?.state = getStateForDetentIndex(index)
+  fun handleBackPress() {
+    if (dismissible) {
+      dismiss(animated = true)
+    }
   }
 
-  fun setSoftInputMode(mode: Int) {
-    dialog?.window?.setSoftInputMode(mode)
+  private fun animateDismiss() {
+    val sheet = sheetView ?: run {
+      finishDismiss()
+      return
+    }
+
+    sheet.animate()
+      .y(realScreenHeight.toFloat())
+      .setDuration(DISMISS_DURATION)
+      .setInterpolator(android.view.animation.AccelerateInterpolator())
+      .setUpdateListener { updateSheetVisuals(sheet.y.toInt()) }
+      .withEndAction { finishDismiss() }
+      .start()
   }
 
-  // ==================== Drag Handling ====================
+  private fun finishPresent() {
+    // Restore isHideable to actual value after present animation
+    behavior?.isHideable = dismissible
 
-  /**
-   * Get current detent info from sheet view position
-   */
-  private fun getCurrentDetentInfo(sheetView: View): DetentInfo {
-    // Get the Y position in screen coordinates (like iOS presentedView.frame.origin.y)
-    val screenY = ScreenUtils.getScreenY(sheetView)
-    val position = screenY.pxToDp()
-    return DetentInfo(currentDetentIndex, position)
+    containerView?.setupKeyboardHandler()
+
+    val (index, position, detent) = getDetentInfoWithValue(currentDetentIndex)
+    delegate?.viewControllerDidPresent(index, position, detent)
+    parentSheetView?.viewControllerDidBlur()
+    delegate?.viewControllerDidFocus()
+    sheetView?.updateGrabberAccessibilityValue(index, detents.size)
+
+    TrueSheetStackManager.updateBackgroundAccessibility()
+    // Move accessibility focus into the sheet
+    sheetView?.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED)
+
+    presentPromise?.invoke()
+    presentPromise = null
   }
 
-  /**
-   * Handle drag begin
-   */
-  private fun handleDragBegin(sheetView: View) {
-    val detentInfo = getCurrentDetentInfo(sheetView)
-    delegate?.viewControllerDidDragBegin(detentInfo.index, detentInfo.position)
-    isDragging = true
+  private fun finishDismiss() {
+    TrueSheetStackManager.updateBackgroundAccessibility()
+    restoreFocusedView()
+    emitDidDismissEvents()
+    cleanupSheet()
   }
 
-  /**
-   * Handle drag change
-   */
-  private fun handleDragChange(sheetView: View) {
-    if (!isDragging) return
+  // =============================================================================
+  // MARK: - Sheet Configuration
+  // =============================================================================
 
-    val detentInfo = getCurrentDetentInfo(sheetView)
-    delegate?.viewControllerDidDragChange(detentInfo.index, detentInfo.position)
-  }
+  fun setupSheetDetents(applyState: Boolean = true) {
+    val behavior = this.behavior ?: run {
+      RNLog.e(reactContext, "TrueSheet: behavior is null in setupSheetDetents")
+      return
+    }
 
-  /**
-   * Handle drag end
-   */
-  private fun handleDragEnd(state: Int) {
-    if (!isDragging) return
-
-    // For consistency with iOS,
-    // we only handle state changes after dragging.
-    //
-    // Changing detent programmatically is handled via the present method.
-    val detentInfo = getDetentInfoForState(state)
-    detentInfo?.let {
-      // Notify delegate of drag end
-      delegate?.viewControllerDidDragEnd(it.index, it.position)
-
-      if (it.index != currentDetentIndex) {
-        presentPromise?.let { promise ->
-          promise()
-          presentPromise = null
-        }
+    containerView?.let {
+      cachedContentHeight = it.contentHeight
+      cachedHeaderHeight = it.headerHeight
+      cachedFooterHeight = it.footerHeight
+      cachedPeekContentHeight = it.peekContentHeight
+    }
 
-        currentDetentIndex = it.index
-        setupDimmedBackground(it.index)
+    interactionState = InteractionState.Reconfiguring
 
-        // Notify delegate of detent change
-        delegate?.viewControllerDidChangeDetent(it.index, it.position)
-      }
+    behavior.isFitToContents = false
+
+    val maxAvailableHeight = realScreenHeight - topInset
+
+    // With a keyboard floor only the last detent stays keyboard-shifted; the
+    // collapsed and half stops are the keyboard-free first and second detents,
+    // so a short drag down from the keyboard-expanded sheet rests at the second
+    // and a long one at the first, like iOS
+    val peekHeight = minOf(detentCalculator.getDetentHeight(detents[0], includeKeyboard = !hasKeyboardFloor), maxAvailableHeight)
+
+    val halfExpandedDetentHeight = when (detents.size) {
+      1 -> peekHeight
+      else -> detentCalculator.getDetentHeight(detents[1], includeKeyboard = !hasKeyboardFloor)
     }
 
-    isDragging = false
+    val maxDetentHeight = minOf(detentCalculator.getDetentHeight(detents.last()), maxAvailableHeight)
+
+    val adjustedHalfExpandedHeight = minOf(halfExpandedDetentHeight, maxAvailableHeight)
+    val halfExpandedRatio = (adjustedHalfExpandedHeight.toFloat() / realScreenHeight.toFloat())
+
+    val expandedOffset = realScreenHeight - maxDetentHeight
+
+    // fitToContents works better with <= 2 detents when no expanded offset, but
+    // it drops the half stop the keyboard floor relies on
+    val fitToContents = !hasKeyboardFloor && detents.size < 3 && expandedOffset == 0
+
+    configureDetents(
+      behavior = behavior,
+      peekHeight = peekHeight,
+      halfExpandedRatio = halfExpandedRatio,
+      expandedOffset = expandedOffset,
+      fitToContents = fitToContents,
+      animate = isPresented
+    )
+
+    updateStateDimensions()
+
+    if (isPresented && applyState) {
+      // Prefer the pending target while a resize animation is in flight so a
+      // layout-driven reconfigure doesn't revert to the stale currentDetentIndex.
+      val targetIndex = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
+      setStateForDetentIndex(targetIndex)
+    }
+
+    interactionState = InteractionState.Idle
   }
 
-  // ==================== Detent Calculations ====================
+  private fun configureDetents(
+    behavior: BottomSheetBehavior<TrueSheetBottomSheetView>,
+    peekHeight: Int,
+    halfExpandedRatio: Float,
+    expandedOffset: Int,
+    fitToContents: Boolean,
+    animate: Boolean
+  ) {
+    behavior.apply {
+      isFitToContents = fitToContents
+      skipCollapsed = false
+      setPeekHeight(peekHeight, animate)
+      this.halfExpandedRatio = halfExpandedRatio.coerceIn(0.01f, 0.999f)
+      this.expandedOffset = expandedOffset
+    }
+  }
 
-  /**
-   * Get the height value based on the detent config value.
-   */
-  private fun getDetentHeight(detent: Double): Int {
-    val height: Int = if (detent == -1.0) {
-      // -1.0 represents "auto"
-      contentHeight
-    } else {
-      if (detent <= 0.0 || detent > 1.0) {
-        throw IllegalArgumentException("TrueSheet: detent fraction ($detent) must be between 0 and 1")
-      }
-      (detent * maxScreenHeight).toInt()
+  fun setupSheetDetentsForSizeChange() {
+    // Defer while dragging — the size change is driven by the drag itself (the
+    // container tracks the sheet's visible height), and reconfiguring resets
+    // behavior state, killing the gesture. Applied on settle so a real content
+    // change mid-drag (e.g. items removed from a list) isn't lost.
+    if (interactionState is InteractionState.Dragging) {
+      hasPendingSizeChange = true
+      return
     }
+    hasPendingSizeChange = false
 
-    // Apply top inset when edge-to-edge is enabled and fullScreen is false
-    val maxAllowedHeight = maxScreenHeight - sheetTopInset
-    val finalHeight = maxSheetHeight?.let { minOf(height, it, maxAllowedHeight) } ?: minOf(height, maxAllowedHeight)
-    return finalHeight
+    setupSheetDetents()
+    positionFooter()
   }
 
-  /**
-   * Determines the state based from the given detent index.
-   */
-  private fun getStateForDetentIndex(index: Int): Int =
-    when (detents.size) {
-      1 -> {
-        BottomSheetBehavior.STATE_EXPANDED
-      }
+  fun setStateForDetentIndex(index: Int) {
+    behavior?.state = detentCalculator.getStateForDetentIndex(index)
+  }
+
+  // =============================================================================
+  // MARK: - Dimmed Background
+  // =============================================================================
 
-      2 -> {
-        when (index) {
-          0 -> BottomSheetBehavior.STATE_COLLAPSED
-          1 -> BottomSheetBehavior.STATE_EXPANDED
-          else -> BottomSheetBehavior.STATE_HIDDEN
+  fun setupDimmedBackground() {
+    val coordinator = this.coordinatorLayout ?: run {
+      RNLog.e(reactContext, "TrueSheet: coordinatorLayout is null in setupDimmedBackground")
+      return
+    }
+
+    if (dimmed) {
+      val parentDimVisible = (parentSheetView?.viewController?.dimView?.alpha ?: 0f) > 0f
+
+      if (dimView == null) {
+        dimView = TrueSheetDimView(reactContext).apply {
+          delegate = this@TrueSheetViewController
         }
       }
+      if (!parentDimVisible) {
+        dimView?.attachToCoordinator(coordinator)
+      }
 
-      3 -> {
-        when (index) {
-          0 -> BottomSheetBehavior.STATE_COLLAPSED
-          1 -> BottomSheetBehavior.STATE_HALF_EXPANDED
-          2 -> BottomSheetBehavior.STATE_EXPANDED
-          else -> BottomSheetBehavior.STATE_HIDDEN
+      // Attach dim view to parent sheet if stacked
+      val parentController = parentSheetView?.viewController
+      val parentBottomSheet = parentController?.sheetView
+      if (parentBottomSheet != null) {
+        if (parentDimView == null) {
+          parentDimView = TrueSheetDimView(reactContext).apply {
+            delegate = this@TrueSheetViewController
+          }
         }
+        parentDimView?.attach(parentBottomSheet, parentController.sheetCornerRadius)
       }
+    } else {
+      dimView?.detach()
+      dimView = null
+      parentDimView?.detach()
+      parentDimView = null
+    }
+  }
 
-      else -> BottomSheetBehavior.STATE_HIDDEN
+  fun updateDimAmount(sheetTop: Int? = null, animated: Boolean = false) {
+    if (!dimmed) return
+    if (contentHeight == 0) return
+
+    // While keyboard is active or transitioning, use the target detent position for dim
+    val top = if (isKeyboardActive) {
+      detentCalculator.getSheetTopForDetentIndex(currentDetentIndex)
+    } else {
+      val keyboardOffset = if (isBeingDismissed) 0 else currentKeyboardInset
+      (sheetTop ?: sheetView?.top ?: return) + keyboardOffset
     }
 
-  /**
-   * Get the DetentInfo data by state.
-   */
-  fun getDetentInfoForState(state: Int): DetentInfo? =
-    when (detents.size) {
-      1 -> {
-        when (state) {
-          BottomSheetBehavior.STATE_COLLAPSED -> DetentInfo(0, getPositionForDetentIndex(0))
-          BottomSheetBehavior.STATE_EXPANDED -> DetentInfo(0, getPositionForDetentIndex(0))
-          else -> null
+    if (animated) {
+      val targetAlpha = dimView?.calculateAlpha(
+        top,
+        dimmedDetentIndex,
+        detentCalculator::getSheetTopForDetentIndex
+      ) ?: 0f
+      dimViews.forEach { it.animate().alpha(targetAlpha).setDuration(200).start() }
+    } else {
+      dimViews.forEach { it.interpolateAlpha(top, dimmedDetentIndex, detentCalculator::getSheetTopForDetentIndex) }
+    }
+  }
+
+  // =============================================================================
+  // MARK: - Footer Positioning
+  // =============================================================================
+
+  var footerKeyboardOffset: Int = 0
+
+  fun positionFooter() {
+    if (!isPresented) return
+    val footerView = containerView?.footerView ?: return
+    val sheet = sheetView ?: return
+
+    // A relative footer is laid out by Yoga (pinned to the container's bottom
+    // edge) and stays in the layout flow behind the keyboard — only an
+    // absolute footer floats above it
+    if (!absoluteFooter) {
+      footerView.translationY = 0f
+      return
+    }
+
+    // The footer's absorbed safe-area inset rides below the keyboard's top
+    // edge — its content stays flush with the keyboard without dropping the
+    // inset padding from the layout, which would jump at the transition edges
+    val keyboardShift = if (currentKeyboardInset > 0) {
+      maxOf(0, currentKeyboardInset + footerKeyboardOffset - footerView.bottomInset)
+    } else {
+      0
+    }
+
+    val footerHeight = footerView.height
+    val sheetHeight = sheet.height
+
+    // Pinned to the screen bottom (above the keyboard) while the sheet sits at
+    // or above its lowest stop; past it the footer rides down with the sheet
+    // instead, like iOS
+    val anchorTop = minOf(sheet.top, detentCalculator.getLowestSheetTop())
+    val footerY = (sheetHeight - anchorTop - footerHeight - keyboardShift).toFloat()
+
+    // Clamp to prevent footer going above safe area
+    val maxAllowedY = (sheetHeight - topInset - footerHeight).toFloat()
+    footerView.y = minOf(footerY, maxAllowedY)
+  }
+
+  // =============================================================================
+  // MARK: - Keyboard Handling
+  // =============================================================================
+
+  private fun shouldHandleKeyboard(checkFocus: Boolean = true): Boolean {
+    if (wasHiddenByScreen) return false
+    if (!isTopmostSheet) return false
+    if (checkFocus && !isFocusedViewWithinSheet()) return false
+    return true
+  }
+
+  fun saveFocusedView() {
+    focusedViewBeforeBlur = delegate?.findRootContainerView()?.findFocus()
+      ?: reactContext.currentActivity?.currentFocus
+  }
+
+  fun restoreFocusedView() {
+    val viewToFocus = focusedViewBeforeBlur ?: return
+    focusedViewBeforeBlur = null
+
+    if (!viewToFocus.isAttachedToWindow) return
+    if (viewToFocus.requestFocus()) {
+      viewToFocus.postDelayed({
+        KeyboardUtils.show(viewToFocus)
+      }, 100)
+    }
+  }
+
+  fun setupKeyboardObserver() {
+    val coordinator = coordinatorLayout ?: run {
+      RNLog.e(reactContext, "TrueSheet: coordinatorLayout is null in setupKeyboardObserver")
+      return
+    }
+    cleanupKeyboardObserver()
+    keyboardObserver = TrueSheetKeyboardObserver(coordinator, reactContext).apply {
+      delegate = object : TrueSheetKeyboardObserverDelegate {
+        override fun keyboardWillShow(height: Int) {
+          if (!shouldHandleKeyboard()) return
+          // If a resize is in flight, restore to its target — not the stale current
+          detentIndexBeforeKeyboard = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
+          pendingDetentIndex = -1
+          // Commit the target index first so the container grows before the sheet expands
+          currentDetentIndex = detents.size - 1
+          setupSheetDetents()
+          positionFooter()
+          updateDimAmount(animated = true)
         }
-      }
 
-      2 -> {
-        when (state) {
-          BottomSheetBehavior.STATE_COLLAPSED -> DetentInfo(0, getPositionForDetentIndex(0))
-          BottomSheetBehavior.STATE_EXPANDED -> DetentInfo(1, getPositionForDetentIndex(1))
-          else -> null
+        override fun keyboardWillHide() {
+          if (!shouldHandleKeyboard(checkFocus = false)) return
+          // Mid-drag (the drag itself dismissed the keyboard) the release decides
+          // the detent and a reconfigure would kill the gesture — the floor stops
+          // stay put until the settle flushes the pending reconfigure
+          if (interactionState is InteractionState.Dragging) {
+            hasPendingSizeChange = true
+            return
+          }
+          val restoring = !isBeingDismissed && detentIndexBeforeKeyboard >= 0
+
+          // Skip reconfigure during interactive keyboard dismiss (e.g. keyboardDismissMode="on-drag")
+          // to prevent the sheet from jumping. keyboardDidHide will reconfigure after.
+          if (restoring || isKeyboardDismissProgrammatic) {
+            setupSheetDetents()
+            if (restoring) {
+              currentDetentIndex = detentIndexBeforeKeyboard
+              setStateForDetentIndex(currentDetentIndex)
+            }
+          }
+
+          // Same-frame reposition — the reconfigure above shrinks the container
+          // to the target detent, which yanks the bottom-pinned footer up until
+          // the next keyboard animation frame repositions it.
+          positionFooter()
+          updateDimAmount(
+            sheetTop = detentCalculator.getSheetTopForDetentIndex(currentDetentIndex),
+            animated = true
+          )
         }
-      }
 
-      3 -> {
-        when (state) {
-          BottomSheetBehavior.STATE_COLLAPSED -> DetentInfo(0, getPositionForDetentIndex(0))
-          BottomSheetBehavior.STATE_HALF_EXPANDED -> DetentInfo(1, getPositionForDetentIndex(1))
-          BottomSheetBehavior.STATE_EXPANDED -> DetentInfo(2, getPositionForDetentIndex(2))
-          else -> null
+        override fun keyboardDidHide() {
+          if (!shouldHandleKeyboard(checkFocus = false)) return
+          isKeyboardDismissProgrammatic = false
+          // Keep detentIndexBeforeKeyboard for the settle's detent-change check
+          if (interactionState is InteractionState.Dragging) {
+            hasPendingSizeChange = true
+            return
+          }
+          detentIndexBeforeKeyboard = -1
+          setupSheetDetents(applyState = false)
+          positionFooter()
+          updateDimAmount(
+            sheetTop = detentCalculator.getSheetTopForDetentIndex(currentDetentIndex),
+            animated = true
+          )
         }
-      }
 
-      else -> null
+        override fun keyboardDidChangeHeight(height: Int) {
+          // Skip focus check during active keyboard transitions (focus may be lost during hide)
+          val skipFocusCheck = detentIndexBeforeKeyboard >= 0 || isKeyboardTransitioning
+          if (!shouldHandleKeyboard(checkFocus = !skipFocusCheck)) return
+          positionFooter()
+        }
+
+        override fun focusDidChange(newFocus: View) {
+          // Handle case where keyboard is already visible and focus moves into the sheet
+          if (!shouldHandleKeyboard()) return
+          if (detentIndexBeforeKeyboard < 0 && (keyboardObserver?.currentHeight ?: 0) > 0) {
+            detentIndexBeforeKeyboard = currentDetentIndex
+            currentDetentIndex = detents.size - 1
+            setupSheetDetents()
+            positionFooter()
+          }
+        }
+      }
+      start()
     }
+  }
+
+  fun cleanupKeyboardObserver() {
+    keyboardObserver?.stop()
+    keyboardObserver = null
+  }
+
+  // =============================================================================
+  // MARK: - Drag Handling
+  // =============================================================================
+
+  private fun getPositionDpForView(sheetView: View): Float =
+    detentCalculator.getPositionDp(detentCalculator.getVisibleSheetHeight(sheetView.top))
+
+  fun commitKeyboardDetent() {
+    detentIndexBeforeKeyboard = -1
+  }
+
+  private fun handleSettling(sheetView: View) {
+    // A keyboard-floor drag was released — the first settle frame reveals the target
+    keyboardSettleStartTop = if (hasKeyboardFloor && interactionState is InteractionState.Dragging) sheetView.top else -1
+  }
 
   /**
-   * Calculate the expected Y position for a given detent index.
-   * Uses actual screen position if available, otherwise calculates based on screen height.
+   * Dismisses the keyboard as soon as a released drag is known to land on a
+   * keyboard-free stop, rather than waiting for the landing. BottomSheetBehavior
+   * keeps its target private, so read it off the first settle frame: heading
+   * down means the half stop or the floor; heading up from below the half stop
+   * means the half stop; only heading up from above it means the expanded stop.
    */
-  private fun getPositionForDetentIndex(index: Int): Float {
-    if (index < 0 || index >= detents.size) {
-      return 0f
-    }
+  private fun dismissKeyboardForSettleTarget(sheetView: View) {
+    if (keyboardSettleStartTop < 0) return
+    val startTop = keyboardSettleStartTop
+    keyboardSettleStartTop = -1
 
-    // Try to get actual position from bottom sheet view first (same view used in behavior callbacks)
-    bottomSheetView?.let {
-      it
-      val screenY = ScreenUtils.getScreenY(it)
-      // Only use actual position if sheet has been positioned (screenY > 0)
-      if (screenY > 0) {
-        return screenY.pxToDp()
-      }
-    }
+    val headingToKeyboardFreeStop = sheetView.top > startTop || startTop > detentCalculator.getKeyboardHalfStopTop()
+    if (headingToKeyboardFreeStop && shouldHandleKeyboard()) dismissKeyboard()
+  }
+
+  private fun handleDragBegin(sheetView: View) {
+    pendingDetentIndex = -1
+
+    val position = getPositionDpForView(sheetView)
+    val detent = detentCalculator.getDetentValueForIndex(currentDetentIndex)
+    delegate?.viewControllerDidDragBegin(currentDetentIndex, position, detent)
+    interactionState = InteractionState.Dragging(startTop = sheetView.top)
+  }
+
+  // Commits a non-keyboard detent and hides the keyboard; keyboardWillHide then
+  // reconfigures the detents so the sheet settles at the committed index.
+  private fun commitDetentAndDismissKeyboard(index: Int, sheetView: View) {
+    val changed = index != knownDetentIndex
+    detentIndexBeforeKeyboard = -1
+    currentDetentIndex = index
+    dismissKeyboard()
+    setupDimmedBackground()
+
+    if (!changed) return
+    val position = getPositionDpForView(sheetView)
+    val detent = detentCalculator.getDetentValueForIndex(index)
+    delegate?.viewControllerDidChangeDetent(index, position, detent)
+    this.sheetView?.updateGrabberAccessibilityValue(index, detents.size)
+  }
+
+  private fun handleDragChange(sheetView: View) {
+    if (interactionState !is InteractionState.Dragging) return
+
+    updateStateDimensionsForDrag(sheetView.top)
+
+    val position = getPositionDpForView(sheetView)
+    val detent = detentCalculator.getDetentValueForIndex(currentDetentIndex)
+    delegate?.viewControllerDidDragChange(currentDetentIndex, position, detent)
+  }
+
+  // =============================================================================
+  // MARK: - Event Emission
+  // =============================================================================
+
+  private fun emitWillPresentEvents() {
+    val (index, position, detent) = getDetentInfoWithValue(currentDetentIndex)
+    parentSheetView?.viewControllerWillBlur()
+    delegate?.viewControllerWillPresent(index, position, detent)
+    delegate?.viewControllerWillFocus()
+  }
+
+  private fun emitWillDismissEvents() {
+    delegate?.viewControllerWillBlur()
+    delegate?.viewControllerWillDismiss()
+    parentSheetView?.viewControllerWillFocus()
+  }
+
+  private fun emitDidDismissEvents() {
+    val parent = parentSheetView
+    parentSheetView = null
+
+    delegate?.viewControllerDidBlur()
+    delegate?.viewControllerDidDismiss(parent)
+
+    dismissPromise?.invoke()
+    dismissPromise = null
+  }
 
-    // Fallback: calculate expected position
-    val detentHeight = getDetentHeight(detents[index])
+  private fun emitChangePositionDelegate(currentTop: Int, realtime: Boolean = true) {
+    // Dedupe emissions for same position
+    if (currentTop == lastEmittedPositionPx) return
 
-    // Position calculation is simple: screen height - sheet height
-    // In both edge-to-edge and non-edge-to-edge modes, getScreenY returns
-    // coordinates in screen space, and maxScreenHeight represents the available height
-    // for the sheet, so the calculation is the same
-    val positionPx = maxScreenHeight - detentHeight
+    lastEmittedPositionPx = currentTop
+    val visibleHeight = realScreenHeight - currentTop
+    val position = detentCalculator.getPositionDp(visibleHeight)
+    val (interpolatedIndex, detent) = detentCalculator.getInterpolatedPositionInfo(currentTop)
+    delegate?.viewControllerDidChangePosition(interpolatedIndex, position, detent, realtime)
+  }
 
-    return positionPx.pxToDp()
+  /**
+   * Updates position emission, footer, and dim amount together.
+   * This pattern is commonly used during animations and state changes.
+   */
+  private fun updateSheetVisuals(effectiveTop: Int) {
+    emitChangePositionDelegate(effectiveTop)
+    positionFooter()
+    updateDimAmount(effectiveTop)
+  }
+
+  // =============================================================================
+  // MARK: - Detent Helpers
+  // =============================================================================
+
+  fun updateBehaviorMaxWidth() {
+    val behavior = this.behavior ?: return
+    val applyMaxWidth = maxContentWidth != null && !ScreenUtils.isPortraitPhone(reactContext)
+    val newMaxWidth = if (applyMaxWidth) maxContentWidth!! else DEFAULT_MAX_WIDTH.dpToPx().toInt()
+    if (behavior.maxWidth == newMaxWidth) return
+
+    behavior.maxWidth = newMaxWidth
   }
 
   /**
-   * Get DetentInfo data for given detent index.
+   * Updates the Fabric state with the current/target detent size so Yoga sizes
+   * the container to the sheet's visible height.
+   *
+   * Unlike iOS, resize animations run over multiple frames (ViewDragHelper), so
+   * shrinking is deferred to settle ([deferShrink]) when a resize animation is
+   * about to run — growing applies immediately so content is laid out before
+   * the sheet reveals it.
    */
-  fun getDetentInfoForIndex(index: Int) = getDetentInfoForState(getStateForDetentIndex(index)) ?: DetentInfo(0, 0f)
+  private fun updateStateDimensions(deferShrink: Boolean = false) {
+    if (detents.isEmpty()) return
 
-  // ==================== RootView Implementation ====================
+    val targetIndex = (if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex)
+      .coerceIn(0, detents.size - 1)
+    val maxAvailableHeight = realScreenHeight - topInset
+    val newHeight = minOf(detentCalculator.getDetentHeight(detents[targetIndex]), maxAvailableHeight)
+    val newWidth = getStateWidth()
 
-  override fun onInitializeAccessibilityNodeInfo(info: AccessibilityNodeInfo) {
-    super.onInitializeAccessibilityNodeInfo(info)
+    if (deferShrink && newWidth == lastStateWidth && newHeight < lastStateHeight) return
 
-    val testId = getTag(R.id.react_test_id) as String?
-    if (testId != null) {
-      info.viewIdResourceName = testId
-    }
+    setStateDimensions(newWidth, newHeight)
   }
 
-  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
-    super.onSizeChanged(w, h, oldw, oldh)
+  /**
+   * Tracks the sheet's visible height during drag (and the post-release settle
+   * animation) so the container resizes with the finger, like iOS. Clamped to the
+   * smallest detent — dragging below it slides the sheet out without resizing.
+   */
+  private fun updateStateDimensionsForDrag(sheetTop: Int) {
+    if (detents.isEmpty()) return
 
-    // Only proceed if size actually changed
-    if (w == oldw && h == oldh) return
+    val maxAvailableHeight = realScreenHeight - topInset
+    val minHeight = minOf(
+      detentCalculator.getDetentHeight(detents.first(), includeKeyboard = !hasKeyboardFloor),
+      maxAvailableHeight
+    )
+    val newHeight = detentCalculator.getVisibleSheetHeight(sheetTop).coerceIn(minHeight, maxAvailableHeight)
 
-    // Update screen height based on new dimensions
-    val oldMaxScreenHeight = maxScreenHeight
-    maxScreenHeight = ScreenUtils.getScreenHeight(reactContext, edgeToEdgeEnabled)
+    setStateDimensions(getStateWidth(), newHeight)
+  }
+
+  private fun getStateWidth(): Int {
+    val applyMaxWidth = maxContentWidth != null && !ScreenUtils.isPortraitPhone(reactContext)
+    val effectiveMaxWidth = if (applyMaxWidth) maxContentWidth!! else DEFAULT_MAX_WIDTH.dpToPx().toInt()
+    return minOf(screenWidth, effectiveMaxWidth)
+  }
+
+  private fun setStateDimensions(width: Int, height: Int) {
+    if (lastStateWidth == width && lastStateHeight == height) return
+
+    lastStateWidth = width
+    lastStateHeight = height
+    delegate?.viewControllerDidChangeSize(width, height)
+  }
+
+  /**
+   * Realtime (non-animated) counterpart of TrueSheetStackManager.updateParentTranslation,
+   * driven by onSlide so the parent tracks this sheet's actual position.
+   */
+  private fun syncParentTranslation(sheetTop: Int) {
+    val parent = parentSheetView ?: return
+    val minSheetTop = detentCalculator.getSheetTopForDetentIndex(0)
+    parent.syncTranslationForChild(sheetTop, minSheetTop)
+  }
 
-    // Only handle rotation if sheet is presented and screen height actually changed
-    if (isPresented && oldMaxScreenHeight != maxScreenHeight && oldMaxScreenHeight > 0) {
-      // Recalculate sheet detents with new screen dimensions
-      setupSheetDetents()
+  fun translateSheet(translationY: Int, animated: Boolean = true, onEnd: (() -> Unit)? = null) {
+    val sheet = sheetView ?: return
 
-      this.post {
-        // Update footer position after rotation
-        positionFooter()
+    if (!animated) {
+      sheet.animate().cancel()
+      sheet.translationY = translationY.toFloat()
+      emitChangePositionDelegate(sheet.top + translationY)
+      onEnd?.invoke()
+      return
+    }
 
-        // Notify JS about position change after rotation settles
-        val detentInfo = getDetentInfoForIndex(currentDetentIndex)
-        delegate?.viewControllerDidChangePosition(detentInfo.index, detentInfo.position, transitioning = true)
+    sheet.animate()
+      .translationY(translationY.toFloat())
+      .setDuration(TRANSLATE_ANIMATION_DURATION)
+      .setUpdateListener {
+        val effectiveTop = sheet.top + sheet.translationY.toInt()
+        emitChangePositionDelegate(effectiveTop)
+      }
+      .withEndAction { onEnd?.invoke() }
+      .start()
+  }
+
+  private fun getDetentInfoWithValue(index: Int): Triple<Int, Float, Float> {
+    val state = detentCalculator.getStateForDetentIndex(index)
+    val detentIndex = detentCalculator.getDetentIndexForState(state) ?: 0
+    val position = getPositionForDetentIndex(detentIndex)
+    val detent = detentCalculator.getDetentValueForIndex(detentIndex)
+    return Triple(detentIndex, position, detent)
+  }
+
+  private fun getPositionForDetentIndex(index: Int): Float {
+    if (index < 0 || index >= detents.size) return screenHeight.pxToDp()
+
+    sheetView?.let {
+      val visibleSheetHeight = detentCalculator.getVisibleSheetHeight(it.top)
+      if (visibleSheetHeight in 1..<realScreenHeight) {
+        return detentCalculator.getPositionDp(visibleSheetHeight)
       }
     }
 
-    // Notify delegate about size change
-    delegate?.viewControllerDidChangeSize(w, h)
+    val detentHeight = detentCalculator.getDetentHeight(detents[index])
+    return detentCalculator.getPositionDp(detentHeight)
   }
 
-  override fun handleException(t: Throwable) {
-    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  // =============================================================================
+  // MARK: - RootView Implementation
+  // =============================================================================
+
+  override fun onInitializeAccessibilityNodeInfo(info: AccessibilityNodeInfo) {
+    super.onInitializeAccessibilityNodeInfo(info)
+    (getTag(R.id.react_test_id) as? String)?.let { info.viewIdResourceName = it }
+  }
+
+  // =============================================================================
+  // MARK: - RootView Touch Handling
+  // =============================================================================
+
+  override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+    val footer = containerView?.footerView
+    val action = event.actionMasked
+
+    if (footer != null && footer.isShown) {
+      if (action == MotionEvent.ACTION_DOWN) {
+        val loc = ScreenUtils.getScreenLocation(footer)
+        val x = event.rawX.toInt()
+        val y = event.rawY.toInt()
+        footerOwnsTouchStream = x >= loc[0] &&
+          x <= loc[0] + footer.width &&
+          y >= loc[1] &&
+          y <= loc[1] + footer.height
+      }
+
+      if (footerOwnsTouchStream) {
+        val loc = ScreenUtils.getScreenLocation(footer)
+        val localEvent = MotionEvent.obtain(event)
+        localEvent.setLocation(event.rawX - loc[0], event.rawY - loc[1])
+        val handled = footer.dispatchTouchEvent(localEvent)
+        localEvent.recycle()
+
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+          footerOwnsTouchStream = false
+        }
+        if (handled) return true
+      }
+    }
+
+    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+      footerOwnsTouchStream = false
+    }
+    return super.dispatchTouchEvent(event)
   }
 
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { eventDispatcher ->
-      jSTouchDispatcher.handleTouchEvent(event, eventDispatcher, reactContext)
-      jSPointerDispatcher?.handleMotionEvent(event, eventDispatcher, true)
+    eventDispatcher?.let {
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, it, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, it, true)
     }
     return super.onInterceptTouchEvent(event)
   }
 
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // Mirrors ReactSurfaceView: keep receiving onInterceptTouchEvent so
+    // jsTouchDispatcher sees the gesture end, but forward the request up the tree.
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
   override fun onTouchEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { eventDispatcher ->
-      jSTouchDispatcher.handleTouchEvent(event, eventDispatcher, reactContext)
-      jSPointerDispatcher?.handleMotionEvent(event, eventDispatcher, false)
+    eventDispatcher?.let {
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, it, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, it, false)
     }
     super.onTouchEvent(event)
-    // In case when there is no children interested in handling touch event, we return true from
-    // the root view in order to receive subsequent events related to that gesture
     return true
   }
 
   override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { jSPointerDispatcher?.handleMotionEvent(event, it, true) }
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, true) }
     return super.onHoverEvent(event)
   }
 
   override fun onHoverEvent(event: MotionEvent): Boolean {
-    eventDispatcher?.let { jSPointerDispatcher?.handleMotionEvent(event, it, false) }
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, false) }
     return super.onHoverEvent(event)
   }
 
-  @OptIn(UnstableReactNativeAPI::class)
-  @Suppress("DEPRECATION")
   override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
-    eventDispatcher?.let { eventDispatcher ->
-      jSTouchDispatcher.onChildStartedNativeGesture(ev, eventDispatcher, reactContext)
-      jSPointerDispatcher?.onChildStartedNativeGesture(childView, ev, eventDispatcher)
+    coordinatorLayout?.childDidClaimNativeGesture()
+    eventDispatcher?.let {
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, it)
+      jsPointerDispatcher.onChildStartedNativeGesture(childView, ev, it)
     }
   }
 
   override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
-    eventDispatcher?.let { jSTouchDispatcher.onChildEndedNativeGesture(ev, it) }
-    jSPointerDispatcher?.onChildEndedNativeGesture()
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher.onChildEndedNativeGesture()
   }
 
-  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
-    // Allow the request to propagate to parent
-    super.requestDisallowInterceptTouchEvent(disallowIntercept)
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
   }
 }