@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.3

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalAnimations.kt

@@ -1,40 +1,38 @@
 package dev.apexnative.navigation.viewcontrollers.modal
 
-import kotlin.math.PI
-import kotlin.math.cos
+import dev.apexnative.navigation.views.animations.Curves
 
 /**
- * The default animations of a modal on Android, as values: it comes up from the bottom of the window by the window's
- * height (in a split screen or a window, the window's, not the display's) and fades in, [DURATION] with a deceleration
- * at the end; it goes down and fades out in the same time, accelerating and decelerating (the system's cosine, not the
- * option's `accelerateDecelerate`). A sheet moves only by the Material sheet's own motion. Pure arithmetic.
+ * The default animations of a modal over the whole screen on Android, as values: the system's motion of a window that
+ * opens over the one below it (`activity_translucent_open_enter` and `activity_translucent_close_exit` of the
+ * platform, which Android 16 plays for a translucent activity). The modal comes up from the bottom of the window by the
+ * window's height (in a split screen or a window, the window's, not the display's) in [SHOW_DURATION], slowing down at
+ * the end; it goes down in [DISMISS_DURATION], speeding up. It doesn't fade: the screen below is seen only around it,
+ * as under a translucent activity. A sheet moves only by the Material sheet's own motion. Pure arithmetic.
  */
 internal object ModalAnimations {
-    /** How long the default show and the default dismissal last (ms). */
-    const val DURATION = 300L
+    /** How long the default show lasts (ms): `activity_translucent_open_enter`. */
+    const val SHOW_DURATION = 300L
+
+    /** How long the default dismissal lasts (ms): `activity_translucent_close_exit`. */
+    const val DISMISS_DURATION = 250L
+
+    // `linear_out_slow_in` of the platform: the path (0, 0) (0, 0) (0.2, 1) (1, 1).
+    private val linearOutSlowIn = Curves.CubicBezier(0.0, 0.0, 0.2, 1.0)
 
     /** How far a modal comes up and goes down: the window's height ([windowHeight]), or the display's while it is 0. */
     fun distance(windowHeight: Int, displayHeight: Int): Float =
         (if (windowHeight > 0) windowHeight else displayHeight).toFloat()
 
-    /** The curve of the show: a deceleration, 1 − (1 − p)². */
-    fun decelerate(progress: Float): Float = 1f - (1f - progress) * (1f - progress)
+    /** The curve of the show: the platform's `linear_out_slow_in`, fast at first and slow at the end. */
+    fun linearOutSlowIn(progress: Float): Float = linearOutSlowIn.getInterpolation(progress)
 
-    /** The curve of the dismissal: an acceleration then a deceleration, cos((p + 1)π) / 2 + 0.5. */
-    fun accelerateDecelerate(progress: Float): Float = (cos((progress + 1) * PI) / 2 + 0.5).toFloat()
+    /** The curve of the dismissal: the platform's `accelerate_quad`, p². */
+    fun accelerate(progress: Float): Float = progress.coerceIn(0f, 1f).let { it * it }
 
-    /** Where a modal is at [progress] (0 … 1, in time) of its show over [distance]: its translation and its alpha. */
-    fun show(progress: Float, distance: Float): Frame {
-        val value = decelerate(progress)
-        return Frame(translationY = distance * (1f - value), alpha = value)
-    }
+    /** Where a modal is at [progress] (0 … 1, in time) of its show over [distance]: its translation. */
+    fun show(progress: Float, distance: Float): Float = distance * (1f - linearOutSlowIn(progress))
 
     /** Where a modal is at [progress] of its dismissal over [distance], from where it rests. */
-    fun dismiss(progress: Float, distance: Float): Frame {
-        val value = accelerateDecelerate(progress)
-        return Frame(translationY = distance * value, alpha = 1f - value)
-    }
-
-    /** A modal's place in its animation. */
-    data class Frame(val translationY: Float, val alpha: Float)
+    fun dismiss(progress: Float, distance: Float): Float = distance * accelerate(progress)
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalCoordinator.kt

@@ -147,8 +147,11 @@ internal class ModalCoordinator(
          */
         fun carry(record: ModalRecord, oldRoot: ViewController<*>?)
 
-        /** New [options] (resolved) of the record: its `testID`s, its sheet's `update` ([move]: to its selection). */
-        fun update(record: ModalRecord, options: Options, move: Boolean)
+        /**
+         * New [options] (resolved) of the record: its `testID`s, its sheet's `update`; [merge] is the `mergeOptions`
+         * that brought them, which alone may move the sheet, or null when the shown screen changed.
+         */
+        fun update(record: ModalRecord, options: Options, merge: Options?)
 
         /** The colors of the record's own views again (a light/dark switch). */
         fun repaint(record: ModalRecord) = Unit
@@ -258,6 +261,54 @@ internal class ModalCoordinator(
         }
     }
 
+    /**
+     * A modal of a `setRoot`'s layout made with the root, before its turn: it joins the modals layer and renders
+     * unseen while the root waits and comes in, held — it doesn't show, and commands and back don't count it — until
+     * [release]; [animated] as in [showInChain]. A failure is logged, and nothing is made (null).
+     */
+    fun hold(id: String, make: () -> ViewController<*>, animated: Boolean): ModalRecord? = try {
+        start(make, null, ModalRecord.Chain(animated) {}, held = true)
+    } catch (e: Throwable) {
+        val reason = ErrorTexts.reasonOf(e)
+        host.log("[ApexNavigation] setRoot: ${ErrorTexts.couldNot("show the screen '$id'", reason)}")
+        null
+    }
+
+    /**
+     * The turn of a [hold]'s modal in its `setRoot`'s chain: it shows as soon as it rendered, as [showInChain]'s
+     * would, with [done] once it showed or went; at once when it went meanwhile. The function returned stops it while
+     * it waits.
+     */
+    fun release(record: ModalRecord, done: () -> Unit): () -> Unit {
+        if (!record.held || record.state != State.Waiting) {
+            done()
+            return {}
+        }
+        record.chain = ModalRecord.Chain(record.chain?.animated ?: true, done)
+        record.held = false
+        guarded(record) {
+            host.backChanged()
+            // Rendered while held: the targets of its elements are in the layer under it only now.
+            if (record.isReady && !record.targetsAwaited && awaitsTargets(record)) {
+                record.isReady = false
+                awaitTargets(record)
+            } else {
+                presentReady()
+            }
+        }
+        return {
+            record.chain = null
+            if (record.state == State.Waiting) cancel(record, null, reports = false)
+        }
+    }
+
+    /** A [hold]'s modal whose `setRoot` ended before its turn: it goes without a word. */
+    fun drop(record: ModalRecord) {
+        if (!record.held) return
+        record.chain = null
+        if (record.state == State.Waiting) cancel(record, null, reports = false)
+    }
+
     /**
      * `dismissModal` after its shared steps: the record of [componentId], Android's rule of the last modal without a
      * root, [options] merged into the modal's visible screen, the animation of the command's screen with its parents
@@ -276,6 +327,7 @@ internal class ModalCoordinator(
             State.ClosedBelow -> return answer.resolve(record.rootId)
             else -> Unit
         }
+        if (record.held) return answer.reject(ErrorTexts.screenNotShown(componentId))
         if (isLastWithoutRoot(record)) return answer.reject(ErrorTexts.modalWithoutRoot(componentId))
         options?.let { mergeInto(record, it) }
         val from = node?.takeUnless { it.isDestroyed } ?: record.root
@@ -290,7 +342,7 @@ internal class ModalCoordinator(
      * before anything changes, with the id of the top modal's visible screen.
      */
     fun dismissAll(options: Options?, unreadablePath: String?, answer: CommandAnswer) {
-        val members = records.filter { it.batch == null && it.state in BATCHED }
+        val members = records.filter { it.batch == null && !it.held && it.state in BATCHED }
         if (members.isEmpty()) {
             // Nothing else to take: the second one answers with the running batch (N6), else at once.
             val running = batches.lastOrNull()
@@ -344,6 +396,12 @@ internal class ModalCoordinator(
         return true
     }
 
+    /**
+     * The root of the modal that back goes to first; none without one. A back gesture previews only a pop in it: its
+     * dismissal has a preview of its own nowhere yet.
+     */
+    fun backTargetRoot(): ViewController<*>? = backTarget()?.root
+
     /** The mirror of [handleBack], without acting; null without a modal to ask. */
     fun canHandleBack(): Boolean? {
         val record = backTarget() ?: return null
@@ -353,13 +411,14 @@ internal class ModalCoordinator(
     // Options.
 
     /**
-     * A `mergeOptions` went into [node] (`mergeOptions` step 5): when it is in a modal, the modal's sheet takes its
-     * options again (it re-reads the resolved ones at any merge) and its `testID`s apply again.
+     * A `mergeOptions` of [merge] went into [node] (`mergeOptions` step 5): when it is in a modal, the modal's sheet
+     * takes its resolved options again, moving only to a `selectedDetent` that [merge] names, and its `testID`s apply
+     * again.
      */
-    fun optionsMergedInto(node: ViewController<*>) {
+    fun optionsMergedInto(node: ViewController<*>, merge: Options) {
         val record = recordOf(node) ?: return
         if (record.root.isDestroyed) return
-        views.update(record, record.root.resolveShownOptions(DefaultOptions.current), move = true)
+        views.update(record, record.root.resolveShownOptions(DefaultOptions.current), merge)
     }
 
     /**
@@ -369,7 +428,7 @@ internal class ModalCoordinator(
     fun visibleScreenChanged(node: ViewController<*>) {
         val record = recordOf(node) ?: return
         if (record.state == State.Waiting || record.root.isDestroyed) return
-        views.update(record, record.root.resolveShownOptions(DefaultOptions.current), move = false)
+        views.update(record, record.root.resolveShownOptions(DefaultOptions.current), merge = null)
     }
 
     /** The colors of the modals' own views again, after a light/dark switch. */
@@ -418,6 +477,8 @@ internal class ModalCoordinator(
         }
         batches.clear()
         for (record in records.toList()) {
+            // A modal of the new root's layout, made with it, stays: it shows over the new root in its turn.
+            if (record.held) continue
             if (record.state == State.Waiting) {
                 cancel(record, null, reports = false)
                 continue
@@ -428,7 +489,7 @@ internal class ModalCoordinator(
             views.carry(record, old)
             carried += record
         }
-        records.clear()
+        records.retainAll { it.held }
         host.backChanged()
     }
 
@@ -478,7 +539,12 @@ internal class ModalCoordinator(
 
     // The show (3, 4).
 
-    private fun start(make: () -> ViewController<*>, answer: CommandAnswer?, chain: ModalRecord.Chain?): ModalRecord {
+    private fun start(
+        make: () -> ViewController<*>,
+        answer: CommandAnswer?,
+        chain: ModalRecord.Chain?,
+        held: Boolean = false,
+    ): ModalRecord {
         val root = make()
         val record: ModalRecord
         val options: Options
@@ -488,6 +554,7 @@ internal class ModalCoordinator(
             val sheet = ModalRecord.isSheet(options)
             root.shownAsSheet = sheet
             record = ModalRecord(root, sheet)
+            record.held = held
         } catch (e: Throwable) {
             root.destroy()
             throw e
@@ -551,7 +618,7 @@ internal class ModalCoordinator(
     private fun ready(record: ModalRecord) {
         if (record.state != State.Waiting) return
         record.wait = null
-        if (!record.targetsAwaited && awaitsTargets(record)) return awaitTargets(record)
+        if (!record.targetsAwaited && !record.held && awaitsTargets(record)) return awaitTargets(record)
         record.cancelLimit()
         record.isReady = true
         presentReady()
@@ -603,7 +670,7 @@ internal class ModalCoordinator(
         if (taking) return
         for (record in records.toList()) {
             if (record.state != State.Waiting) continue
-            if (!record.isReady) return
+            if (record.held || !record.isReady) return
             present(record)
         }
     }
@@ -1152,13 +1219,16 @@ internal class ModalCoordinator(
 
     // A record is the top when no record above it waits, comes in or shows; one that leaves doesn't count.
     private fun isTop(record: ModalRecord): Boolean =
-        records.drop(records.indexOf(record) + 1).none { it.effective in TOP_STATES }
+        records.drop(records.indexOf(record) + 1).none(::countsAsTop)
 
     // The top record, as the commands see it; none.
-    private fun topRecord(): ModalRecord? = records.lastOrNull { it.effective in TOP_STATES }
+    private fun topRecord(): ModalRecord? = records.lastOrNull(::countsAsTop)
 
     // Back goes to the top modal that waits, comes in or shows.
-    private fun backTarget(): ModalRecord? = records.lastOrNull { it.effective in TOP_STATES }
+    private fun backTarget(): ModalRecord? = records.lastOrNull(::countsAsTop)
+
+    // A record that waits, comes in or shows; a held one doesn't count before its turn.
+    private fun countsAsTop(record: ModalRecord): Boolean = !record.held && record.effective in TOP_STATES
 
     // `hardwareBackButton.dismissModalOnPress: false` of the modal's options now.
     private fun holdsBack(record: ModalRecord): Boolean =
@@ -1230,7 +1300,7 @@ internal class ModalCoordinator(
         val screen = AppearanceDispatcher.visibleNode(record.root)
         if (screen.isDestroyed) return
         screen.mergeOptions(options)
-        optionsMergedInto(screen)
+        optionsMergedInto(screen, options)
     }
 
     private inline fun whileTaking(work: () -> Unit) {

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalRecord.kt

@@ -17,7 +17,10 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 internal class ModalRecord(
     /** The top node of the modal's layout. */
     val root: ViewController<*>,
-    /** The modal shows as a Material sheet (`modal.sheet`), decided before its root's view is made. */
+    /**
+     * The modal shows as a Material sheet (`pageSheet`, `formSheet`, `popover`, or `modal.sheet` without a style),
+     * decided before its root's view is made.
+     */
     val isSheet: Boolean,
 ) : WaitingLayer {
     /** Where the modal is. */
@@ -78,6 +81,12 @@ internal class ModalRecord(
     /** Its wait ended: it shows once every older waiting modal showed or went (N1). */
     var isReady = false
 
+    /**
+     * A modal of a `setRoot`'s layout made with the root, before its turn: it renders unseen while the root waits and
+     * comes in, and neither shows nor counts for commands or back until its step of the chain lets it go.
+     */
+    var held = false
+
     /** The wait for its screens while it waits. */
     var wait: RenderWait? = null
 
@@ -160,14 +169,20 @@ internal class ModalRecord(
         /** `modalPresentationStyle` values that keep the layer under in place. */
         private val OVER_STYLES = setOf("overFullScreen", "overCurrentContext")
 
-        /** The styles a sheet shows with: unset, `pageSheet`, `formSheet`. */
-        private val SHEET_STYLES = setOf(null, "pageSheet", "formSheet")
+        /**
+         * The styles that always show as a sheet: the sheets of iOS, and the popover, which an iPhone shows as a sheet
+         * too.
+         */
+        private val SHEET_STYLES = setOf("pageSheet", "formSheet", "popover")
 
         /**
-         * Whether a modal with [options] (resolved, with the defaults) shows as a sheet: any `modal.sheet` field set,
-         * and the style unset, `pageSheet` or `formSheet`.
+         * Whether a modal with [options] (resolved, with the defaults) shows as a sheet: its style is `pageSheet`,
+         * `formSheet` or `popover`, or it has none and any `modal.sheet` field is set.
          */
-        fun isSheet(options: Options): Boolean = options.modal.sheet.hasValue && styleOf(options) in SHEET_STYLES
+        fun isSheet(options: Options): Boolean {
+            val style = styleOf(options)
+            return style in SHEET_STYLES || (style == null && options.modal.sheet.hasValue)
+        }
 
         /**
          * Whether a modal covers the layer under it at the end of its show: full screen, unless it is a sheet or

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalSheet.kt

@@ -29,11 +29,12 @@ import dev.apexnative.navigation.utils.dp
 import kotlin.math.roundToInt
 
 /**
- * A modal shown as a Material bottom sheet (`modal.sheet`): the modal's view in a container with a
- * [BottomSheetBehavior], in the modals' CoordinatorLayout, over a scrim. It stops at the detents of its options —
- * `medium` at half the height, `large` at the full height under the status bar, a number at that height in dp — and the
- * user drags it between them. A drag down past the smallest one closes it, unless `swipeToDismiss` is false: then the
- * sheet stays, and the try is told. The screen under it stays in place.
+ * A modal shown as a Material bottom sheet (`pageSheet`, `formSheet`, `popover`, or `modal.sheet` without a style): the
+ * modal's view in a container with a [BottomSheetBehavior], in the modals' CoordinatorLayout, over a scrim. It stops at
+ * the detents of its options — `medium` at half the height, `large` at the full height under the status bar, a number
+ * at that height in dp — and the user drags it between them. In a window wider than [MAX_WIDTH_DP] it stands in the
+ * middle at that width. A drag down past the smallest one closes it, unless `swipeToDismiss` is false: then the sheet
+ * stays, and the try is told. The screen under it stays in place.
  */
 internal class ModalSheet(
     private val layout: CoordinatorLayout,
@@ -96,11 +97,19 @@ internal class ModalSheet(
                 outline.setRoundRect(0, 0, view.width, view.height + radius.roundToInt(), radius)
             }
         }
-        // The sheet is under the status bar: its screens leave no room for it at their top.
+        // The sheet is under the status bar: its screens leave no room for it at their top. In the middle of a wide
+        // window it reaches no side, and keeps room only for the part of a side bar that is over it.
         ViewCompat.setOnApplyWindowInsetsListener(container) { _, insets ->
             val types = WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()
             val bars = insets.getInsets(types)
-            WindowInsetsCompat.Builder(insets).setInsets(types, Insets.of(bars.left, 0, bars.right, bars.bottom)).build()
+            val laidOut = container.width > 0
+            val left = if (laidOut) (bars.left - container.left).coerceAtLeast(0) else bars.left
+            val right = if (laidOut) (bars.right - (layout.width - container.right)).coerceAtLeast(0) else bars.right
+            WindowInsetsCompat.Builder(insets).setInsets(types, Insets.of(left, 0, right, bars.bottom)).build()
+        }
+        // Its sides move with the window's width (a rotation, a resize): the room for the side bars follows.
+        container.addOnLayoutChangeListener { _, left, _, right, _, oldLeft, _, oldRight, _ ->
+            if (left != oldLeft || right != oldRight) container.post { ViewCompat.requestApplyInsets(container) }
         }
         container.addView(content, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
         container.addView(grabber, FrameLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT, Gravity.TOP or Gravity.CENTER_HORIZONTAL))
@@ -120,33 +129,39 @@ internal class ModalSheet(
         layout.addView(scrim, CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
         // As tall as its largest detent (maxHeight), not moved down by a margin: the behavior counts its states from
         // where the sheet is laid out.
-        layout.addView(container, CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT).also { it.behavior = behavior })
+        // In a wide window it stands in the middle, as wide as a Material modal sheet at most.
+        behavior.maxWidth = MAX_WIDTH_DP.dp
+        val params = CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT)
+        params.gravity = Gravity.TOP or Gravity.CENTER_HORIZONTAL
+        params.behavior = behavior
+        layout.addView(container, params)
         shown = onShown
-        update(sheetOptions, swipeToDismiss, move = false)
+        update(sheetOptions, swipeToDismiss, merge = null)
+        selected = sheetOptions.selectedDetent?.takeIf { it in detents }
         // Laid out hidden first, so it slides up from the bottom.
         container.post { if (closing == null) behavior.state = stateOf(selected ?: detents.first()) }
     }
 
-    /** New options from mergeOptions: the detents, the look, and the selected detent, which the sheet moves to. */
-    fun update(sheetOptions: SheetOptions, swipeToDismiss: Boolean, move: Boolean = true) {
-        val previous = selected
+    /**
+     * New resolved options: the detents and the look. The sheet moves only as [SheetStops] says, after a `mergeOptions`
+     * of [merge]; without one (the shown screen changed, the show) it stays where it is.
+     */
+    fun update(sheetOptions: SheetOptions, swipeToDismiss: Boolean, merge: SheetOptions?) {
         options = sheetOptions
         this.swipeToDismiss = swipeToDismiss
         detents = sheetOptions.detents?.takeIf { it.isNotEmpty() }?.sortedBy { heightOf(it) } ?: listOf(SheetDetent.Large)
-        selected = sheetOptions.selectedDetent?.takeIf { it in detents }
         grabber.visibility = if (sheetOptions.grabber.isTrue) View.VISIBLE else View.GONE
         behavior.dragAnywhere = sheetOptions.expandsOnScroll.get(true)
         container.invalidateOutline()
         configure()
-        if (!move || closing != null) return
+        if (merge == null || closing != null) return
         val settled = detentOf(behavior.state)
         if (settled != null) behavior.isHideable = swipeToDismiss && settled == detents.first()
-        val target = when {
-            selected != null && selected != previous -> selected
-            settled != null && settled !in detents -> selected ?: detents.first()
-            else -> null
+        val target = SheetStops.target(settled, detents, merge.selectedDetent, sheetOptions.selectedDetent)
+        if (target != null) {
+            selected = target
+            behavior.state = stateOf(target)
         }
-        if (target != null) behavior.state = stateOf(target)
         updateScrim()
     }
 
@@ -333,10 +348,13 @@ internal class ModalSheet(
         }
     }
 
-    private companion object {
+    companion object {
+        /** The widest a sheet is, in dp: the Material modal bottom sheet's `maxWidth`. */
+        const val MAX_WIDTH_DP = 640
+
         /** The dim of a Material modal bottom sheet's scrim. */
-        const val SCRIM_ALPHA = 0.32f
-        const val GRAB_AREA_DP = 48
-        const val ATTEMPT_DISTANCE_DP = 48
+        private const val SCRIM_ALPHA = 0.32f
+        private const val GRAB_AREA_DP = 48
+        private const val ATTEMPT_DISTANCE_DP = 48
     }
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalViews.kt

@@ -4,9 +4,9 @@ import android.animation.Animator
 import android.animation.AnimatorListenerAdapter
 import android.animation.AnimatorSet
 import android.animation.ObjectAnimator
-import android.animation.PropertyValuesHolder
 import android.animation.TimeInterpolator
 import android.content.Context
+import android.view.Gravity
 import android.view.View
 import android.view.ViewGroup
 import android.view.animation.LinearInterpolator
@@ -17,6 +17,7 @@ import androidx.core.view.WindowInsetsCompat
 import dev.apexnative.navigation.options.ModalAnimationOptions
 import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.utils.TestIds
+import dev.apexnative.navigation.utils.dp
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 import dev.apexnative.navigation.views.animations.AnimationRules
 import dev.apexnative.navigation.views.animations.SideAnimator
@@ -62,9 +63,15 @@ internal class ModalViews(
         try {
             val view = record.root.view
             (view.parent as? ViewGroup)?.removeView(view)
-            // A sheet's content waits at the sheet's full height, under the status bar.
+            // A sheet's content waits at the sheet's full height, under the status bar, and at its width.
             val params = CoordinatorLayout.LayoutParams(MATCH, MATCH)
-            if (record.isSheet) params.topMargin = statusBarTop()
+            if (record.isSheet) {
+                params.topMargin = statusBarTop()
+                params.gravity = Gravity.CENTER_HORIZONTAL
+                // The modals layer is hidden while it has no modal: the window's content gives the width.
+                val maxWidth = ModalSheet.MAX_WIDTH_DP.dp
+                if (((modalsLayer.parent as? View)?.width ?: 0) > maxWidth) params.width = maxWidth
+            }
             container.addView(view, params)
             modalsLayer.addView(container, FrameLayout.LayoutParams(MATCH, MATCH))
         } catch (e: Throwable) {
@@ -100,14 +107,13 @@ internal class ModalViews(
             container.translationY = 0f
             return playOwn(record, parts, motion, showing = true, onEnd)
         }
+        // The system's slide over the window below: the modal comes up whole, without a fade.
         val distance = distanceOf(container)
-        val animator = ObjectAnimator.ofPropertyValuesHolder(
-            container,
-            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, distance, 0f),
-            PropertyValuesHolder.ofFloat(View.ALPHA, 0f, 1f),
-        )
-        animator.interpolator = TimeInterpolator { ModalAnimations.decelerate(it) }
-        return play(parts, animator, onEnd)
+        container.alpha = 1f
+        container.translationY = distance
+        val animator = ObjectAnimator.ofFloat(container, View.TRANSLATION_Y, distance, 0f)
+        animator.interpolator = TimeInterpolator { ModalAnimations.linearOutSlowIn(it) }
+        return play(parts, animator, ModalAnimations.SHOW_DURATION, onEnd)
     }
 
     // The root's view leaves the container and goes into the sheet's, in one turn; the sheet slides to its first
@@ -163,13 +169,11 @@ internal class ModalViews(
         if (!animated || !seen) return none(onEnd)
         if (motion != null) return playOwn(record, parts, motion, showing = false, onEnd)
         val container = parts.container
-        val animator = ObjectAnimator.ofPropertyValuesHolder(
-            container,
-            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, container.translationY, distanceOf(container)),
-            PropertyValuesHolder.ofFloat(View.ALPHA, container.alpha, 0f),
+        val animator = ObjectAnimator.ofFloat(
+            container, View.TRANSLATION_Y, container.translationY, distanceOf(container),
         )
-        animator.interpolator = TimeInterpolator { ModalAnimations.accelerateDecelerate(it) }
-        return play(parts, animator, onEnd)
+        animator.interpolator = TimeInterpolator { ModalAnimations.accelerate(it) }
+        return play(parts, animator, ModalAnimations.DISMISS_DURATION, onEnd)
     }
 
     override fun awaitTargets(
@@ -245,10 +249,10 @@ internal class ModalViews(
         hideEmptyLayer()
     }
 
-    override fun update(record: ModalRecord, options: Options, move: Boolean) {
+    override fun update(record: ModalRecord, options: Options, merge: Options?) {
         val parts = parts[record] ?: return
         applyTestIds(record, parts, options)
-        parts.sheet?.update(options.modal.sheet, swipeToDismissOf(options), move)
+        parts.sheet?.update(options.modal.sheet, swipeToDismissOf(options), merge?.modal?.sheet)
     }
 
     override fun repaint(record: ModalRecord) {
@@ -355,8 +359,8 @@ internal class ModalViews(
     private fun viewOf(node: ViewController<*>): View? =
         parts.entries.firstOrNull { it.key.root === node }?.value?.container ?: node.peekView()
 
-    private fun play(parts: Parts, animator: Animator, onEnd: () -> Unit): () -> Unit {
-        animator.duration = ModalAnimations.DURATION
+    private fun play(parts: Parts, animator: Animator, duration: Long, onEnd: () -> Unit): () -> Unit {
+        animator.duration = duration
         animator.addListener(object : AnimatorListenerAdapter() {
             override fun onAnimationEnd(animation: Animator) {
                 if (parts.animator === animation) parts.animator = null

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/SheetStops.kt

@@ -0,0 +1,25 @@
+package dev.apexnative.navigation.viewcontrollers.modal
+
+import dev.apexnative.navigation.options.SheetDetent
+
+/**
+ * Where a shown sheet goes at new options, as on iOS: the sheet keeps the stop it stands at (the user's last drag
+ * included) until a `selectedDetent` arrives in a `mergeOptions`, or until its stop is no longer among the detents.
+ */
+internal object SheetStops {
+    /**
+     * The stop to move to, or null to stay: [arrived] (the `selectedDetent` the merge names) when it is among
+     * [detents]; else, when [settled] (the stop the sheet rests at) is no longer one of them, [selected] (the resolved
+     * `selectedDetent`) when it is, or the lowest.
+     */
+    fun target(
+        settled: SheetDetent?,
+        detents: List<SheetDetent>,
+        arrived: SheetDetent?,
+        selected: SheetDetent?,
+    ): SheetDetent? = when {
+        arrived != null && arrived in detents -> arrived
+        settled != null && settled !in detents -> selected?.takeIf { it in detents } ?: detents.first()
+        else -> null
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/navigator/BackCallbackState.kt

@@ -41,6 +41,10 @@ internal object BackCallbackState {
         entries.removeAll { it.navigator.get().let { attached -> attached == null || attached === navigator } }
     }
 
+    /** JavaScript listens to back (`BackHandler`): it hears a press before the navigation does. */
+    val hasJsListeners: Boolean
+        get() = jsListeners
+
     /** `setBackListeners` of JavaScript; false again when its JavaScript goes. */
     fun setJsListeners(active: Boolean) {
         jsListeners = active