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

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

@@ -270,8 +270,8 @@ class StackController(
 
     /**
      * The default pop of the top is what back does now and it can be previewed: two entries or more, nothing running
-     * or waiting, no open search, the top doesn't hold back and pops with the default transition, the screen under it
-     * has its view, and the stack shows.
+     * or waiting, no open search, the top doesn't hold back, pops with the default transition and doesn't turn the
+     * preview off (`animations.pop.preview: false`), the screen under it has its view, and the stack shows.
      */
     override fun stackPoppedByBack(): StackController? {
         if (topBar.isSearchOpen() || !queue.isAtRest) return null
@@ -282,9 +282,8 @@ class StackController(
         if (!queue.isRendered(target) || backGesture != null) return null
         val options = resolvedOf(top)
         val pop = options.animations.pop
-        if (options.hardwareBackButton.popStackOnPress.isFalse || pop.enabled.isFalse || AnimationRules.stackIsOwn(pop)) {
-            return null
-        }
+        if (options.hardwareBackButton.popStackOnPress.isFalse || pop.enabled.isFalse) return null
+        if (pop.preview.isFalse || AnimationRules.stackIsOwn(pop)) return null
         val display = queue.display
         return this.takeIf { display.isOnScreen && display.canAnimate }
     }
@@ -694,15 +693,20 @@ class StackController(
     private fun optionsScreen(node: ViewController<*>): ViewController<*> =
         (node as? OptionsScreen)?.optionsScreen ?: node
 
+    // What back does is computed again on each change of the queue (BackCallbackState): its entries change as an
+    // operation is accepted, the screen whose options count as its current child changes (a push that waited for its
+    // screen begins after its command), and an operation ends or rejects.
     private inner class QueueHost : StackQueue.Host {
         override fun operationAccepted() {
             backGesture?.abort()
+            BackCallbackState.update()
         }
 
         // The bar takes the options of the new top at once, also without appearance events.
         override fun currentChildChanged() {
             updateBar()
             navigator?.shownScreensChanged(this@StackController)
+            BackCallbackState.update()
         }
 
         // Before the bar takes the new top's options: the row's picture or the bar's travel, and how it shows or hides.

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

@@ -36,6 +36,8 @@ import dev.apexnative.navigation.views.stack.topbar.search.SuggestionList
 class ScreenSearch(
     private val host: Host,
     private val screenId: String,
+    /** The sender of the JavaScript the screen was made for: silent once it went. */
+    private val emitter: EventEmitter,
     private val context: Context,
     private val loadIcon: (String) -> Drawable?,
     /** A scope the user picks goes into the screen's options, so it stays when they apply again. */
@@ -45,7 +47,6 @@ class ScreenSearch(
         /** The search changed what the bar shows (open or closed, its text): shown again if it is the shown one. */
         fun refresh(search: ScreenSearch)
         fun isShown(search: ScreenSearch): Boolean
-        fun emitter(): EventEmitter?
         fun keyboard(view: View, show: Boolean)
         /** The stack's view: a search view goes over it. */
         fun stackView(): ViewGroup?
@@ -402,7 +403,7 @@ class ScreenSearch(
 
     // A pick sends searchSuggestionPicked with the suggestion's id; the text stays.
     private fun pickSuggestion(suggestionId: String) {
-        host.emitter()?.emitSearchSuggestionPicked(screenId, suggestionId)
+        emitter.emitSearchSuggestionPicked(screenId, suggestionId)
         setSuggestions(emptyList())
     }
 
@@ -426,18 +427,15 @@ class ScreenSearch(
     private fun sendUpdate(
         focused: Boolean = isActive && (panel?.searchView?.editText ?: searchField.editText).hasFocus(),
     ) {
-        val emitter = host.emitter() ?: return
         eventTargets().forEach { emitter.emitSearchBarUpdated(it, text, focused, scope()) }
     }
 
     private fun sendCancel() {
-        val emitter = host.emitter() ?: return
         eventTargets().forEach { emitter.emitSearchBarCancelPressed(it) }
         sendUpdate()
     }
 
     private fun sendSubmit() {
-        val emitter = host.emitter() ?: return
         eventTargets().forEach { emitter.emitSearchBarSubmitted(it, text, scope()) }
     }
 

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

@@ -12,7 +12,6 @@ import androidx.appcompat.content.res.AppCompatResources
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.ReactApplication
 import dev.apexnative.navigation.options.SearchBarOptions
 import dev.apexnative.navigation.options.params.ThemeColour
 import dev.apexnative.navigation.react.events.EventEmitter
@@ -137,9 +136,6 @@ class StackSearchPresenter(
         refresh()
     }
 
-    override fun emitter(): EventEmitter? =
-        (activity.application as? ReactApplication)?.reactHost?.currentReactContext?.let { EventEmitter(it) }
-
     override fun keyboard(view: View, show: Boolean) {
         val controller = WindowCompat.getInsetsController(activity.window, view)
         if (show) controller.show(WindowInsetsCompat.Type.ime()) else controller.hide(WindowInsetsCompat.Type.ime())
@@ -150,7 +146,8 @@ class StackSearchPresenter(
             // The search of a pair of screens is its primary's: its events name that screen, which keeps the scope in
             // its user layer, where a merge that sends the same options again doesn't take it away.
             val owner = (screen as? OptionsScreen)?.optionsScreen ?: screen
-            ScreenSearch(this, owner.id, styleContext(), loadIcon) { scope ->
+            // Its events go to the JavaScript the screen was made for, and to no other.
+            ScreenSearch(this, owner.id, EventEmitter.of(owner.jsGeneration), styleContext(), loadIcon) { scope ->
                 owner.changeChoices { it.pickScope(scope) }
             }
         }

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

@@ -5,7 +5,6 @@ import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.options.TitleComponentOptions
 import dev.apexnative.navigation.options.TopBarBackgroundComponentOptions
 import dev.apexnative.navigation.options.params.Text
-import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.IReactView
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
@@ -15,7 +14,8 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
  * same root, never made again; another replaces it, and the old one stops at once. A background with the same `name`
  * and `componentId` on several screens is one root, shared; it stops when no screen of the stack names it any more. The
  * roots go with their screen ([screenDestroyed]) or the stack ([destroyAll]). Each root renders at once, without
- * waiting for its layout: [makeRoot] marks its id so before its surface starts. Main thread only.
+ * waiting for its layout: [makeRoot] makes it so (`ReactView`'s `rendersAtOnce`), and each answers by its own render
+ * when several live roots show one id (`ScreenReadiness`). Main thread only.
  */
 internal class BarComponents(private val makeRoot: (componentId: String, name: String) -> IReactView) {
     /** A root of the bar: what it renders, and its content. */
@@ -151,18 +151,10 @@ internal class BarComponents(private val makeRoot: (componentId: String, name: S
         backgrounds.remove(key)?.let(::stop)
     }
 
-    // Made first, counted after: the maker asks whether another root with the id lives.
-    private fun make(key: Key): Root {
-        val root = Root(key.name, key.componentId, makeRoot(key.componentId, key.name))
-        LiveIds.add(key.componentId)
-        return root
-    }
+    private fun make(key: Key): Root = Root(key.name, key.componentId, makeRoot(key.componentId, key.name))
 
-    // Stops a root once; what the readiness store kept of its id goes unless another live root holds the id.
-    private fun stop(root: Root) {
-        root.view.destroy()
-        if (LiveIds.remove(root.componentId)) ScreenReadiness.remove(root.componentId)
-    }
+    // Stops a root once; its content takes its mark of rendering at once with it.
+    private fun stop(root: Root) = root.view.destroy()
 
     private fun keyOf(name: Text, componentId: Text, id: Text): Key? {
         val componentName = name.get(null)?.takeIf { it.isNotEmpty() } ?: return null
@@ -170,42 +162,4 @@ internal class BarComponents(private val makeRoot: (componentId: String, name: S
             ?: return null
         return Key(componentName, rootId)
     }
-
-    companion object {
-        /** Whether a bar root with [id] is alive now, in any stack. */
-        fun isLive(id: String): Boolean = LiveIds.has(id)
-
-        /**
-         * Another root that renders at once lives with [id] (a cell of the tabs' custom row): it counts as the bar's
-         * roots do, so a root that stops clears the id's readiness only when it was the last one with it.
-         */
-        internal fun rootMade(id: String) = LiveIds.add(id)
-
-        /** A root of [rootMade] stopped; true when no live root has [id] any more. */
-        internal fun rootStopped(id: String): Boolean = LiveIds.remove(id)
-
-        /** The JavaScript went (a reload): no id counts as held by a live root any more, as `ScreenReadiness.reset`. */
-        fun reset() = LiveIds.clear()
-    }
-
-    // The ids of the bar roots alive now, in every stack: a root that stops clears its id's readiness only when it was
-    // the last one with it.
-    private object LiveIds {
-        private val counts = HashMap<String, Int>()
-
-        fun has(id: String): Boolean = (counts[id] ?: 0) > 0
-
-        fun clear() = counts.clear()
-
-        fun add(id: String) {
-            counts[id] = (counts[id] ?: 0) + 1
-        }
-
-        // True when no root with the id is left.
-        fun remove(id: String): Boolean {
-            val count = (counts[id] ?: return true) - 1
-            if (count <= 0) counts.remove(id) else counts[id] = count
-            return count <= 0
-        }
-    }
 }

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

@@ -41,7 +41,6 @@ import dev.apexnative.navigation.utils.ImageLoader
 import dev.apexnative.navigation.utils.ImageLoadingListenerAdapter
 import dev.apexnative.navigation.utils.TestIds
 import dev.apexnative.navigation.utils.UiUtils
-import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay
 import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.BarMotion
@@ -936,14 +935,10 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         return resolved.component
     }
 
-    private fun makeRoot(componentId: String, name: String): IReactView {
-        // A component of the bar renders at once, without waiting for its layout, from before its surface starts.
-        ScreenReadiness.setRendersAtOnce(componentId, true)
-        // Another live root has this id (a component of the stack's options on two screens): what it rendered isn't
-        // this root's, which answers by its own render.
-        if (BarComponents.isLive(componentId)) ScreenReadiness.forgetRender(componentId)
-        return ReactView(activity, componentId, name)
-    }
+    // A component of the bar renders at once, without waiting for its layout. Another live root may show the same id
+    // (a component of the stack's options on two screens): each answers by the render of its own surface.
+    private fun makeRoot(componentId: String, name: String): IReactView =
+        ReactView(activity, componentId, name, rendersAtOnce = true)
 
     private fun loadIcon(uri: String): Drawable? {
         var loaded: Drawable? = null

package/android/src/main/java/dev/apexnative/navigation/views/bottomtabs/CustomBottomTabItemView.kt

@@ -22,9 +22,6 @@ open class CustomBottomTabItemView(context: Context) : FrameLayout(context) {
     private var state: TabCellState? = null
     private var destroyed = false
 
-    /** Runs once as the cell stops: what was kept for its content's id goes. */
-    internal var onDestroyed: (() -> Unit)? = null
-
     /** The content the cell shows, filling it, made with [state] as its first props. */
     internal fun show(view: IReactView, state: TabCellState) {
         content = view
@@ -68,8 +65,6 @@ open class CustomBottomTabItemView(context: Context) : FrameLayout(context) {
         didDisappear()
         destroyed = true
         content?.destroy()
-        onDestroyed?.invoke()
-        onDestroyed = null
     }
 
     /** The props of [state] as React Native takes them. */

package/cli/doctor/checks/splash.js

@@ -17,34 +17,16 @@ const CIRCLE = 192;
 const LOGO_HEIGHT = /<dimen name="apex_navigation_splash_logo_height">([\d.]+)dp<\/dimen>/;
 
 /**
- * The native splash: made from its settings in package.json on both platforms, its logo whole on Android 12+; without
- * settings, a launch screen the navigation can't keep on screen until the first screen draws.
+ * The native splash: made from its settings in package.json on both platforms, its logo whole on Android 12+. Without
+ * settings there is nothing to check: the navigation keeps a copy of a storyboard and of `UILaunchScreen` alike.
  * @param {string} root
  * @param {Project} project
  * @returns {Check[]}
  */
 function splashChecks(root, project) {
-  const plist = project.infoPlist && fs.readFileSync(project.infoPlist, 'utf8');
   const saved = readConfig(root).splash;
-  if (!saved) {
-    // UILaunchScreen alone: iOS shows it, but the navigation keeps only a storyboard while the first screen renders.
-    if (
-      plist?.includes('<key>UILaunchScreen</key>') &&
-      !plist.includes('<key>UILaunchStoryboardName</key>')
-    ) {
-      return [
-        {
-          group: 'app',
-          title: 'Launch screen',
-          status: 'warn',
-          detail:
-            'UILaunchScreen in Info.plist: an empty window shows between it and the first screen',
-          fix: SPLASH,
-        },
-      ];
-    }
-    return [];
-  }
+  if (!saved) return [];
+  const plist = project.infoPlist && fs.readFileSync(project.infoPlist, 'utf8');
   const resolved = resolveSettings(root, {}, saved);
   if ('errors' in resolved) {
     return [

package/cli/splash/index.js

@@ -88,7 +88,9 @@ async function splash({
   }
   const plist = project.infoPlist && fs.readFileSync(project.infoPlist, 'utf8');
   if (plist?.includes('<key>UILaunchScreen</key>')) {
-    command.warn('Info.plist has UILaunchScreen too: remove it, so that iOS shows the storyboard.');
+    command.warn(
+      'Info.plist has UILaunchScreen too: iOS shows it instead of the storyboard; remove it, so that iOS shows the storyboard.'
+    );
   }
   return command.apply(
     [

package/docs-md/containers/modals.md

@@ -52,8 +52,8 @@ Compose shows with a close button at the leading edge of its top bar. The settin
 
 | Setting | What it does |
 | --- | --- |
-| `closeButton` | A close button on the first screen: the system one on iOS, an icon on Android. Needs the stack. |
-| `onDismiss` | Called once the modal is gone, whatever closed it: a swipe, a command, a new root. |
+| `closeButton` | A close button on the first screen: the system one on iOS, an icon on Android. Needs the stack. A new first screen from `setStack` or `replace` in the modal's stack gets it too. |
+| `onDismiss` | Called once the modal is gone, whatever closed it: a swipe, a command, a new root. `setStack` and `replace` in the modal's stack replace its first screen and call it too. |
 | `stack` | `false`: the screen alone, without a stack and its top bar. |
 | `style`, `sheet`, `popover`, `contentSize` | How it looks: see [How a modal looks](#styles). |
 | `transition`, `options` | The animation, and the screen's options for this show. |

package/docs-md/guides/cli.md

@@ -311,7 +311,7 @@ Each file and why: [What the command writes](./splash-screen#files).
 - **The settings** go into `package.json`, under `apexNavigation.splash`. An option given replaces its saved value; to drop the dark logo or color, remove `darkLogo` or `darkBackground` there and run the command again.
 - **A logo whose corners leave the circle** of Android 12's splash icon, 192 dp, gets a warning: Android cuts them. Make `--logo-width` smaller, or give the logo room around it.
 - **A file it can't change** is listed as `manual`, with the change to make: an app without `Images.xcassets` next to `Info.plist`, a manifest whose `MainActivity` and `<application>` have no theme to go over.
-- **`Info.plist` with `UILaunchScreen`** as well gets a warning: remove that dictionary, so that iOS shows the storyboard.
+- **`Info.plist` with `UILaunchScreen`** as well gets a warning: iOS shows that dictionary instead of the storyboard, so remove it.
 - **Its errors** in the JSON: `splash-settings` for a setting it can't take, `splash-image` for a logo it can't read or that doesn't fit (too tall at its width, a dark logo of other proportions), and `sharp-missing`, as for `icons`.
 
 `doctor` checks the splash in the App group:
@@ -320,7 +320,6 @@ Each file and why: [What the command writes](./splash-screen#files).
 | --- | --- |
 | Splash | The files of iOS or Android aren't made from the settings in `package.json`: changed by hand, made on one platform only, or by an older version of the command. Or the settings themselves are wrong, such as a logo that isn't there. |
 | Splash logo | The logo's corners leave Android 12's circle. |
-| Launch screen | Without settings: `Info.plist` has `UILaunchScreen` and no storyboard. iOS shows it at launch, but the navigation can only keep a storyboard on screen, so an empty window shows between it and the first screen. |
 
 Each warning names its fix, such as `npx apex-navigation splash`; `--fix` leaves these to you. What the user sees, and a splash of your own after the native one: [Splash screen](./splash-screen).
 

package/docs-md/help/troubleshooting.md

@@ -232,9 +232,9 @@ A signed-in user sees Login for a moment, then the app.
 
 (iOS) Between the launch screen and the first screen, the window is empty for a moment.
 
-**Why:** the launch screen is made with the `UILaunchScreen` dictionary of `Info.plist`, not a storyboard. The navigation keeps a copy of a storyboard on screen until the first root, and can't make one of the dictionary. `doctor` warns about it under Launch screen.
+**Why:** the app has no launch screen the navigation can copy: `Info.plist` names no storyboard and has no `UILaunchScreen` dictionary (or `UILaunchScreens` default), and no legacy launch images.
 
-**Fix:** run `npx apex-navigation splash`, or name a storyboard in `UILaunchStoryboardName` and remove `UILaunchScreen`. More: [Make the native splash](../guides/splash-screen#command).
+**Fix:** run `npx apex-navigation splash`, or name a storyboard in `UILaunchStoryboardName`. More: [Make the native splash](../guides/splash-screen#command).
 
 ### Android brings the app back without its pushed screens
 

package/docs-md/screen-ui/back-and-gestures.md

@@ -106,6 +106,17 @@ export const MapScreen = defineScreen({
 
 The preview shows when back pops the screen with the default transition. It doesn't when back does something else first, or when the app takes it: a menu or a search that closes, a screen that holds back (`hardwareBackButton.popStackOnPress: false`, a [`BackHandler` listener](#back-handler), `usePreventLeave`), or a pop with an animation of its own (`animations.pop`). On Android 13 and older the screen pops when the swipe ends.
 
+`animations.pop.preview: false` turns the preview off for a screen: the gesture shows nothing, and the screen pops when the user lets go, as on Android 13. It is read from the screen that goes, so the app's `options` turn it off everywhere:
+
+```ts
+defineScreen({
+  component: Checkout,
+  options: { animations: { pop: { preview: false } } },
+});
+```
+
+iOS ignores it: the swipe back there is UIKit's.
+
 ### Back to the home screen
 
 (Android) On the first screen of the app, with nothing left to go back to, the navigation leaves the back to the system. The system then plays its predictive back animation: as the user swipes, the app shrinks and the home screen shows behind it, and the user can still change their mind halfway. The system decides this as the swipe starts, so the navigation takes the back only while it has something to do with it: a screen to pop, a modal, a menu or a search to close, a tab to go to (`backBehavior`), or a [`BackHandler` listener](#back-handler) of the app.
@@ -122,6 +133,17 @@ Without it, back on the first screen still leaves the app, at once. See [What se
 
 With the animation on, the system leaves the app itself: an `invokeDefaultOnBackPressed` of the app's `MainActivity` (such as `moveTaskToBack(true)`) isn't called on the first screen. Without it, and before Android 13, the back goes through the activity as before.
 
+`hardwareBackButton.systemAnimation: false` keeps the back in the app on the first screen too, so the system plays no animation there: the gesture shows nothing, and on release the press goes to the [`BackHandler` listeners](#back-handler), then to the activity's own back, `invokeDefaultOnBackPressed` included. It is read from the screen back acts on; for the whole app, set it in the app's `options`:
+
+```ts
+createNavigation({
+  // …
+  options: { hardwareBackButton: { systemAnimation: false } },
+});
+```
+
+iOS ignores it.
+
 ### Handling back yourself: BackHandler
 
 (Android) React Native's `BackHandler` works on every screen, as in any React Native app. A listener runs before the navigation's own back: returning `true` takes the press, `false` passes it on to the next listener, then to the navigation.

package/docs-md/start/installation.md

@@ -215,7 +215,7 @@ export {};
 
 | Group | What it checks |
 | --- | --- |
-| App | React Native and the New Architecture, the package, the files `setup` sets up, the entry point, React Native loaded twice, the status bar of the template, the generated code of native screens. Typed commands: `navigation-env.d.ts` there, pointing to the navigation, with its `context` line, and read by `tsconfig.json`. The splash screen made from its settings, with its logo inside the circle of Android's splash icon, and an iOS launch screen made with `UILaunchScreen` and no storyboard, which the navigation can't keep on screen. The app icon made from its settings, and an iOS icon set with no image, which the App Store refuses. |
+| App | React Native and the New Architecture, the package, the files `setup` sets up, the entry point, React Native loaded twice, the status bar of the template, the generated code of native screens. Typed commands: `navigation-env.d.ts` there, pointing to the navigation, with its `context` line, and read by `tsconfig.json`. The splash screen made from its settings, with its logo inside the circle of Android's splash icon. The app icon made from its settings, and an iOS icon set with no image, which the App Store refuses. |
 | Navigation | From the app's code. Screens: no name given twice in `screens` and the groups, and no file of the screens' folder with a `defineScreen` or `nativeScreen` that no file imports, a screen made and never added. Links: each prefix of `linking` declared on both platforms, the declarations no prefix has, a main activity that isn't `singleTask`. Screen names, in a JavaScript app only: a name that `push`, `replace`, `showModal` or `showInColumn` gives and no screen has, with its file and line. |
 | (Android) | JDK 17 in use, the Android SDK, `minSdk`, how edge-to-edge works in the app. |
 | (iOS) | Xcode 26 or newer, CocoaPods, the pods of the navigation and whether they are out of date, the iOS version of the Podfile. |

package/ios/CORE.md

@@ -87,10 +87,10 @@ dispatcher.
    `ANNStackAnimatingDelegate` give UIKit the `ANNTransitionAnimator`.
 7. **The end.** `stackWhenTransitionEnds:` fires from the transition coordinator and calls `endPush:`, which calls
    `+[ANNAppearanceDispatcher endTransitionHiding:showing:events:answer:value:]`. In this order: `ComponentDidDisappear`
-   of Home, `ComponentDidAppear` of Profile, `ANN.NavigationStateChanged` (`+[ANNNavigationState updateNow]`), the
-   transition's `events`, then `-[ANNCommandAnswer resolve:]`: the state again if it changed
-   (`reportBeforeAnswerOf:`), the promise with Profile's id, then `ANN.CommandCompleted`. `finish:` frees the queue for
-   the next operation.
+   of Home, `ComponentDidAppear` of Profile, `ANN.NavigationStateChanged` (`-[ANNCommandAnswer reportStateNow]`, the
+   answer's one state step), the transition's `events`, then `-[ANNCommandAnswer resolve:]`: the promise with
+   Profile's id, then `ANN.CommandCompleted`. A command answered without a transition's end (`setRoot` with layout
+   modals) sends its state from `resolve:`. `finish:` frees the queue for the next operation.
 
 Events go out through `ANNEventEmitter` on the main queue and reach JS through `ANNTurboEventEmitter`.
 
@@ -117,13 +117,13 @@ Each of these owns one rule. Call it; do not copy it.
 
 - `ANNCommandRunner`: The one path of every async command: generation, check, main queue, exception guard. Called by: `ANNTurboModule`.
 - `ANNLayoutReader`: The layout check, depth first, the same order and texts as Android. Module queue. Called by: The runner's check blocks.
-- `ANNCommandAnswer`: The answer: state, then promise, then `ANN.CommandCompleted`; once; silent for a JavaScript that went. Called by: Every coordinator and queue.
+- `ANNCommandAnswer`: The answer: state (one step per answer, `reportStateNow`, asked by the end of its transition or by `resolve:`), then promise, then `ANN.CommandCompleted`; once; silent for a JavaScript that went. Called by: Every coordinator and queue.
 - `ANNNodeRegistry`: Every node by id, weakly. Filled by the factory, cleared at a reload. Called by: Commands, modules, `findViewController:`.
 - `ANNLayoutFactory`: The core code that names module classes (`ANNSplitViewController`, `ANNSideMenuViewController`, `ANNArrangementViewController`); `ANNSideMenuPresenter` is the one other file that does. One maker per layout type; registers each node. Called by: Every command that shows a layout.
 - `ANNOptionsCache`: The one invalidation point of resolved options. Called by: The setters of `ANNNodeHelper.options` and of its user layer (`setUserChoice:forKey:`), and `ANNDefaultOptions`, only.
 - `ANNNodeHelper resolveOptionsWithDefault`: What a node shows with: defaults, parents' own options (each with its user layer), the node's `resolveOptions` (own, its user layer, then the current child down). Cached, read-only. Called by: Presenters, coordinators.
 - `ANNAppearanceDispatcher`: The only sender of `ComponentWillAppear`, `ComponentDidAppear`, `ComponentDidDisappear`; the end-of-transition order; the events of a node that goes. Called by: Screens, queues, coordinators.
-- `ANNNavigationState`: The visible screen and the nearest tabs it is in (the last tabs met walking down); coalesced updates, holds, the state before an answer. Called by: The dispatcher, `ANNCommandAnswer`, `ANNRootCoordinator`.
+- `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`.

package/ios/Contract/ANNCommandAnswer.h

@@ -27,8 +27,15 @@ NS_ASSUME_NONNULL_BEGIN
 /// Whether the JavaScript the command came from still runs: its work goes on only then.
 @property(nonatomic, readonly) BOOL isCurrent;
 
-/// Resolves the promise: first the state goes, then the promise, then `ANN.CommandCompleted` for a command that shows
-/// or dismisses.
+/// The navigation state now, sent when it changed, once per answer: the end of the command's transition asks for it
+/// after the `DidAppear` it sends and before the transition's own events (`ANNAppearanceDispatcher`); otherwise
+/// `resolve:` asks for it before the promise. A later call sends nothing, and nothing goes for a JavaScript that went.
+/// A failure of the step is logged and costs only the state.
+- (void)reportStateNow;
+
+/// Resolves the promise: first the state, when the command changes what shows (`ANNCommandContract`) and its
+/// transition didn't send it already (`reportStateNow`), then the promise, then `ANN.CommandCompleted` for a command
+/// that shows or dismisses.
 - (void)resolve:(nullable id)value;
 
 /// Rejects the promise with the text alone: no code of the navigation.

package/ios/Contract/ANNCommandAnswer.mm

@@ -10,6 +10,7 @@
 @implementation ANNCommandAnswer {
     RCTPromiseResolveBlock _resolve;
     RCTPromiseRejectBlock _reject;
+    BOOL _stateReported;
 }
 
 - (instancetype)initWithCommandName:(NSString *)commandName
@@ -51,6 +52,27 @@
     return YES;
 }
 
+- (void)reportStateNow {
+    ANNAssertMainQueue();
+    if (_stateReported) {
+        return;
+    }
+    _stateReported = YES;
+    // A step made for the JavaScript that went sends nothing, as its answer does.
+    if (!self.isCurrent) {
+        return;
+    }
+    // The command did its work: a failure of the state step costs only the state, never the events and the answer.
+    @try {
+        [ANNNavigationState updateNowFor:_commandName];
+    } @catch (NSException *exception) {
+        NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
+        [ANNErrorHandler logFailureOf:_commandName
+                                 text:[ANNErrorTexts couldNot:@"report the navigation state"
+                                                        reason:reason]];
+    }
+}
+
 - (void)resolve:(id)value {
     if (![self takeAnswer]) {
         return;
@@ -59,18 +81,9 @@
     _resolve = nil;
     _reject = nil;
     // A command that may change what shows (`ANNCommandContract`): the state goes before the promise, so that
-    // `getState()` after `await` has the result.
-    BOOL changesWhatShows = ANNCommandReportsState(_commandName);
-    if (changesWhatShows) {
-        // The command did its work: a failure of the state step costs only the state, never the answer.
-        @try {
-            [ANNNavigationState reportBeforeAnswerOf:_commandName];
-        } @catch (NSException *exception) {
-            NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
-            [ANNErrorHandler logFailureOf:_commandName
-                                     text:[ANNErrorTexts couldNot:@"report the navigation state"
-                                                            reason:reason]];
-        }
+    // `getState()` after `await` has the result. Sent at the end of its transition already, it goes no more.
+    if (ANNCommandReportsState(_commandName)) {
+        [self reportStateNow];
     }
     [ANNErrorHandler resolve:resolve of:_commandName value:value];
     if (_commandId && ANNCommandSendsCompleted(_commandName)) {

package/ios/Core/ANNAppearanceDispatcher.h

@@ -58,11 +58,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// A transition ended, in this order: first a screen a transition began inside a node of `shown` that left the window
 /// and isn't one of that node's shown screens gets its `DidDisappear`; then `DidDisappear` of every screen of `hidden`,
-/// `DidAppear` of what `shown` shows, the navigation state now when it changed, `events` (the transition's own events,
+/// `DidAppear` of what `shown` shows, the navigation state now when it changed (the answer's one state step,
+/// `-[ANNCommandAnswer reportStateNow]`; nothing for a JavaScript that went), `events` (the transition's own events,
 /// `ANN.ScreenPopped` and `ANN.ModalDismissed`, and what must follow them, like stopping the content that went), then
-/// `answer` resolves with `value` (its own state step finds nothing new, then the promise, then
-/// `ANN.CommandCompleted`). A user's action passes no answer. The callbacks of UIKit that come later find the phases
-/// set and send nothing.
+/// `answer` resolves with `value` (the promise, then `ANN.CommandCompleted`; no second state). A user's action passes
+/// no answer, and its state goes all the same. The callbacks of UIKit that come later find the phases set and send
+/// nothing.
 + (void)endTransitionHiding:(NSArray<UIViewController *> *)hidden
                     showing:(NSArray<UIViewController *> *)shown
                      events:(nullable dispatch_block_t)events

package/ios/Core/ANNAppearanceDispatcher.mm

@@ -305,7 +305,18 @@ static BOOL ANNIsInsideNode(UIViewController *screen, UIViewController *node) {
     for (UIViewController *node in shown) {
         [self nodeDidAppear:node];
     }
-    [ANNNavigationState updateNowFor:answer.commandName];
+    // The state before the transition's events, once per answer: the answer's own step before its promise finds it
+    // sent. A user's transition has no answer; one whose answer went before its end (an interrupt) sends the state of
+    // its end itself, as Android does.
+    if (!answer) {
+        [ANNNavigationState updateNow];
+    } else if (answer.answered) {
+        if (answer.isCurrent) {
+            [ANNNavigationState updateNowFor:answer.commandName];
+        }
+    } else {
+        [answer reportStateNow];
+    }
     if (events) {
         events();
     }

package/ios/Core/ANNNavigationState.h

@@ -23,17 +23,15 @@ NS_ASSUME_NONNULL_BEGIN
 + (void)holdUpdates;
 + (void)releaseUpdates;
 
-/// The state now, sent when it changed: at the end of a transition, at once after a tab chosen from code. A walk that
-/// throws logs one line, `[ApexNavigation] <commandName>: could not report the navigation state: <reason>` (as on
-/// Android; `transition` without a command), and sends nothing, so its caller always goes on.
+/// The state now, sent when it changed. A command's answer asks for it once (`-[ANNCommandAnswer reportStateNow]`, at
+/// the end of its transition or before its promise); the end of a user's transition and a tab chosen from code ask
+/// `updateNow`. A walk that throws logs one line, `[ApexNavigation] <commandName>: could not report the navigation
+/// state: <reason>` (as on Android; `transition` without a command), and sends nothing, so its caller always goes on.
 + (void)updateNowFor:(nullable NSString *)commandName;
 
 /// `updateNowFor:` without a command.
 + (void)updateNow;
 
-/// The command `commandName` is about to answer: when what shows changed, the new state goes now, before the promise.
-+ (void)reportBeforeAnswerOf:(NSString *)commandName;
-
 /// Forgets the last state sent: the next one goes even if it is the same (a new bundle, `AppLaunched`).
 + (void)reset;
 

package/ios/Core/ANNNavigationState.mm

@@ -94,10 +94,6 @@ static BOOL ANNSameValue(id a, id b) {
     [ApexNavigation.eventEmitter sendNavigationStateChanged:screenId name:name tab:tab];
 }
 
-+ (void)reportBeforeAnswerOf:(NSString *)commandName {
-    [self updateNowFor:commandName];
-}
-
 + (void)reset {
     ANNAssertMainQueue();
     ANNHasLastState = NO;

package/ios/Layouts/Root/ANNSplashViewController.h

@@ -7,9 +7,11 @@ NS_ASSUME_NONNULL_BEGIN
 /// either at once. The status bar follows the Info.plist keys `UIStatusBarStyle` and `UIStatusBarHidden`. Main queue.
 @interface ANNSplashViewController : UIViewController
 
-/// The copy of the launch screen: the initial view controller of `UILaunchStoryboardName` as a child (a storyboard
-/// that doesn't load: the first view of the nib of that name), else the legacy launch images, full screen. Nil when the
-/// app has none of these: the window then has no root view controller until the first root.
+/// The copy of the launch screen. When iOS builds it from the Info.plist (`UILaunchScreen`, or the default of
+/// `UILaunchScreens`), the same color, image and bars as plain views; else the initial view controller of
+/// `UILaunchStoryboardName` as a child (a storyboard that doesn't load: the first view of the nib of that name), else
+/// the legacy launch images, full screen. Nil when the app has none of these: the window then has no root view
+/// controller until the first root.
 + (nullable instancetype)launchScreenCopyWithBounds:(CGRect)bounds;
 
 /// The blank screen after a reload: clear when the default options give the window a color (`window.backgroundColor`),