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

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # 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)
+
+
+### Bug Fixes
+
+* group options reach the screens that show, and the android bar hides as it shows ([#63](https://github.com/apexnative/navigation/issues/63)) ([474ca8a](https://github.com/apexnative/navigation/commit/474ca8aae53e5284d64a5d90dd852fdbdcbabcac))
+* **ios:** overlays and preloaded tabs take the scheme the app set with Appearance.setColorScheme ([#61](https://github.com/apexnative/navigation/issues/61)) ([232d7e0](https://github.com/apexnative/navigation/commit/232d7e038b53cd9656e59c7cfa5cbf0f52f9b587))
+
 ## [1.0.0-alpha.7](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.6...v1.0.0-alpha.7) (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/viewcontrollers/stack/topbar/TopBarPresenter.kt

@@ -129,6 +129,8 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
     // The bar goes with the screens of a transition of the stack's own, and the screen that leaves with its picture.
     private var travelling = false
     private var travelLeaving: ViewController<*>? = null
+    // The bar hides as it shows now, and the options of the screen it hides for wait until it is gone.
+    private var waitsForHide = false
 
     private enum class Part { Look, Title, Left, Right, Back, LargeTitle, Visible, TestId }
 
@@ -141,7 +143,7 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         this.bar = bar
         leftButtons = ButtonBar(bar.leftButtonBar, ::loadIcon, Buttons())
         rightButtons = ButtonBar(bar.rightButtonBar, ::loadIcon, Buttons())
-        visibility = TopBarVisibility(VisibilityTarget(bar) { collapse?.reset() })
+        visibility = TopBarVisibility(VisibilityTarget(bar) { collapse?.reset() }, ::hidden)
         rowTransition = BarRowTransition(RowTarget(bar).also { rowTarget = it })
         collapse = TopBarCollapseBehavior(bar)
         bar.leftButtonBar.setNavigationOnClickListener { host.backPressed() }
@@ -182,6 +184,7 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         val bar = bar
         val leaving = shownEntry
         val lowers = bar != null && bar.isLargeTitleShown && incoming != null && leaving != null &&
+            !hidesMoving(host.resolvedOf(incoming), visibility, travel != null) &&
             lowersBar(motion, incoming, host.resolvedOf(incoming))
         rowTarget?.withLargeTitle = !lowers
         if (lowers) pictureUnderRow(bar, leaving)
@@ -190,6 +193,15 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         if (travel != null && bar != null && incoming != null) beginTravel(bar, leaving, incoming, travel, visibility)
     }
 
+    // Whether a screen with [options] hides the bar, shown now, by a move of [change]: a slide, or the transition's
+    // side. The bar then leaves as it shows, its large title too (`applyAll`); while it goes with the screens of a
+    // transition of the stack's own ([travels]) only a side of its own moves it.
+    private fun hidesMoving(options: Options, change: StackDisplay.BarVisibility, travels: Boolean): Boolean {
+        val exit = change.side?.exit
+        return options.topBar.visible.isFalse && !options.topBar.animate.isFalse && change.animated &&
+            !AnimationRules.isTurnedOff(exit) && (!travels || AnimationRules.barSideGiven(exit))
+    }
+
     /** The transition that brought the current child ended: the row at rest, the picture under it gone. */
     fun endRowTransition() {
         // A large title still opening is open now.
@@ -306,6 +318,7 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
      * of the bar (the search) applies again.
      */
     fun onInsets() {
+        if (waitsForHide) return
         val bar = bar ?: return
         val entry = shownEntry ?: return
         val screen = shownScreen ?: return
@@ -380,6 +393,12 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
 
     /** [screen] is destroyed: its components and its search go. */
     fun screenDestroyed(screen: ViewController<*>, entryView: View?) {
+        // The bar may still show the components of the screen that goes: it is gone at once, with the options it held
+        // back, before they go; none when they are of the screen that goes.
+        if (waitsForHide) {
+            if (screen === shownScreen) waitsForHide = false
+            visibility?.hide(animated = false)
+        }
         if (screen === shownScreen) {
             shownScreen = null
             shownEntry = null
@@ -466,6 +485,26 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         merge: Boolean,
         delta: Options? = null,
     ) {
+        // A screen that hides the bar: the bar leaves as it shows, its look, title and buttons those of the screen
+        // before, and takes this screen's options once it is gone. Taken first, they would paint the leaving bar (the
+        // default color over a bar that was transparent).
+        val waited = waitsForHide
+        waitsForHide = false
+        if (options.topBar.visible.isFalse && (!merge || waited)) {
+            applyVisibility(options, merge)
+            waitsForHide = visibility?.isHiding == true
+            if (waitsForHide) {
+                // The list of the screen before no longer moves the bar: a move of it would stop the hide.
+                collapse?.disableCollapse(reset = false)
+                return
+            }
+        }
+        // Shown again by a merge before it was gone: none of this screen's options are on the bar yet. It shows as a
+        // merge shows it, by `animate`, not by the transition's side.
+        if (merge && waited) {
+            visibilityChange = StackDisplay.BarVisibility(true, null)
+            return applyAll(bar, entry, screen, options, merge = false)
+        }
         applyLook(bar, entry, options)
         applyTitle(bar, screen, options)
         // The search first: its magnifier takes a place among the right buttons. It gets a copy of the group: it
@@ -794,6 +833,16 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         opening.cancel()
     }
 
+    // A hide that held the options back ended: the bar, gone now, takes them.
+    private fun hidden() {
+        if (!waitsForHide) return
+        waitsForHide = false
+        val bar = bar ?: return
+        val entry = shownEntry ?: return
+        val screen = shownScreen ?: return
+        applyAll(bar, entry, screen, host.resolvedOf(entry), merge = false)
+    }
+
     // Shown or hidden: with the transition by its side, or by `animate` in a merge.
     private fun applyVisibility(options: Options, merge: Boolean) {
         val visible = !options.topBar.visible.isFalse

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

@@ -10,9 +10,10 @@ import dev.apexnative.navigation.views.animations.AnimationRules
  * stack its side (`animations.*.topBar`) plays instead — its `exit` hides, its `enter` shows; `enabled: false` shows or
  * hides at once. A show cancels a running hide and a hide a running show, each with its own token, so `visible: false`
  * then `true` leaves the bar shown; a motion cancelled leaves the bar at rest; a bar shown again stands in its place
- * with its row seen (the hide on scroll's shift and fade reset). Main thread only.
+ * with its row seen (the hide on scroll's shift and fade reset). [onHidden] runs once a hide has made the bar `GONE`.
+ * Main thread only.
  */
-internal class TopBarVisibility(private val target: Target) {
+internal class TopBarVisibility(private val target: Target, private val onHidden: () -> Unit = {}) {
     /** What moves: the bar's view, or the unit tests' fake. */
     interface Target {
         /** How far up the bar goes to hide: its height and the room over it, in pixels. */
@@ -45,6 +46,10 @@ internal class TopBarVisibility(private val target: Target) {
     val isHidden: Boolean
         get() = hidden
 
+    /** The bar is on its way out: a hide moves it and it still shows. */
+    val isHiding: Boolean
+        get() = hidden && sliding != null
+
     /** Shows the bar: by [side] when it plays, sliding down when [animated], else at once. */
     fun show(animated: Boolean, side: TopBarAnimationOptions? = null) {
         val wasHidden = hidden
@@ -84,6 +89,7 @@ internal class TopBarVisibility(private val target: Target) {
         if (!moves || target.isGone) {
             target.translationY = 0f
             target.isGone = true
+            onHidden()
             return
         }
         val token = Any()
@@ -93,6 +99,7 @@ internal class TopBarVisibility(private val target: Target) {
                 settle()
                 target.isGone = true
                 target.translationY = 0f
+                onHidden()
             }
         }
         val own = side?.takeIf { AnimationRules.sidePlays(it) }

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
@@ -133,7 +136,10 @@ Top-level files: `Package.swift` (SwiftPM; `headerFolders` lists every folder wh
 - Use an `@available` check for newer OS APIs, and `#if __IPHONE_OS_VERSION_MAX_ALLOWED >= …` for names of a newer SDK.
 - React Native hears of the app's light or dark style only from its hosting views in the window. A view that stands in
   for one (`ANNSlotScreenView`, the screens of one tree) posts the trait change itself, with the window filter of
-  `ANNSurfaceHostingView`; without it `useColorScheme` keeps the old theme.
+  `ANNSurfaceHostingView`; without it `useColorScheme` keeps the old theme. `Appearance.setColorScheme` sets the style
+  only on the windows there are at that moment: every window the core makes but the main window comes from
+  `+[ANNUtils makeWindowOfClass:]`, which gives it the main window's style. A window of the system's style would draw
+  its screens in the other theme, and its hosting views would switch the app's theme in JS.
 - A step that runs later in a command (a ready handler, a timer, a transition's end) goes through the owner's guard
   (`protect:step:`), so an exception rejects the command instead of crashing the app. So does the start of a wait
   (the root, a modal, an overlay: their record is listed and parked by then), and the modal's end steps inside UIKit's

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.