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

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

@@ -240,8 +240,9 @@ internal class RootCoordinator(
     /**
      * The activity's layers go: the `setRoot` on its way ends, then the root it replaced, the current root and its root
      * are destroyed, as at any destroy (their events reach only their own JavaScript). [answerPending]: the activity
-     * went, the waiting `setRoot` resolves with `''` (JavaScript sets the root again in the next activity); otherwise
-     * (a reload) it gets no answer.
+     * went; a `setRoot` whose root still waited resolves with `''` (JavaScript sets the root again in the next
+     * activity), one whose root showed (its transition ran, or the modals and overlays of its layout were showing)
+     * resolves with the root's id. Otherwise (a reload) it gets no answer.
      */
     fun destroyAll(answerPending: Boolean) {
         val pending = pending
@@ -256,7 +257,9 @@ internal class RootCoordinator(
         modals.replacedRootGone()
         pending?.let(::releaseState)
         if (pending != null && pending.phase == Phase.Waiting) firstRoot.rootDestroyed()
-        if (answerPending) pending?.answer?.resolve("")
+        if (!answerPending || pending == null) return
+        // An empty id tells JavaScript the root didn't show: its start waits for the next activity and sets it there.
+        pending.answer.resolve(if (pending.phase == Phase.Waiting) "" else pending.root.id)
     }
 
     // Waits for the screens that show when the root shows, then runs its transition. Without `waitForRender` one limit

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/overlay/OverlayCoordinator.kt

@@ -124,18 +124,18 @@ internal class OverlayCoordinator(
     }
 
     /**
-     * `dismissOverlay`: the overlays with the root id [componentId] go — one that waits is cancelled, one that shows
-     * goes with its events (both, when a replacement of a shown one waits) — and [answer] resolves with the id. An id
-     * no node has: `not shown`; a node that is no overlay's root (Android takes only the root's id): `not in an
-     * overlay`.
+     * `dismissOverlay`: the overlay [componentId] is in — its root or any screen inside it — goes with every overlay of
+     * the same root id: one that waits is cancelled, one that shows goes with its events (both, when a replacement of
+     * a shown one waits). [answer] resolves with the overlay's root id, as on iOS. An id no node has: `not shown`; a
+     * node in no overlay: `not in an overlay`.
      */
     fun dismiss(componentId: String, answer: CommandAnswer) {
-        if (host.find(componentId) == null) return answer.reject(ErrorTexts.screenNotShown(componentId))
-        val matches = records.filter { it.rootId == componentId }
-        if (matches.isEmpty()) return answer.reject(ErrorTexts.notInOverlay(componentId))
+        val node = host.find(componentId) ?: return answer.reject(ErrorTexts.screenNotShown(componentId))
+        val rootId = recordOf(node)?.rootId ?: return answer.reject(ErrorTexts.notInOverlay(componentId))
+        val matches = records.filter { it.rootId == rootId }
         matches.filter { it.state == OverlayRecord.State.Waiting }.forEach(::cancel)
         val shown = matches.filter { it.state == OverlayRecord.State.Shown }
-        if (shown.isEmpty()) return answer.resolve(componentId)
+        if (shown.isEmpty()) return answer.resolve(rootId)
         shown.dropLast(1).forEach { remove(it, null) }
         remove(shown.last(), answer)
     }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/parent/Capabilities.kt

@@ -41,11 +41,18 @@ interface KeepsStatusBarRoom
 /** A node that shows screens in its columns (the split view): `showInColumn` and `setColumnShown` go to it. */
 interface ShowsColumns {
     /**
-     * Shows [screen] in the column after the first one, in place of what it shows; [listener] once it shows, or with
-     * the error reason, which names [from], the screen the command comes from. False when the node doesn't take it now
-     * (its compact layout shows): the core pushes the screen over [from] instead.
+     * Shows [screen] in [column], in place of what it shows; [listener] once it shows, or with the error reason, which
+     * names [from], the screen the command comes from. [goesInStack] says whether [screen]'s layout is what a stack
+     * takes (a screen, a native screen, a pair), not a container. False when the node doesn't take it now (its compact
+     * layout shows): the core pushes the screen over [from] instead.
      */
-    fun showScreen(screen: ViewController<*>, from: ViewController<*>, listener: CommandListener): Boolean
+    fun showScreen(
+        screen: ViewController<*>,
+        column: String,
+        goesInStack: Boolean,
+        from: ViewController<*>,
+        listener: CommandListener,
+    ): Boolean
 
     /** Shows or hides [column]; [done] once the columns have stopped moving. */
     fun setColumnShown(column: String, shown: Boolean, done: Runnable)

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/sidemenu/SideMenuController.kt

@@ -131,7 +131,7 @@ internal class SideMenuController(
 
     // `mergeOptions` with the side menu's id: its own options, then what a merge does, then the layouts around.
     override fun mergeOptions(options: Options) {
-        this.options = this.options.copy().mergeWith(options)
+        mergeOwnOptions(options)
         applyMerge(options)
         performOnParentController { it.mergeChildOptions(SideMenuRules.withoutSideMenu(options), this) }
     }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/splitview/SplitPanes.kt

@@ -1,6 +1,8 @@
 package dev.apexnative.navigation.viewcontrollers.splitview
 
 import android.content.Context
+import android.view.View
+import android.view.ViewGroup
 import android.view.WindowInsets
 import androidx.core.graphics.Insets
 import androidx.core.view.WindowInsetsCompat
@@ -14,6 +16,27 @@ class SplitPanes(context: Context) : SlidingPaneLayout(context) {
     /** The panes are side by side. */
     var isSideBySide = false
 
+    /**
+     * Puts [next] in the place of the pane [old], with the structure and the params [old] had. The library wraps the
+     * second view it is given in a view of its own that holds back touches (`addView` with one child there), and its
+     * `removeView` takes that wrapper away: a plain remove and add would wrap a new primary pane, or give a new
+     * secondary one the wrapper's params, and lose its width and weight. So the secondary pane's content changes
+     * inside the wrapper, and a new primary pane goes in before the old one leaves, while two children are there.
+     */
+    internal fun replacePane(old: View, next: View) {
+        val holder = old.parent as? ViewGroup ?: return
+        val params = old.layoutParams
+        if (holder === this) {
+            // A copy: the width that `splitView.width` changes later is the new pane's own.
+            addView(next, indexOfChild(old), if (params is LayoutParams) LayoutParams(params) else params)
+            removeView(old)
+        } else {
+            val index = holder.indexOfChild(old)
+            holder.removeView(old)
+            holder.addView(next, index, params)
+        }
+    }
+
     override fun dispatchApplyWindowInsets(insets: WindowInsets): WindowInsets {
         if (!isSideBySide) return super.dispatchApplyWindowInsets(insets)
         val own = onApplyWindowInsets(insets)

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/splitview/SplitViewController.kt

@@ -15,6 +15,7 @@ import dev.apexnative.navigation.options.SplitViewGroupOptions
 import dev.apexnative.navigation.options.SplitViewOptions
 import dev.apexnative.navigation.react.CommandListener
 import dev.apexnative.navigation.react.CommandListenerAdapter
+import dev.apexnative.navigation.react.ErrorTexts
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.system.SystemUiOwner
 import dev.apexnative.navigation.utils.TestIds
@@ -24,6 +25,7 @@ import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
 import dev.apexnative.navigation.viewcontrollers.parent.ChildOffsetFromRest
+import dev.apexnative.navigation.viewcontrollers.parent.OptionsScreen
 import dev.apexnative.navigation.viewcontrollers.parent.ParentController
 import dev.apexnative.navigation.viewcontrollers.parent.ReturnsScreenFromColumn
 import dev.apexnative.navigation.viewcontrollers.parent.ShownChildren
@@ -45,8 +47,9 @@ class SplitViewController(
     presenter: Presenter,
     initialOptions: Options,
     private var split: SplitViewOptions,
-    private val primary: ViewController<*>,
-    private val secondary: ViewController<*>,
+    // The panes' content; `showInColumn` may give a pane a new one.
+    private var primary: ViewController<*>,
+    private var secondary: ViewController<*>,
     private val compact: ViewController<*>?,
     private val eventEmitter: EventEmitter,
 ) : ParentController<SplitViewLayout>(activity, childRegistry, id, presenter, initialOptions),
@@ -421,27 +424,67 @@ class SplitViewController(
     }
 
     /**
-     * Shows [screen] in the secondary pane in place of what it shows and brings the pane into view. False with the
-     * compact layout on screen: the screen goes over [from], the screen the command comes from.
+     * Shows [screen] in [column] (`primary` or `secondary`; Android has no other) in place of what the pane shows, and
+     * brings the pane into view. A stack pane's screens are replaced by it, unless it is a container
+     * (![goesInStack]): `columnIsStack`. Any other pane is taken by it, and its content goes. A column the split view
+     * doesn't have: `noSuchColumn`. False with the compact layout on screen: the screen goes over [from], the screen
+     * the command comes from.
      */
-    override fun showScreen(screen: ViewController<*>, from: ViewController<*>, listener: CommandListener): Boolean {
+    override fun showScreen(
+        screen: ViewController<*>,
+        column: String,
+        goesInStack: Boolean,
+        from: ViewController<*>,
+        listener: CommandListener,
+    ): Boolean {
         if (isViewCreated && getView().isCompact) return false
-        val stack = secondary as? StackController
-        if (stack == null) {
-            listener.onError("the 'secondary' column of the split view of the screen '${from.id}' is not a stack")
-            return true
+        val pane = when (column) {
+            PRIMARY -> primary
+            SECONDARY -> secondary
+            else -> null
         }
-        stack.setRoot(listOf(screen), false, object : CommandListenerAdapter() {
-            override fun onSuccess(childId: String) {
+        when {
+            pane == null -> listener.onError(ErrorTexts.noSuchColumn(from.id, column))
+            pane is StackController && !goesInStack -> listener.onError(ErrorTexts.columnIsStack(from.id, column))
+            pane is StackController -> pane.setRoot(listOf(screen), false, object : CommandListenerAdapter() {
+                override fun onSuccess(childId: String) {
+                    updateBackButton()
+                    bringIntoView(column) { listener.onSuccess(childId) }
+                }
+
+                override fun onError(message: String) = listener.onError(message)
+            })
+            else -> {
+                replacePane(pane, screen)
                 updateBackButton()
-                showSecondary { listener.onSuccess(childId) }
+                val shownId = ((screen as? OptionsScreen)?.optionsScreen ?: screen).id
+                bringIntoView(column) { listener.onSuccess(shownId) }
             }
-
-            override fun onError(message: String) = listener.onError(message)
-        })
+        }
         return true
     }
 
+    // [next] takes the pane of [old], a screen alone or a container, as iOS puts a screen in place of a column's: its
+    // view goes where the old one's was, the children shown are told as a move of the panes tells them (DidDisappear
+    // of what left, DidAppear of what came), and [old] goes with its screens.
+    private fun replacePane(old: ViewController<*>, next: ViewController<*>) {
+        next.setParentController(this)
+        if (old === primary) primary = next else secondary = next
+        peekView()?.let { layout ->
+            layout.panes.replacePane(old.getView(), next.getView())
+            applyTestIds(primary.getView(), secondary.getView())
+            hideCoveredPane()
+            shownChildren.moved()
+            tellShownChanged()
+        }
+        old.destroy()
+    }
+
+    // The pane of [column] comes into view; [done] once the panes stopped.
+    private fun bringIntoView(column: String, done: Runnable) {
+        if (column == PRIMARY) setColumnShown(PRIMARY, true, done) else showSecondary(done)
+    }
+
     private fun showSecondary(done: Runnable) {
         if (!isSliding || getView().panes.isOpen) {
             done.run()

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackCommands.kt

@@ -105,33 +105,42 @@ internal class StackCommands(
     }
 
     /**
-     * `showInColumn` (Android): [layout] in the secondary pane of the split view of the screen [componentId], or over
-     * that screen in its stack. Before any node: the screen is there, else `the screen '<id>' is not shown`; the push's
-     * checks of the layout (an id that shows already; a container, which the stack of the screen, else its split view,
-     * doesn't take); a screen prepared with the id goes. The screen is made at once, a native screen's view too. The
-     * split view takes it (the answer once its pane stopped, or the rejection of the pane); with the compact layout on
-     * screen, or without a split view, it is pushed over [componentId] in its stack, with the push's answer and errors;
-     * neither: `the screen '<id>' is neither in a split view nor in a stack`. Every rejection after the screen was made
-     * destroys it. Two calls in a row each make their screen the root of the pane in turn, and each answers its own id.
+     * `showInColumn` (Android): [layout] in [column] of the split view of the screen [componentId], or over that screen
+     * in its stack. Before any node: the screen is there, else `the screen '<id>' is not shown`; the layout has no id
+     * that shows already; out of a split view, the push's check of the layout (a container, which the stack doesn't
+     * take); a screen prepared with the id goes. The screen is made at once, a native screen's view too. The split view
+     * takes it — in place of a stack column's screens or of a column's content — with the answer once its pane
+     * stopped, or rejects (a column it doesn't have, a container for a stack column); with the compact layout on
+     * screen, or without a split view, it is pushed over [componentId] in its stack, with the push's checks, answer and
+     * errors; neither: `the screen '<id>' is neither in a split view nor in a stack`. Every rejection after the screen
+     * was made destroys it. Two calls in a row each make their screen the column's content in turn, and each answers
+     * its own id.
      */
-    fun showInColumn(componentId: String, layout: LayoutNode, answer: CommandAnswer, what: String) {
+    fun showInColumn(componentId: String, column: String, layout: LayoutNode, answer: CommandAnswer, what: String) {
         val source = find(componentId)?.takeIf { !prepared.isPrepared(it) }
             ?: return answer.reject(ErrorTexts.screenNotShown(componentId))
         val shown = LayoutChecks.firstShownId(listOf(layout), ::isShown) { false }
         if (shown != null) return answer.reject(ErrorTexts.alreadyShown(shown))
         val columns = nodeWith<ShowsColumns>(source)
         val stack = source as? StackController ?: source.findParentStack()
-        val placeId = stack?.id ?: (columns as? ViewController<*>)?.id
-        placeId?.let { id -> LayoutChecks.checkStackChild(layout, id)?.let { return answer.reject(it) } }
+        // Out of a split view it can only be a push: the stack's check comes before any node.
+        if (columns == null && stack != null) {
+            LayoutChecks.checkStackChild(layout, stack.id)?.let { return answer.reject(it) }
+        }
         if (!factory.canMake(layout)) return answer.reject(ErrorTexts.notDoneYet("showInColumn"))
         prepared.discard(layout.id)
         val node = make(layout)
         try {
-            if (columns?.showScreen(node, source, destroyingOnError(node, answer)) == true) return
+            val goesInStack = LayoutChecks.isStackChild(layout)
+            if (columns?.showScreen(node, column, goesInStack, source, destroyingOnError(node, answer)) == true) return
             if (stack == null) {
                 node.destroy()
                 return answer.reject(ErrorTexts.neitherSplitViewNorStack(componentId))
             }
+            LayoutChecks.checkStackChild(layout, stack.id)?.let {
+                node.destroy()
+                return answer.reject(it)
+            }
             pushMade(stack, source, node, layout, answer, what)
         } catch (e: Throwable) {
             node.destroy()
@@ -225,8 +234,9 @@ internal class StackCommands(
     fun setStackRoot(componentId: String, layouts: List<LayoutNode>, answer: CommandAnswer, what: String) {
         if (layouts.isEmpty()) return answer.reject(ErrorTexts.noScreensForStack(componentId))
         val stack = stackOf(componentId, answer) ?: return
-        // An id of this stack may come again: the new screen replaces it (`setStackRoot` step 3).
-        val shown = LayoutChecks.firstShownId(layouts, { isShown(it) && !isOf(stack, it) }) { false }
+        // An id of an entry of this stack may come again: the new screen replaces it (`setStackRoot` step 3). The
+        // stack's own id, and a screen an accepted cut or replace took away, show elsewhere or still go: as on iOS.
+        val shown = LayoutChecks.firstShownId(layouts, ::isShown) { isInEntryOf(stack, it.id) }
         if (shown != null) return answer.reject(ErrorTexts.alreadyShown(shown))
         for (layout in layouts) LayoutChecks.checkStackChild(layout, stack.id)?.let { return answer.reject(it) }
         if (!layouts.all(factory::canMake)) return answer.reject(ErrorTexts.notDoneYet("setStackRoot"))
@@ -357,10 +367,10 @@ internal class StackCommands(
     // A node of the registry has [id], and it isn't only prepared for a push (`push` step 1, `preparePush`).
     private fun isShown(id: String): Boolean = registry.find(id)?.let { !prepared.isPrepared(it) } == true
 
-    // The node with [id] is [stack] or in it.
-    private fun isOf(stack: StackController, id: String): Boolean {
-        val node = find(id) ?: return false
-        return node === stack || node.findParentStack() === stack
+    // The node with [id] is in an entry of [stack] as JavaScript sees it (`StackQueue.entries`), not the stack itself.
+    private fun isInEntryOf(stack: StackController, id: String): Boolean {
+        val node = find(id)?.takeIf { it !== stack } ?: return false
+        return stack.entryOf(node)?.let { it in stack.queue.entries } == true
     }
 
     // A node of [layout], with its view made now when it has a native screen: its creator's failure rejects the

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackController.kt

@@ -12,6 +12,7 @@ import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.options.TopBarOptions
 import dev.apexnative.navigation.react.CommandListener
 import dev.apexnative.navigation.react.ErrorTexts
+import dev.apexnative.navigation.react.PendingCalls
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.utils.NavigationLog
 import dev.apexnative.navigation.utils.UiThread
@@ -21,8 +22,8 @@ import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
 import dev.apexnative.navigation.viewcontrollers.component.ComponentViewController
 import dev.apexnative.navigation.viewcontrollers.component.ContentReadiness
 import dev.apexnative.navigation.viewcontrollers.component.Readiness
+import dev.apexnative.navigation.viewcontrollers.component.RenderWait
 import dev.apexnative.navigation.viewcontrollers.component.RestPlace
-import dev.apexnative.navigation.viewcontrollers.component.ScreenContentFactory
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
 import dev.apexnative.navigation.viewcontrollers.parent.ContainerBackground
@@ -81,26 +82,34 @@ class StackController(
 
     /** The one queue of the stack. */
     // The readiness of the screens reaches the queue's waits on the next turn of the main loop: a signal that comes
-    // inside a layout pass or a view's attach moves no view of the container there.
+    // inside a layout pass or a view's attach moves no view of the container there. A pushed screen's mount reaches
+    // its push behind the calls JavaScript made before it (`PendingCalls`), on a later turn too.
     internal var queue = StackQueue(
         display = StackViews(this),
         readiness = ContentReadiness,
         scheduler = { delay, task -> AppearanceDispatcher.scheduler.schedule(delay, task) },
         host = QueueHost(),
         deliver = { signal -> UiThread.post { signal() } },
+        afterCalls = PendingCalls::after,
     )
         private set
 
     /**
      * The unit tests run the stack over their own display, readiness and host (views are stubs there), before any
-     * screen joins it; the readiness signals come at once there.
+     * screen joins it; the readiness signals come at once there, and a push's behind the calls as [afterCalls] says.
      */
-    internal fun useQueueParts(display: StackDisplay, readiness: Readiness, host: StackQueue.Host?) {
+    internal fun useQueueParts(
+        display: StackDisplay,
+        readiness: Readiness,
+        host: StackQueue.Host?,
+        afterCalls: (() -> Unit) -> Unit = { it() },
+    ) {
         queue = StackQueue(
             display = display,
             readiness = readiness,
             scheduler = { delay, task -> AppearanceDispatcher.scheduler.schedule(delay, task) },
             host = host ?: QueueHost(),
+            afterCalls = afterCalls,
         )
     }
 
@@ -470,7 +479,7 @@ class StackController(
 
     // `mergeOptions` with the stack's id: its own options, what it shows, then the layouts around.
     override fun mergeOptions(options: Options) {
-        this.options = this.options.copy().mergeWith(options)
+        mergeOwnOptions(options)
         applyOrKeep(options, null)
         performOnParentController { it.mergeChildOptions(withoutStackGroups(options), this) }
     }
@@ -730,8 +739,8 @@ class StackController(
             if (peekView() != null) topBar.stage(node)
         }
 
-        override fun isOwnRootScreen(node: ViewController<*>): Boolean =
-            (node as? ComponentViewController)?.componentName?.startsWith(ScreenContentFactory.SLOT_PREFIX) == false
+        override fun hasReactContent(node: ViewController<*>): Boolean =
+            RenderWait.waitedScreens(node).any { it is ComponentViewController }
 
         override fun log(text: String) {
             Log.e(NavigationLog.TAG, text)

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackDisplay.kt

@@ -185,7 +185,8 @@ internal interface StackDisplay {
 
     /**
      * The push of a prepared slot screen: [mounted] as the slot's content mounts into the screen's container (or at the
-     * limit of 0.5 s), then [start] on the pre-draw of that frame, while [waiting] holds.
+     * limit of 0.5 s), then [start] on the pre-draw of that frame, while [waiting] holds; the queue starts the
+     * transition from there behind the calls JavaScript made before, on a later turn.
      */
     fun awaitPrepared(screen: ViewController<*>, waiting: () -> Boolean, mounted: () -> Unit, start: () -> Unit)
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackQueue.kt

@@ -52,8 +52,12 @@ private typealias Node = ViewController<*>
  *
  * Its waits for a screen to render are the core's one wait ([RenderWait]), on the screen it pushes or sets as the top;
  * the readiness signals reach it through [deliver] (the stack posts them to the next turn of the main loop: a signal
- * that comes inside a layout pass or a view's attach moves no view of the container there). A push or a
- * `setStackRoot` with elements waits for its targets after that, a wait like the others: a cut or a replace during it
+ * that comes inside a layout pass or a view's attach moves no view of the container there). A push of a screen with
+ * React content waits for its first mount: [PUSH_WAIT_MILLIS] at most without `waitForRender`, as long as it takes
+ * with `true`, not at all with `false`; its signal reaches the wait through [afterCalls], behind the calls JavaScript
+ * made in the commit of that mount (its `mergeOptions`), so the transition starts with the options of that commit —
+ * content mounted already goes that way too. A push or a `setStackRoot` with elements waits for its targets after
+ * that, a wait like the others, within what is left of its limit without `waitForRender`: a cut or a replace during it
  * interrupts the push, which moves no view into a layer.
  *
  * The transition is the screens' own when the options say so (`AnimationRules.stackIsOwn`): the display plays each
@@ -66,6 +70,11 @@ internal class StackQueue(
     private val scheduler: AppearanceDispatcher.Scheduler,
     private val host: Host,
     private val deliver: (() -> Unit) -> Unit = { it() },
+    /**
+     * How the mount of a pushed screen reaches the push's wait: on the main thread behind every call JavaScript made
+     * before it (the stack: `PendingCalls`, on a later turn of the main loop); at once by default.
+     */
+    private val afterCalls: (() -> Unit) -> Unit = { it() },
 ) {
     /** What the queue tells the stack. */
     interface Host {
@@ -104,10 +113,10 @@ internal class StackQueue(
         fun operationEnded(topSettled: Boolean)
 
         /**
-         * Whether [node] is a React screen with a root of its own, which a push prepares when its switch is on
-         * ([StackSwitches.preparesOwnRootPushes]).
+         * Whether [node] shows React content whose first mount its push waits for: a React screen (a root of its own or
+         * a slot), or an entry that shows one. A native screen has none: its push starts at once.
          */
-        fun isOwnRootScreen(node: Node): Boolean = false
+        fun hasReactContent(node: Node): Boolean = false
 
         /** One line for the log: a failure that has no command to answer. */
         fun log(text: String) = Unit
@@ -427,11 +436,12 @@ internal class StackQueue(
         val node = op.node
         val push = resolved(node).animations.push
         op.awaitsTargets = awaitsTargets(push, !push.enabled.isFalse)
+        // A prepared screen rendered before its push; `false`, and a node without React content, start at once.
         val wait = when {
             op.prepared -> Wait.Prepared
             push.waitForRender.isTrue -> Wait.Content
-            StackSwitches.preparesOwnRootPushes && host.isOwnRootScreen(node) -> Wait.Limited
-            else -> Wait.None
+            push.waitForRender.isFalse || !host.hasReactContent(node) -> Wait.None
+            else -> Wait.Limited
         }
         if (wait == Wait.None) return if (op.awaitsTargets) awaitTargets(op) else beginPush(op)
         waiting = op
@@ -439,18 +449,37 @@ internal class StackQueue(
             Wait.Prepared -> awaitPrepared(op)
             Wait.Content -> {
                 // Then the components of the bar drawn in advance, 0.5 s at most after the content (a title or a
-                // background with its own `waitForRender: false` not).
+                // background with its own `waitForRender: false` not). React content mounted already goes behind the
+                // calls too; a native screen starts at once.
                 display.placeWaiting(node)
-                awaitContent(op, node, limit = null, bar = RenderWait.Bar.AfterContent)
+                awaitContent(
+                    op,
+                    node,
+                    limit = null,
+                    bar = RenderWait.Bar.AfterContent,
+                    deliver = afterCalls,
+                    deliversReady = host.hasReactContent(node),
+                )
             }
             else -> {
+                // The screen renders hidden under the top, its signal (or its content mounted already) behind the
+                // calls; the bar's components don't count. The 0.5 s hold for the content and the targets together.
                 display.placeWaiting(node)
-                awaitContent(op, node, limit = OWN_ROOT_WAIT_MILLIS, bar = RenderWait.Bar.None)
+                op.cancelLimit = scheduler.schedule(PUSH_WAIT_MILLIS) { op.overLimit = true }
+                awaitContent(
+                    op,
+                    node,
+                    limit = PUSH_WAIT_MILLIS,
+                    bar = RenderWait.Bar.None,
+                    deliver = afterCalls,
+                    deliversReady = true,
+                )
             }
         }
     }
 
     private fun beginPush(op: PushOp) {
+        op.cancelLimit?.invoke()
         val node = op.node
         val covered = shownList.lastOrNull()
         // The views first: a failure here leaves the lists as they were.
@@ -505,6 +534,7 @@ internal class StackQueue(
 
     // Off screen or without a view: at once, without a transition; the top appears when the stack shows.
     private fun pushAtOnce(op: PushOp) {
+        op.cancelLimit?.invoke()
         val node = op.node
         val covered = shownList.lastOrNull()
         if (display.hasView) {
@@ -533,6 +563,7 @@ internal class StackQueue(
         if (op.done) return
         op.done = true
         if (waiting === op) stopWaiting(op)
+        op.cancelLimit?.invoke()
         queued.remove(op)
         val node = op.node
         entryList.remove(node)
@@ -799,8 +830,16 @@ internal class StackQueue(
 
     // The one wait (RenderWait) for [screen], the node the operation brings: at [limit] the content not ready counts
     // as mounted; without one, `waitForRender: true` waits as long as it takes, except for content the readiness store
-    // knows nothing of after 1 s, which counts as ready (the same rule as iOS).
-    private fun awaitContent(op: Op, screen: Node, limit: Long?, bar: RenderWait.Bar) {
+    // knows nothing of after 1 s, which counts as ready (the same rule as iOS). A push's signals come through
+    // [afterCalls] ([deliver]); with [deliversReady], so does content ready at the start.
+    private fun awaitContent(
+        op: Op,
+        screen: Node,
+        limit: Long?,
+        bar: RenderWait.Bar,
+        deliver: (() -> Unit) -> Unit = this.deliver,
+        deliversReady: Boolean = false,
+    ) {
         val wait = RenderWait(
             readiness = readiness,
             scheduler = scheduler,
@@ -808,6 +847,7 @@ internal class StackQueue(
             bar = bar,
             countsUnknownContent = true,
             deliver = deliver,
+            deliversReadyContent = deliversReady,
             step = { work -> step(op) { work() } },
             onEnd = { endWait(op) },
         )
@@ -828,15 +868,32 @@ internal class StackQueue(
         step(op) { wait.retake(RenderWait.waitedScreens(node)) }
     }
 
+    // The prepared screen's slot mounts (or the display's limit passes), then its transition starts behind the calls
+    // JavaScript made before ([afterCalls]): a commit that came after the push (its JavaScript's own limit) brings its
+    // `mergeOptions` first. The same 0.5 s from the start hold for both: the transition starts then anyway.
     private fun awaitPrepared(op: PushOp) {
         val token = Any()
         op.waitToken = token
         val node = op.node
+        val still = { !destroyed && !op.done && op.waitToken === token && waiting === op && op.isCurrent() }
+        var mounted = false
+        val markMounted = {
+            if (!mounted && !readiness.isReady(node)) readiness.markReady(node)
+            mounted = true
+        }
+        val start = { step(op) { if (still()) endWait(op) } }
+        op.cancelCap = scheduler.schedule(PUSH_WAIT_MILLIS) {
+            step(op) {
+                if (!still()) return@step
+                markMounted()
+                endWait(op)
+            }
+        }
         display.awaitPrepared(
             node,
-            waiting = { !destroyed && !op.done && op.waitToken === token && waiting === op && op.isCurrent() },
-            mounted = { step(op) { if (!readiness.isReady(node)) readiness.markReady(node) } },
-            start = { step(op) { if (waiting === op) endWait(op) } },
+            waiting = still,
+            mounted = { step(op) { markMounted() } },
+            start = { afterCalls(start) },
         )
     }
 
@@ -865,7 +922,8 @@ internal class StackQueue(
         val token = Any()
         op.waitToken = token
         val still = { !destroyed && !op.done && op.waitToken === token && waiting === op && op.isCurrent() }
-        // Without `waitForRender` a `setStackRoot`'s 0.5 s holds for its content and its targets together.
+        // Without `waitForRender` the 0.5 s of a `setStackRoot` and of a push of React content hold for the content
+        // and the targets together.
         val from = currentChild
         op.stopTargets = display.awaitTargets(animation, from, to, { still() && !op.overLimit }) {
             step(op) { if (still()) endWait(op) }
@@ -874,6 +932,8 @@ internal class StackQueue(
 
     private fun stopWaiting(op: Op) {
         if (waiting === op) waiting = null
+        op.cancelCap?.invoke()
+        op.cancelCap = null
         op.waitToken = null
         op.wait?.cancel()
         op.wait = null
@@ -1218,9 +1278,12 @@ internal class StackQueue(
         // It waits for its elements' targets after its content; what stops that wait.
         var awaitsTargets = false
         var stopTargets: (() -> Unit)? = null
-        // The limit of a `setStackRoot` without `waitForRender` passed: its targets get nothing of it any more.
+        // The limit of a `setStackRoot` or a push without `waitForRender` passed: its targets get nothing of it any
+        // more.
         var overLimit = false
         var cancelLimit: (() -> Unit)? = null
+        // The limit of a prepared push's wait, which ends with the wait.
+        var cancelCap: (() -> Unit)? = null
         // Its screen came by an animation of its own: it stays at that animation's end values.
         var keepsEnd = false
         // The listener of a module heard its answer: it hears one only.
@@ -1295,20 +1358,13 @@ internal class StackQueue(
         /** How long a lower screen stays placed in the container to make its content, at most. */
         const val LOWER_SCREEN_MILLIS = 500L
 
-        /** How long the push of a screen with its own root waits for its content, with the switch on. */
-        const val OWN_ROOT_WAIT_MILLIS = 500L
+        /**
+         * How long a push waits for its screen's first mount without `waitForRender`, and a prepared push for its slot
+         * and the calls before it.
+         */
+        const val PUSH_WAIT_MILLIS = 500L
 
         // The alpha an arriving screen shows with: its own at rest, never the 0 of its wait.
         private const val ARRIVING_ALPHA = 1f
     }
 }
-
-/**
- * The internal switches of the stack. [preparesOwnRootPushes]: the push of a React screen with a root of its own starts
- * its surface hidden in the stack at its size and insets, and starts its transition once the content rendered, 0.5 s at
- * most. Off by default («б»: the push starts at once); it is measured at the end on a phone.
- */
-internal object StackSwitches {
-    @Volatile
-    var preparesOwnRootPushes = false
-}