@apexnative/navigation 1.0.0-alpha.8 → 1.0.0-alpha.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.0.0-alpha.9](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.8...v1.0.0-alpha.9) (2026-10-30)
+
+
+### Features
+
+* side menus can be created after the center or at their first open ([#67](https://github.com/apexnative/navigation/issues/67)) ([a4a0ecf](https://github.com/apexnative/navigation/commit/a4a0ecfdc04ccd13d2c96b5799b45e510113a7e8))
+
+
+### Bug Fixes
+
+* **android:** the room beside a moving screen goes on with what its edge shows ([#64](https://github.com/apexnative/navigation/issues/64)) ([eb0936f](https://github.com/apexnative/navigation/commit/eb0936f15d8d157d31621917920814df2c725ff1))
+* **ios:** tabs not shown yet render their screens before they show ([#68](https://github.com/apexnative/navigation/issues/68)) ([cf34a09](https://github.com/apexnative/navigation/commit/cf34a09a772865a8e3ff377b053c968e306f4972))
+
 ## [1.0.0-alpha.8](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.7...v1.0.0-alpha.8) (2026-10-29)
 
 

package/android/src/main/java/dev/apexnative/navigation/options/SideMenuOptions.kt

@@ -20,16 +20,18 @@ class SideMenuOptions {
     @JvmField var right = SideMenuSideOptions()
     @JvmField var openGestureMode: Text = NullText()
     @JvmField var animationType: Text = NullText()
+    @JvmField var menusAttachMode: Text = NullText()
     @JvmField var testID: Text = NullText()
 
     fun hasValue(): Boolean = left.hasValue() || right.hasValue() || openGestureMode.hasValue() ||
-        animationType.hasValue() || testID.hasValue()
+        animationType.hasValue() || menusAttachMode.hasValue() || testID.hasValue()
 
     fun mergeWith(other: SideMenuOptions) {
         left.mergeWith(other.left)
         right.mergeWith(other.right)
         if (other.openGestureMode.hasValue()) openGestureMode = other.openGestureMode
         if (other.animationType.hasValue()) animationType = other.animationType
+        if (other.menusAttachMode.hasValue()) menusAttachMode = other.menusAttachMode
         if (other.testID.hasValue()) testID = other.testID
     }
 
@@ -38,6 +40,7 @@ class SideMenuOptions {
         right.mergeWithDefault(defaults.right)
         if (!openGestureMode.hasValue()) openGestureMode = defaults.openGestureMode
         if (!animationType.hasValue()) animationType = defaults.animationType
+        if (!menusAttachMode.hasValue()) menusAttachMode = defaults.menusAttachMode
         if (!testID.hasValue()) testID = defaults.testID
     }
 
@@ -46,6 +49,7 @@ class SideMenuOptions {
     companion object {
         private val OPEN_GESTURE_MODES = setOf("bezel", "entireScreen")
         private val ANIMATION_TYPES = setOf("parallax", "slide", "slide-and-scale", "door")
+        private val MENUS_ATTACH_MODES = setOf("together", "afterCenter", "onOpen")
 
         @JvmStatic
         fun parse(map: ReadableMap?): SideMenuOptions {
@@ -55,6 +59,7 @@ class SideMenuOptions {
             options.right = map.group("right") { SideMenuSideOptions.parse(it) }
             options.openGestureMode = TextParser.parse(map, "openGestureMode", OPEN_GESTURE_MODES)
             options.animationType = TextParser.parse(map, "animationType", ANIMATION_TYPES)
+            options.menusAttachMode = TextParser.parse(map, "menusAttachMode", MENUS_ATTACH_MODES)
             options.testID = TextParser.parse(map, "testID")
             return options
         }

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

@@ -29,7 +29,8 @@ import dev.apexnative.navigation.views.sidemenu.SideMenuView
  * - The current child is the open menu's node, else the center ([SideMenuMotion.openSide]: from the end of the
  *  opening to the end of the closing); the state, the options and back follow it.
  * - The center and the open menu show with the side menu ([visibleChildren]); a wait for the side menu to render
- *   waits for the center ([waitedChildren]); the menus' views are made with the side menu's.
+ *   waits for the center ([waitedChildren]); the menus' views join the drawer as `sideMenu.menusAttachMode` says
+ *   ([attached]): with the side menu's view, once it first appeared, or each as it first starts to show.
  * - Its options ([SideMenuPresenter]): from the resolution of [resolveShownOptions] at creation, at every appearance
  *   of a screen inside, and for the fields a merge names; `sideMenu.<side>.visible` acts once, from a merge or from the
  *  layout at the first show. What goes on up goes without `sideMenu`: the nearest side menu acts.
@@ -64,6 +65,12 @@ internal class SideMenuController(
     // From the end of its appearance's start until it disappears: the drawer's motion tells the menu screens then.
     private var appeared = false
     private var firstShown = false
+    private var firstAppeared = false
+
+    private val attachMode = SideMenuRules.attachModeOf(initialOptions.sideMenu, DefaultOptions.current.sideMenu)
+
+    /** The menus whose nodes' views are in the drawer, or join it as it is made. */
+    internal val attached = HashSet<Side>(2)
     // Its children go first as it is destroyed: nothing reacts to them, nor to the drawer, from the start.
     private var destroying = false
 
@@ -72,6 +79,7 @@ internal class SideMenuController(
 
     init {
         getChildControllers().forEach { it.parentController = this }
+        SideMenuRules.attachedAtCreation(attachMode).filter { childOf(it) != null }.forEach { attached += it }
     }
 
     override fun getChildControllers(): List<ViewController<*>> = listOfNotNull(center, left, right)
@@ -88,13 +96,16 @@ internal class SideMenuController(
 
     private fun childOf(side: Side): ViewController<*>? = if (side == Side.Left) left else right
 
-    // The drawer and its parts, each node's view in its part; the creation's options. An open menu recorded before the
-    // view existed is open in it from the start; the drawer is silent before its first layout.
+    // The drawer and its parts, the view of each node attached so far in its part; the creation's options. An open menu
+    // recorded before the view existed is open in it from the start; the drawer is silent before its first layout.
     override fun createView(): SideMenuView {
         val view = SideMenuView(activity)
         view.setCenter(center.view)
-        left?.let { view.addPart(Side.Left, it.view) }
-        right?.let { view.addPart(Side.Right, it.view) }
+        for (side in Side.entries) {
+            val child = childOf(side) ?: continue
+            view.addPart(side)
+            if (side in attached) view.fillPart(side, child.view)
+        }
         menus.applyOnCreation(view, resolveShownOptions(DefaultOptions.current))
         motion.openSide?.let { view.open(it, false) }
         view.follow(motion)
@@ -172,6 +183,14 @@ internal class SideMenuController(
         motion.containerAppeared()
     }
 
+    // `afterCenter`: the menus join once the side menu first appeared with its center.
+    override fun onViewDidAppear() {
+        super.onViewDidAppear()
+        if (firstAppeared || destroying || isDestroyed) return
+        firstAppeared = true
+        SideMenuRules.attachedAfterAppearance(attachMode).forEach(::attach)
+    }
+
     override fun onViewDisappear() {
         appeared = false
         motion.containerDisappeared()
@@ -222,6 +241,16 @@ internal class SideMenuController(
         if (child === currentChild) super.tabBarSettled(child)
     }
 
+    // The view of the menu on [side] joins its part, once, before its screens hear that they appear: a stack lays out
+    // its bar as it appears in the window. The drawer's first movement may come while it draws (a peek settles in
+    // `computeScroll`, before the drawer draws its children): the view joins the part then, measured and laid out at the
+    // next frame.
+    private fun attach(side: Side) {
+        val child = childOf(side) ?: return
+        if (destroying || isDestroyed || !attached.add(side)) return
+        peekView()?.fillPart(side, child.view)
+    }
+
     /** Destroys the side menu once: the drawer's callbacks stop first, then the children go. */
     override fun destroy() {
         if (isDestroyed) return
@@ -238,6 +267,8 @@ internal class SideMenuController(
 
         override fun child(side: Side): ViewController<*>? = childOf(side)
 
+        override fun starts(side: Side) = attach(side)
+
         override fun isEnabled(side: Side): Boolean =
             SideMenuRules.isEnabled(resolveShownOptions(DefaultOptions.current).sideMenu, side)
 

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

@@ -82,6 +82,12 @@ internal class SideMenuMotion(
         /** `sideMenu.<side>.enabled` of the side menu's options now. */
         fun isEnabled(side: Side): Boolean
 
+        /**
+         * The menu on [side] starts to show: the drawer's first movement, or a command that opens it. Before its
+         * screen hears that it appears.
+         */
+        fun starts(side: Side)
+
         /** `visible: true` for a side the layout doesn't have: a warning, nothing else. */
         fun missingSide(side: Side)
 
@@ -122,6 +128,7 @@ internal class SideMenuMotion(
     fun slid(side: Side, offset: Float) {
         // Not more than 0 also takes a NaN: `DrawerLayout` divides by the drawer's width, which may be 0.
         if (destroyed || !(offset > 0f)) return
+        if (!isOnScreen(side)) host.starts(side)
         onScreen += side
         if (side in appearing || !host.appeared) return
         appearing += side
@@ -207,6 +214,7 @@ internal class SideMenuMotion(
         }
         // Never decided by where the other menu is: a side asked to open in the same merge hasn't moved yet.
         if (drawer.has(side.other)) move(side.other, open = false, animate = animated)
+        if (!isOnScreen(side)) host.starts(side)
         onScreen += side
         // A locked menu opened from code can be dragged closed while it is open.
         drawer.lock(side, locked = false)

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

@@ -11,11 +11,23 @@ import kotlin.math.min
 
 /**
  * What the options of a side menu do on Android (`sideMenu.*`), without views: the values of each moment, `visible` as
- * a command, the sizes, the `testID`s. Android reads `enabled`, `width`, `height`, `visible`, `animate` and the
- * `testID`s of `sideMenu`; `openGestureMode`, `animationType`, `openMode`, `shouldStretchDrawer`, `animationVelocity`
- * and `glass` are iOS's.
+ * a command, the sizes, the `testID`s, when the menus join the drawer. Android reads `enabled`, `width`, `height`,
+ * `visible`, `animate`, `menusAttachMode` and the `testID`s of `sideMenu`; `openGestureMode`, `animationType`,
+ * `openMode`, `shouldStretchDrawer`, `animationVelocity` and `glass` are iOS's.
  */
 internal object SideMenuRules {
+    /** When the views of the menus' nodes join the drawer (`sideMenu.menusAttachMode`): their content renders then. */
+    enum class AttachMode {
+        /** With the side menu's view. */
+        Together,
+
+        /** Once the side menu first appeared, with its center. */
+        AfterCenter,
+
+        /** Each as it first starts to show: the drawer's first movement, or a command that opens it. */
+        OnOpen,
+    }
+
     /** A side's `visible` of one merge: open or close it, with its `animate`. */
     data class Command(val side: Side, val visible: Boolean, val animate: Boolean)
 
@@ -43,6 +55,26 @@ internal object SideMenuRules {
      */
     fun firstShow(layout: SideMenuOptions): List<Side> = Side.entries.filter { sideOf(layout, it).visible.isTrue }
 
+    /**
+     * The mode of `sideMenu.menusAttachMode`: the side menu's [own] options, else the [defaults]; `together` without
+     * either. Read once, as the side menu is made.
+     */
+    fun attachModeOf(own: SideMenuOptions, defaults: SideMenuOptions): AttachMode {
+        val value = own.menusAttachMode.takeIf { it.hasValue() } ?: defaults.menusAttachMode
+        return when (value.get(null)) {
+            "afterCenter" -> AttachMode.AfterCenter
+            "onOpen" -> AttachMode.OnOpen
+            else -> AttachMode.Together
+        }
+    }
+
+    /** The menus that join as the side menu is made: both with `together`. */
+    fun attachedAtCreation(mode: AttachMode): List<Side> = if (mode == AttachMode.Together) Side.entries else emptyList()
+
+    /** The menus that join once the side menu first appeared: both with `afterCenter`. */
+    fun attachedAfterAppearance(mode: AttachMode): List<Side> =
+        if (mode == AttachMode.AfterCenter) Side.entries else emptyList()
+
     /** `enabled` of [side]: true unless `false`, from the side menu's resolved options. */
     fun isEnabled(options: SideMenuOptions, side: Side): Boolean = !sideOf(options, side).enabled.isFalse
 

package/android/src/main/java/dev/apexnative/navigation/views/sidemenu/SideMenuView.kt

@@ -48,15 +48,24 @@ internal class SideMenuView(context: Context) : DrawerLayout(context), SideMenuM
         center.addView(content, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
     }
 
-    /** The part of [side], holding [content]: a drawer at that edge, the whole height of the side menu. */
-    fun addPart(side: Side, content: View): FrameLayout {
+    /**
+     * The part of [side], empty until [fillPart]: a drawer at that edge, the whole height of the side menu. It opens,
+     * closes and takes its width and lock without its content.
+     */
+    fun addPart(side: Side): FrameLayout {
         val part = FrameLayout(context)
-        part.addView(content, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
         addView(part, LayoutParams(MATCH_PARENT, MATCH_PARENT, gravityOf(side)))
         parts[side.ordinal] = part
         return part
     }
 
+    /** [content] fills the part of [side], once. */
+    fun fillPart(side: Side, content: View) {
+        val part = partOf(side) ?: return
+        if (content.parent === part) return
+        part.addView(content, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
+    }
+
     /** The part of [side]; none when the layout has no menu there. */
     fun partOf(side: Side): FrameLayout? = parts[side.ordinal]
 

package/android/src/main/java/dev/apexnative/navigation/views/stack/ScreenEdge.kt

@@ -1,15 +1,45 @@
 package dev.apexnative.navigation.views.stack
 
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
 import android.view.View
 
 /**
  * What fills the room beside a moving screen in a transition (`StackLayout.extendEdge`), where the system's
  * transitions between activities stretch a window's edge (`<extend>` of `activity_open_*` and `activity_close_*`): the
- * screen's own background, which is what its edge shows unless its content covers it. Taken without drawing the
- * screen, at the start of every push and pop. Main thread only.
+ * column of pixels at the screen's edge, stretched across the room, as the system stretches the window's. What the
+ * screen shows there goes on beside it — a gradient its content draws, not only its own background. Taken at the start
+ * of every push and pop. Main thread only.
  */
 internal object ScreenEdge {
-    /** A copy of [view]'s background, stretched across the room; none without one. */
-    fun pictureOf(view: View): Drawable? = view.background?.constantState?.newDrawable(view.resources)?.mutate()
+    /**
+     * The column of pixels at [view]'s left edge ([left]) or right edge, made to be stretched; its background when the
+     * screen isn't laid out as it shows ([laidOut]: not after a rotation while it was out of the stack) or can't be drawn
+     * in software (a `HARDWARE` bitmap in it, a view that fails to draw), none without one either.
+     */
+    fun pictureOf(view: View, left: Boolean, laidOut: Boolean): Drawable? =
+        (if (laidOut) columnOf(view, left) else null) ?: backgroundOf(view)
+
+    // One pixel wide and as tall as the screen: the view draws itself into a canvas that keeps that column only. Any
+    // view of the screen may fail to draw in software (a hardware bitmap, a view that wants a hardware canvas): the
+    // screen's background stands in then, as the transition must go on.
+    private fun columnOf(view: View, left: Boolean): Drawable? {
+        val width = view.width
+        val height = view.height
+        if (width <= 0 || height <= 0) return null
+        return try {
+            val column = Bitmap.createBitmap(1, height, Bitmap.Config.ARGB_8888)
+            val canvas = Canvas(column)
+            if (!left) canvas.translate(-(width - 1).toFloat(), 0f)
+            view.draw(canvas)
+            BitmapDrawable(view.resources, column)
+        } catch (e: RuntimeException) {
+            null
+        }
+    }
+
+    private fun backgroundOf(view: View): Drawable? =
+        view.background?.constantState?.newDrawable(view.resources)?.mutate()
 }

package/android/src/main/java/dev/apexnative/navigation/views/stack/StackLayout.kt

@@ -145,12 +145,15 @@ class StackLayout(context: Context) : CoordinatorLayout(context) {
 
     /**
      * [view] extends its start edge ([atStart]) or its end edge by [width] pixels while it moves, as the system's
-     * transitions between activities extend a window: its background fills the room it moves away from, so the screen
-     * under it never shows at its edge. [dropEdge] ends it. Each frame of the move calls [edgesMoved].
+     * transitions between activities extend a window: the pixels at its edge, stretched, fill the room it moves away
+     * from, so the screen under it never shows at its edge. [dropEdge] ends it. Each frame of the move calls
+     * [edgesMoved].
      */
     fun extendEdge(view: View, atStart: Boolean, width: Int) {
         val left = atStart != (layoutDirection == LAYOUT_DIRECTION_RTL)
-        val picture = ScreenEdge.pictureOf(view) ?: return
+        // A screen put back for a pop keeps the size of its last layout until the next one: after a rotation while it was
+        // out of the stack, its pixels are of another width.
+        val picture = ScreenEdge.pictureOf(view, left, laidOut = view.width == this.width) ?: return
         edges[view] = Edge(picture, width, left)
         invalidate()
     }

package/docs-md/containers/side-menu.md

@@ -124,6 +124,21 @@ On iOS the content moves aside, and the menu comes in under it with a parallax;
 
 (iOS) 26: `left({ glass: true })` puts the menu on Liquid Glass. The glass shows where the menu's screen has no background of its own.
 
+## When the menus are created
+
+The screens of the menus are created with the side menu by default, with their React content. A heavy menu competes
+with the first render of the center. `options({ menusAttachMode })` moves the creation:
+
+```ts
+SideMenu({ left: 'Menu', center: 'Home' }).options({ menusAttachMode: 'onOpen' });
+```
+
+- `'together'` (the default): with the center.
+- `'afterCenter'`: right after the side menu first appears. The menus don't compete with the first render of the center and are ready at the first open.
+- `'onOpen'`: each menu the first time it starts to open, from a swipe, `openMenu`, `visible: true` or `visible` in the layout. Until React draws the menu, it shows its background (`backgroundColor`). A second open reuses it.
+
+The trade-off of `'onOpen'`: the first open of a menu doesn't wait for its render and shows its background for a moment, while a menu not opened yet runs no code. A push into the stack of such a menu and `mergeOptions` on its screen wait for the menu, like a tab not yet selected. The screens of the menus get appear events only when the menu opens, in every mode. The mode is read once, when the side menu is created, from its own options, else the default options; `mergeOptions` doesn't change it. With `appProvider` the screens render in the app's React tree at once in every mode, and the mode delays only their native containers. It means the same on iOS and Android.
+
 ## Where the swipe is off
 
 A swipe from the edge can clash with the content, such as a map or a carousel. A screen turns it off **while it is on top of the center**, in its options:

package/docs-md/containers/tabs.md

@@ -148,7 +148,7 @@ From a screen of the tab, `setTabBadge(count)` needs no id: it sets the badge of
 
 ## When tabs are created
 
-By default every tab is created with the tabs, so a switch shows it at once. `Tabs().lazy()` creates each tab the first time it shows. The app starts faster when its tabs are heavy, and a tab the user never opens costs nothing.
+By default every tab is created with the tabs, so a switch shows it at once. On (iOS) a text input's `autoFocus` in a tab not selected yet does nothing then: focus the field in `useScreenAppear`. `Tabs().lazy()` creates each tab the first time it shows. The app starts faster when its tabs are heavy, and a tab the user never opens costs nothing.
 
 ```ts
 const main = Tabs(/* … */).lazy();

package/docs-md/index.json

@@ -739,6 +739,10 @@
         "heading": "How it looks",
         "anchor": "look"
       },
+      {
+        "heading": "When the menus are created",
+        "anchor": "attach"
+      },
       {
         "heading": "Where the swipe is off",
         "anchor": "swipe"

package/ios/CLAUDE.md

@@ -20,7 +20,7 @@ Swift is not used here: apps reach the core through the public headers (`Public/
 - `Layouts/Screen/`: The screen (`ANNComponentViewController`), its presenter, readiness, its environment for JS (`ANNScreenEnvironment`), regions, safe-area math, the main list rule, previews.
 - `Layouts/External/`: Native screens: `ANNExternalViewController`, `ANNNativeScreenCalls`.
 - `Layouts/Stack/`: `ANNStackController`, `ANNStackQueue`, `ANNStackCommands`, `ANNStackPresenter`, `ANNPreviewPush`, the swipe-back delegate.
-- `Layouts/Tabs/`: `ANNBottomTabsController`, its presenter, item builder, custom row, preload window, More delegate, long press, dots.
+- `Layouts/Tabs/`: `ANNBottomTabsController`, its presenter, item builder, custom row, More delegate, long press, dots.
 - `Layouts/Modal/`: `ANNModalCoordinator`, `ANNModal`, `ANNPresentationGate`, `ANNModalPresentation`, `ANNModalTransitions`, sheets and popovers.
 - `Layouts/Overlay/`: `ANNOverlayCoordinator`, `ANNOverlayWindow`.
 - `Layouts/SideMenu/`: The side menu module and its presenter and wrapper.
@@ -106,6 +106,9 @@ Top-level files: `Package.swift` (SwiftPM; `headerFolders` lists every folder wh
   list would move as the push starts and UIKit would show the large title only after the transition. On iOS 26 its
   large title also keeps a place of the core's for the push (`arrivesByPushOn:`). Check Showcase 1.4 (with a font
   size), every section panel and 12.6 on push, pop and swipe after any change to waits, parking or the large title.
+  A tab rendered before it shows keeps its parent, yet UIKit gives its views no safe area either: it renders parked
+  in the tabs' view with places measured in the shown tab's view, then leaves the parking, since the core takes a view
+  in a window for one on screen (`isInUnseenTab:`); its screens keep that place until they appear.
 - Every change of a stack's children goes through its `ANNStackQueue`. The core's own calls to UIKit's navigation
   come only from there; UIKit's own pops are followed (`uikitShows:`), not fought.
 - Every UIKit present and dismiss in the main window is a step in `ANNPresentationGate`. UIKit drops a transition

package/ios/CORE.md

@@ -128,8 +128,8 @@ Each of these owns one rule. Call it; do not copy it.
 - `ANNNavigationState`: The visible screen and the nearest tabs it is in (the last tabs met walking down); coalesced updates, holds, the state now. Called by: The dispatcher, `ANNCommandAnswer`, `ANNRootCoordinator`, `ANNModalCoordinator`, `ANNBottomTabsController`.
 - `ANNScreenReadiness`: The signals of a screen's safe area view (has one, laid out, content rendered), sticky, by screen id. Called by: `ANNSafeAreaViewComponentView`, `ANNReactView`.
 - `ANNRenderWait`: The one wait for the render of what a command shows: content, bar components, limits, the unknown-content rule. Called by: Root, stack queue, modals, overlays, `showInColumn`.
-- `ANNParking`: Where a view waits for its content unseen: the window, a stack's view, a preview's host view. Called by: Root, stack, modals, overlays, `ANNPreviewPush`.
-- `ANNScreenPlace`: The safe area a parked screen lays out with, measured where it will show on top of a stack. Called by: `ANNStackController` (`stackPark:`), `ANNSplitViewCommands` (`showInColumn`), through `placeWhileParked` of the screen.
+- `ANNParking`: Where a view waits for its content unseen: the window, a stack's view, a preview's host view, the tabs' view. Called by: Root, stack, modals, overlays, `ANNPreviewPush`, tabs (a tab rendered before it shows).
+- `ANNScreenPlace`: The safe area a parked screen lays out with, measured where it will show on top of a stack. Called by: `ANNStackController` (`stackPark:`), `ANNSplitViewCommands` (`showInColumn`), the tabs (a tab rendered before it shows, measured in the shown tab's view), through `placeWhileParked` of the screen.
 - `ANNPendingLayers`: Layers that wait to show (a pending root, a modal, an overlay); a node inside counts as off screen. Called by: The layer's owner; nodes ask.
 - `ANNShownScreens`: "What a node shows changed": tells the pending layer, the modal hold and the system UI, in that order. Called by: Every container that changes what it shows.
 - `ANNModalCoordinator`, `ANNModal`: One record per modal, its states and waiting commands. Called by: Commands, root, state, repaint, reload.

package/ios/Core/ANNLayoutProtocol.h

@@ -11,10 +11,10 @@ NS_ASSUME_NONNULL_BEGIN
 typedef NS_ENUM(NSInteger, ANNWaitedReadiness) {
     /// The screen's content rendered: what the user sees.
     ANNWaitedReadinessContent,
-    /// The screen's root mounted once: a screen the user doesn't see yet (an unselected tab of `together`), which
-    /// renders its content only where it shows. Its part of a wait ends at the command's 0.5 s at the latest, and its
-    /// bar components are not waited for.
-    ANNWaitedReadinessRootMounted,
+    /// The screen's content rendered, on a screen the user doesn't see yet (an unselected tab of `together`, which
+    /// renders unseen in the tabs' view). Its part of a wait ends at the command's 0.5 s at the latest, and its bar
+    /// components are not waited for.
+    ANNWaitedReadinessUnseen,
 };
 
 /// A transition of the navigation is done: what it moved is in place.
@@ -97,7 +97,7 @@ typedef void (^ANNTransitionRejectionBlock)(NSString *message, NSError *_Nullabl
 - (NSArray<UIViewController *> *)waitedComponentViewControllers;
 
 /// The readiness a wait needs of `screen`, a waited screen inside this node; a node without an answer leaves it to its
-/// parents (`ANNWaitedReadinessOf`). The tabs answer "root mounted" for the screens of their unselected tabs.
+/// parents (`ANNWaitedReadinessOf`). The tabs answer "unseen" for the screens of their unselected tabs.
 - (ANNWaitedReadiness)waitedReadinessOfScreen:(UIViewController *)screen;
 
 #pragma mark - The children

package/ios/Core/ANNParking.h

@@ -4,10 +4,11 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// A place where the views of nodes wait for their content unseen (their safe area views lay out only in a window): the
 /// window under the current root while a root waits, a stack's view under UIKit's container while a screen of the stack
-/// waits or renders. A parked view sits at the back of its host, at the host's size and following it (a rotation, a
-/// resize), gets no touches and is hidden from accessibility; it isn't a child of anything there, and its node's
-/// appearance is driven meanwhile (`ANNAppearanceDispatcher driveAppearanceOf:`), so UIKit's appearance callbacks
-/// report nothing for it. Each node leaves it as it was. Main queue.
+/// waits or renders, the tabs' view while a tab rendered before it shows renders its content. A parked view sits at the
+/// back of its host, at the host's size and following it (a rotation, a resize), gets no touches and is hidden from
+/// accessibility; it isn't a child of anything there (a tab stays the tabs' child), and its node's appearance is driven
+/// meanwhile (`ANNAppearanceDispatcher driveAppearanceOf:`), so UIKit's appearance callbacks report nothing for it.
+/// Each node leaves it as it was. Main queue.
 @interface ANNParking : NSObject
 
 /// `node`'s view waits in `host` from now on, with what it had kept. NO when it waits here already.

package/ios/Core/ANNReloadCoordinator.mm

@@ -15,7 +15,6 @@
 #import "ANNScreenReadiness.h"
 #import "ANNSplashViewController.h"
 #import "ANNSplitViewCommands.h"
-#import "ANNTabsPreloadWindow.h"
 #import "ApexNavigation+Internal.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <React/RCTConstants.h>
@@ -143,9 +142,7 @@ static BOOL ANNWatchingBundles;
     [oldScreens addObjectsFromArray:[ANNOverlayCoordinator takeAllForReload]];
     // 4. The bar components and the tabs' cells and accessories have no store to empty: each screen and each tabs node
     // keeps its own roots in its registry, so a new node never gets an old root by its id, and the old roots stop with
-    // their old nodes after the hold. The tabs' preload windows hide at once; their views go with their tabs. The loop
-    // updates are off already.
-    [ANNTabsPreloadWindow hideAllAfterReload];
+    // their old nodes after the hold. The loop updates are off already.
     // 5. The native screens of the old screens are silent by their emitter. The modals and overlays waiting to show
     // left what waits for them in steps 2 and 3; the screens that wait to show in a split view's column leave it here,
     // without an answer.

package/ios/Core/ANNRenderWait.h

@@ -36,7 +36,7 @@ typedef NS_ENUM(NSInteger, ANNRenderWaitBar) {
 
 /// `screens` gives the screens the wait is about: their bar components, the screens the limit marks ready, the screens
 /// of the unknown-content rule, and with `ANNRenderWaitContentEachScreen` the screens whose content it waits for, each
-/// by the readiness it needs (`ANNWaitedReadinessOf`: content, or "root mounted" without its bar components). It is
+/// by the readiness it needs (`ANNWaitedReadinessOf`: content, or "unseen" content without its bar components). It is
 /// asked as the wait starts, as it takes its screens again (`retakeScreens:`) and as its bar phase starts. `node` is
 /// the node of `ANNRenderWaitContentNode`; nil otherwise. `limit` 0: no limit.
 - (instancetype)initWithContent:(ANNRenderWaitContent)content
@@ -49,10 +49,10 @@ typedef NS_ENUM(NSInteger, ANNRenderWaitBar) {
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/// The longest a waited screen of the "root mounted" kind (`ANNWaitedReadinessOf`, an unselected tab's screen) is
-/// waited for, from the start, also when the wait has no limit: a screen the user doesn't see never holds a command for
-/// long. 0: only the wait's own limit.
-@property(nonatomic) NSTimeInterval mountLimit;
+/// The longest a waited screen of the "unseen" kind (`ANNWaitedReadinessOf`, an unselected tab's screen) is waited
+/// for, from the start, also when the wait has no limit: a screen the user doesn't see never holds a command for long.
+/// 0: only the wait's own limit.
+@property(nonatomic) NSTimeInterval unseenLimit;
 
 /// The rule for content of unknown readiness: 1 s after the start, a screen whose rendered state stays unknown (no safe
 /// area view says it) counts as ready; a screen whose safe area view spoke waits for its signal. Off by default (a root