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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.0.0-alpha.5](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.4...v1.0.0-alpha.5) (2026-10-23)
+
+
+### Features
+
+* android back options, a launch screen copy from UILaunchScreen, modal and back fixes ([#43](https://github.com/apexnative/navigation/issues/43)) ([29f311e](https://github.com/apexnative/navigation/commit/29f311e318134f284a0c6279e6c86e15612c9343))
+
+
+### Bug Fixes
+
+* **android:** send the state of a tab switch from code at its start ([#44](https://github.com/apexnative/navigation/issues/44)) ([34d03d0](https://github.com/apexnative/navigation/commit/34d03d0214cf09e14329d0bae51e47d46063f054))
+* **hooks:** measure agent folder scopes from the worktree a file is in ([#42](https://github.com/apexnative/navigation/issues/42)) ([d306137](https://github.com/apexnative/navigation/commit/d306137534d3ba551fab8a7346c7ad7300c0faf7))
+
 ## [1.0.0-alpha.4](https://github.com/apexnative/navigation/compare/v1.0.0-alpha.3...v1.0.0-alpha.4) (2026-10-23)
 
 

package/android/CLAUDE.md

@@ -25,7 +25,7 @@ top-level folder. Main thread only, unless a line says otherwise.
   `ReactView` (a React root), the stores (`ScreenInsets`, `ScreenRegions`, `ArrangementStates`, `Hinge`, `StartInfo`),
   `LaunchLink`, `ScrollEvents`.
 - `react/events/`: `AppearanceDispatcher`, `ScreenAppearance`, `EventEmitter`, `EventContract` (made by
-  `scripts/contract.mjs`), `NavigationStateReporter`, `ComponentType`.
+  `scripts/contract.mjs`), `NavigationState`, `ComponentType`.
 - `viewcontrollers/viewcontroller/`: `ViewController` (the base of every node), `Presenter`, `IReactView` (what a
   screen shows), `ScrollEventListener`.
 - `viewcontrollers/child/`, `parent/`: `ChildController` and the registry; `ParentController` (the base of layouts),
@@ -105,7 +105,7 @@ top-level folder. Main thread only, unless a line says otherwise.
 - System bars: `system/SystemUiOwner.kt`, `SystemUiLayers.kt`, `SystemUiRules.kt`, `SystemUiWindow.kt`,
   `AppDirection.kt`; `viewcontrollers/parent/ContainerBackground.kt`.
 - Events and state: `react/events/AppearanceDispatcher.kt`, `ScreenAppearance.kt`, `EventEmitter.kt`,
-  `NavigationStateReporter.kt`; `react/CommandAnswer.kt`.
+  `NavigationState.kt`; `react/CommandAnswer.kt`.
 - Options (parsing, merging): `options/Options.kt`, `OptionsReader.kt`, `OptionsCache.kt`, `DefaultOptions.kt`,
   `params/`, `parsers/`; `viewcontrollers/viewcontroller/ViewController.kt` (resolution).
 - Error texts and answers: `react/ErrorTexts.kt` and `react/CommandContract.kt`, made by `scripts/contract.mjs` from
@@ -172,6 +172,9 @@ top-level folder. Main thread only, unless a line says otherwise.
   `cancel` it on every exit.
 - A layer that waits to show must be a `WaitingLayer` and leave on every exit (show, supersede, destroy, root gone).
 - Never resolve a promise yourself: only `CommandAnswer` knows whether its JavaScript went and sends the state first.
+- An event of a screen goes to the JavaScript the screen was made for: `EventEmitter.of(node.jsGeneration)`, or an
+  emitter kept from then (it goes silent after a reload). React Native keeps one context across a reload, so a sender
+  taken from the context at event time tells the new JavaScript about a screen it never had.
 - A signal that comes inside a layout pass or a view's attach must not move views there; the stack posts readiness
   (`deliver`).
 - A step that runs later (a timer, a readiness signal, an animator's end, a user callback) runs under no runner: it
@@ -206,6 +209,10 @@ top-level folder. Main thread only, unless a line says otherwise.
 - The back gesture's preview shows the screen under the top outside any operation of the queue: it may only reveal
   it and put it back, and its release goes through `StackQueue.cut(gesture = true)`. A command that comes meanwhile
   stops it through `StackDisplay.stop`, like any transition it takes over.
+- What back does (`Navigator.canHandleBack`, `keepsBackFromSystem`) is computed on events, not before each frame: a
+  new path that changes it without a command (a gesture, an animator's end, a layout's switch) calls
+  `BackCallbackState.update`, or the system's back leaves the app where it should go back. Debug builds log a missed
+  one (`BackCallbackCheck`).
 - Without edge to edge the window resizes for the keyboard by the manifest's soft input mode, so
   `layout.adjustResize: false` goes through the system UI owner's keyboard group (`SystemUiWindow.setKeyboardCovers`),
   not through the screen's padding.

package/android/CORE.md

@@ -31,7 +31,7 @@ coordinators: RootCoordinator · StackQueue (one per stack) · ModalCoordinator
 presenters: ComponentPresenter · StackPresenter + TopBarPresenter · BottomTabsPresenter · SideMenuPresenter ·
             SplitViewPresenter · system/SystemUiOwner (status bar, navigation bar, orientation, keyboard)
  ▼
-react/events/AppearanceDispatcher ─► NavigationStateReporter ─► EventEmitter ─► ANN.* events ─► JS
+react/events/AppearanceDispatcher ─► NavigationState ─► EventEmitter ─► ANN.* events ─► JS
 ```
 
 - **Way in.** `NavigationTurboModule` only turns a method into a `CommandRunner` call; it holds no navigation logic. It
@@ -84,11 +84,12 @@ react/events/AppearanceDispatcher ─► NavigationStateReporter ─► EventEmi
    `AppearanceDispatcher.beginTransition`: **`ComponentWillAppear`** of Profile. The transition runs
    (`StackTransitions`, `SystemTransition`, or the screens' own animation, `AnimationRules.stackIsOwn`).
 8. **End.** `finishPush` calls `AppearanceDispatcher.endTransition`: **`ComponentDidDisappear`** of Home, then
-   **`ComponentDidAppear`** of Profile, then `reportState` (**`NavigationStateChanged`**, only if it changed), then the
-   transition's own events (none for a push), then `CommandAnswer.resolve` with Profile's id.
-9. **Answer.** `resolve` sends the state once more if it changed (`AnswerEvents.beforeAnswer`), resolves the promise,
-   then sends **`CommandCompleted`** (`CommandContract.COMPLETED`). After the task, `BackCallbackState.update` recomputes what
-   back does.
+   **`ComponentDidAppear`** of Profile, then the answer's one state step (`CommandAnswer.reportStateNow`:
+   **`NavigationStateChanged`**, only if it changed), then the transition's own events (none for a push), then
+   `CommandAnswer.resolve` with Profile's id.
+9. **Answer.** `resolve` sends the state only when no transition sent it (`reportStateNow` runs once per answer: a
+   `setRoot` with layout modals sends it here), resolves the promise, then sends **`CommandCompleted`**
+   (`CommandContract.COMPLETED`). After the task, `BackCallbackState.update` recomputes what back does.
 
 The events go from the main thread, synchronously, through `EventEmitter.current()`; the promise is answered once.
 
@@ -127,13 +128,16 @@ Each rule has one owner. Change the owner, not a caller; if a new feature needs
   `beginTransition` starts the appearances; `endTransition` runs what left, then what came, then the state, then the
   transition's events, then the answer. Events asked before a screen's content is ready are held in its
   `ScreenAppearance` (until the content mounts or `HOLD_LIMIT_MILLIS`).
-- **Navigation state.** `AppearanceDispatcher.state` (`StateUpdates`) is the one way to ask for it: `StateHold`
-  coalesces the asks to one posted update per pass of the main loop and keeps it while held; the update calls
-  `NavigationStateReporter.updateNow`. `updateNow` also runs before every answer of a command that changes what shows
-  (`CommandAnswer`) and is never held. It reads the navigator through `Navigators.current()`, and `stateOf` finds the
+- **Navigation state.** `NavigationState` owns it: the last state sent, the walk (`stateOf`), the posted update and its
+  holds (`NavigationState.Updates`). `AppearanceDispatcher.state` (`StateUpdates`) is the one way to ask for it:
+  `setNeedsUpdate` coalesces the asks to one posted update per pass of the main loop and keeps it while held; the
+  update calls `updateNow`. A command's answer sends it once, at once and never held (`CommandAnswer.reportStateNow`):
+  at the end of its transition, else right before its promise for the commands that change what shows; nothing for a
+  JavaScript that went. It reads the navigator through `Navigators.current()`, and `stateOf` finds the
   `tab` as the nearest tabs of the visible screen (the last tabs met walking down from the visible layout). A `setRoot`
   with layout modals or overlays takes `AppearanceDispatcher.StateUpdates.hold()` and releases it right before its
-  answer, so JavaScript hears one state; every hold has one `release()`.
+  answer, so JavaScript hears one state; every hold has one `release()`. The holds go when the JavaScript goes
+  (`NavigationState.javaScriptWent`), so one left by its `setRoot` never holds the next JavaScript's updates.
 - **Answer.** `CommandAnswer`: resolves or rejects once, and nothing once the JavaScript went. The id a stack entry
   answers with is one rule, `StackController.answerIdOf` (the queue asks it through `StackQueue.Host.answerIdOf` with
   an `AnswerKind`): `push` answers the entry's own id (a pair's), every other command the screen it stands for (a
@@ -141,7 +145,11 @@ Each rule has one owner. Change the owner, not a caller; if a new feature needs
 - **Stack queue.** `StackQueue`: every command, back and return of a container goes through it; it keeps `entries`
   (what JavaScript sees) and `shown` (what the container shows) and answers once.
 - **Screen readiness.** `ScreenReadiness` (by id; written by `SafeAreaView`) and `ContentReadiness` (the `Readiness`
-  the waits ask, through `IReactView.isReady`).
+  the waits ask, through `IReactView.isReady`). As on iOS, the signals are kept (a listener that comes later hears them
+  at once), an id has a listener per key (several roots of one bar component), and each signal carries the React
+  surface it came from: a `ReactView` takes only its own surface's, so an old root with the same id never makes a new
+  one ready. An id renders at once while a root marks it (`ReactView`'s `rendersAtOnce`); the last one takes the id's
+  signals with it. A screen's id is cleared as the screen is made and destroyed, everything on reload.
 - **Render wait.** `RenderWait`: the one wait for screens to render, used by `RootCoordinator`, `ModalCoordinator`,
   `OverlayCoordinator` and `StackQueue`; `RenderWait.waitedScreens` walks `ParentController.waitedChildren()` at every
   level. What differs between users are values (limit, bar phase, unknown-content rule), never steps.
@@ -171,7 +179,8 @@ Each rule has one owner. Change the owner, not a caller; if a new feature needs
 - **Back.** `NavigationActivity.passBack` → `ReactGateway.onBackPressed` (JavaScript's `BackHandler`) →
   `invokeDefaultOnBackPressed` → `Navigator.handleBack` → `ModalCoordinator.handleBack` → the root's
   `ParentController.handleBack` → `StackController.handleBack` → `StackQueue.cut`. `BackCallbackState` keeps the
-  system callback enabled only while back has something to do.
+  system callback enabled only while back has something to do, computed again on the events that change it (its KDoc
+  lists them), never before each frame; debug builds check it (`BackCallbackCheck`).
 - **Error texts.** `ErrorTexts`: one function per text, the same words as iOS, made with iOS's from
   `src/interfaces/contract/errors.json` (`scripts/contract.mjs`). JavaScript adds `[navigation] <command>:`.
 - **Event names and keys.** `EventContract`, made from the event types of `src/interfaces/`; `EventEmitter` and the
@@ -201,7 +210,7 @@ Modules are the feature classes that plug into the core through its contract (th
   (`splash/`), animations (`FadeThrough`, `SystemTransition`, `TransitionTargets`, three element animators), utils
   (`MaterialTheme`, `NavigationLog`, `awaitBarComponents`, `whenDrawn`).
 - **Stores and singletons:** regions (`Hinge`, `ScreenInsets`, `ScreenRegions`, `WindowFolds`), pair state
-  (`ArrangementStates`), links (`LaunchLink`, `StartInfo`), events (`NavigationStateReporter`), commands
+  (`ArrangementStates`), links (`LaunchLink`, `StartInfo`), events (`NavigationState`), commands
   (`BackCallbackState`), stack (`PreparedFrame`).
 
 How they plug in:
@@ -226,4 +235,5 @@ How they plug in:
 - **Core code in a module's folder:** `viewcontrollers/splitview/SplitViewPresenter.kt`, `slots/SlotScreenView.kt`,
   and in `views/animations/` and `views/element/` everything except the files named above.
 - **Stores** are written on the main thread by the core and read from any thread; they are cleared with their nodes and on
-  reload.
+  reload. Their events, and the search's, go through the emitter of the JavaScript the screen was made for
+  (`EventEmitter.of(node.jsGeneration)`); the hinge keeps the `EventEmitter.current()` of the call that turned it on.

package/android/src/main/java/dev/apexnative/navigation/NavigationActivity.kt

@@ -35,6 +35,7 @@ import dev.apexnative.navigation.splash.SplashTheme
 import dev.apexnative.navigation.splash.SplashView
 import dev.apexnative.navigation.system.SystemUiWindow
 import dev.apexnative.navigation.utils.MaterialTheme
+import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackCheck
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
@@ -75,6 +76,7 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
     private val backCallback = object : OnBackPressedCallback(false) {
         override fun handleOnBackStarted(backEvent: BackEventCompat) {
             backGesture = null
+            navigator?.let { backCheck?.atBack(it) }
             if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE || BackCallbackState.hasJsListeners) return
             val stack = navigator?.stackPoppedByBack() ?: return
             backGesture = stack.startBackGesture(backEvent.swipeEdge == BackEventCompat.EDGE_LEFT, backEvent.touchY)
@@ -87,9 +89,11 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
         override fun handleOnBackCancelled() {
             backGesture?.cancel()
             backGesture = null
+            navigator?.let(BackCallbackState::update)
         }
 
         override fun handleOnBackPressed() {
+            navigator?.let { backCheck?.atBack(it) }
             val gesture = backGesture
             backGesture = null
             if (gesture?.commit() == true) BackCallbackState.update() else passBack()
@@ -99,10 +103,12 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
     // The back gesture that previews a pop now; none.
     private var backGesture: StackController.BackGesture? = null
 
-    // Before each frame of the window: what back does may have changed, and the system decides at the start of a
-    // gesture whether the app takes it.
-    private val backBeforeFrame = ViewTreeObserver.OnPreDrawListener {
-        navigator?.let(BackCallbackState::update)
+    // Debug builds only: the check that what back does never changes without its trigger (BackCallbackState), sampled
+    // before frames and at back events. It only logs; release builds have neither the check nor the listener.
+    private val backCheck = if (BuildConfig.DEBUG) BackCallbackCheck() else null
+    private val backCheckBeforeFrame = ViewTreeObserver.OnPreDrawListener {
+        val navigator = navigator
+        if (navigator != null) backCheck?.sample(navigator, SystemClock.uptimeMillis())
         true
     }
     private var frameObserver: ViewTreeObserver? = null
@@ -143,7 +149,9 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
         SlotHost.attachIfStarted(this)
         reactGateway.onActivityCreated(this)
         onBackPressedDispatcher.addCallback(this, backCallback)
-        frameObserver = window.decorView.viewTreeObserver.also { it.addOnPreDrawListener(backBeforeFrame) }
+        if (backCheck != null) {
+            frameObserver = window.decorView.viewTreeObserver.also { it.addOnPreDrawListener(backCheckBeforeFrame) }
+        }
         // The activity's system UI: its owner remembers the theme's colors and the manifest's orientation now, before
         // anything changes them.
         navigator.systemUi.start(SystemUiWindow.of(this))
@@ -218,6 +226,8 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
         isNavigationResumed = true
         // The root, the modals and the overlays lay out again; nothing is sent.
         navigator?.onResume()
+        // A safety net: what back does changes on its own triggers, and the system asks the callback from here on.
+        navigator?.let(BackCallbackState::update)
         if (developerSupport() != null) reloadBroadcast.register()
         ReloadCoordinator.launchIfDue(this)
     }
@@ -239,6 +249,8 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
     override fun onWindowFocusChanged(hasFocus: Boolean) {
         super.onWindowFocusChanged(hasFocus)
         if (reactGateway.currentReactContext != null) reactGateway.host.onWindowFocusChange(hasFocus)
+        // A safety net, as at onResume: back after a dialog or another window over the activity.
+        if (hasFocus) navigator?.let(BackCallbackState::update)
     }
 
     override fun onUserLeaveHint() {
@@ -302,9 +314,11 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
         splashHold = null
         reloadBroadcast.release()
         navigator?.let(BackCallbackState::detach)
-        // The window's observer now, and the one the listener was added to, if they differ.
-        val observers = listOfNotNull(frameObserver, window?.peekDecorView()?.viewTreeObserver).distinct()
-        observers.forEach { if (it.isAlive) it.removeOnPreDrawListener(backBeforeFrame) }
+        // The debug check's listener: from the window's observer now, and the one it was added to, if they differ.
+        if (backCheck != null) {
+            val observers = listOfNotNull(frameObserver, window?.peekDecorView()?.viewTreeObserver).distinct()
+            observers.forEach { if (it.isAlive) it.removeOnPreDrawListener(backCheckBeforeFrame) }
+        }
         frameObserver = null
         SlotHost.detach(this)
         navigator?.destroyWithActivity()
@@ -317,7 +331,9 @@ open class NavigationActivity : AppCompatActivity(), DefaultHardwareBackBtnHandl
     /**
      * Back that JavaScript's listeners didn't take: the navigation does its step first — a stack's top leaves or holds,
      * a pane closes —; with nothing to do there, the activity's own back, as without the navigation. An app may
-     * override it (e.g. `moveTaskToBack(true)`).
+     * override it (e.g. `moveTaskToBack(true)`). The callback is off for that back only: the dispatcher's own back is
+     * the activity's, not [onBackPressed]; then it is computed again, and `hardwareBackButton.systemAnimation: false`
+     * turns it on again.
      */
     override fun invokeDefaultOnBackPressed() {
         val handled = navigator?.handleBack(CommandListenerAdapter()) == true

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

@@ -8,7 +8,7 @@ import com.facebook.react.bridge.ReadableMap
  */
 class AnimationsOptions {
     @JvmField var push = StackPushAnimationOptions()
-    @JvmField var pop = StackAnimationOptions()
+    @JvmField var pop = StackPopAnimationOptions()
     @JvmField var setStackRoot = SetStackRootAnimationOptions()
     @JvmField var setRoot = EnterExitAnimationOptions()
     @JvmField var showModal = ModalAnimationOptions()
@@ -43,7 +43,7 @@ class AnimationsOptions {
             val options = AnimationsOptions()
             if (map == null) return options
             options.push = map.group("push") { StackPushAnimationOptions.parse(it) }
-            options.pop = map.group("pop") { StackAnimationOptions.parse(it) }
+            options.pop = map.group("pop") { StackPopAnimationOptions.parse(it) }
             options.setStackRoot = map.group("setStackRoot") { SetStackRootAnimationOptions.parse(it) }
             options.setRoot = map.group("setRoot") { EnterExitAnimationOptions.parse(it) }
             options.showModal = map.group("showModal") { ModalAnimationOptions.parse(it) }

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

@@ -15,20 +15,27 @@ class HardwareBackButtonOptions {
     @JvmField var popStackOnPress: Bool = NullBool()
     /** Internal. */
     @JvmField var dismissModalOnPress: Bool = NullBool()
+    /**
+     * `systemAnimation`: `false` keeps back in the app on the first screen too, so the system doesn't play its
+     * animation of going home; the press then does the activity's own back.
+     */
+    @JvmField var systemAnimation: Bool = NullBool()
 
     fun hasValue(): Boolean = bottomTabsOnPress.hasValue() || popStackOnPress.hasValue() ||
-        dismissModalOnPress.hasValue()
+        dismissModalOnPress.hasValue() || systemAnimation.hasValue()
 
     fun mergeWith(other: HardwareBackButtonOptions) {
         if (other.bottomTabsOnPress.hasValue()) bottomTabsOnPress = other.bottomTabsOnPress
         if (other.popStackOnPress.hasValue()) popStackOnPress = other.popStackOnPress
         if (other.dismissModalOnPress.hasValue()) dismissModalOnPress = other.dismissModalOnPress
+        if (other.systemAnimation.hasValue()) systemAnimation = other.systemAnimation
     }
 
     fun mergeWithDefault(defaults: HardwareBackButtonOptions) {
         if (!bottomTabsOnPress.hasValue()) bottomTabsOnPress = defaults.bottomTabsOnPress
         if (!popStackOnPress.hasValue()) popStackOnPress = defaults.popStackOnPress
         if (!dismissModalOnPress.hasValue()) dismissModalOnPress = defaults.dismissModalOnPress
+        if (!systemAnimation.hasValue()) systemAnimation = defaults.systemAnimation
     }
 
     fun copy() = HardwareBackButtonOptions().also { it.mergeWith(this) }
@@ -43,6 +50,7 @@ class HardwareBackButtonOptions {
             options.bottomTabsOnPress = TextParser.parse(map, "bottomTabsOnPress", BOTTOM_TABS_ON_PRESS)
             options.popStackOnPress = BoolParser.parse(map, "popStackOnPress")
             options.dismissModalOnPress = BoolParser.parse(map, "dismissModalOnPress")
+            options.systemAnimation = BoolParser.parse(map, "systemAnimation")
             return options
         }
     }

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

@@ -99,8 +99,8 @@ class BottomTabsEnterExitAnimationOptions {
 }
 
 /**
- * `StackAnimationOptions`: the animation of `pop`, and the base of `push` and `setStackRoot`; over the shared elements
- * and element transitions of [LayoutAnimation].
+ * `StackAnimationOptions`: the base of the animations of `push`, `pop` and `setStackRoot`; over the shared elements and
+ * element transitions of [LayoutAnimation].
  */
 open class StackAnimationOptions : LayoutAnimation() {
     @JvmField var enabled: Bool = NullBool()
@@ -188,6 +188,44 @@ class StackPushAnimationOptions : StackAnimationOptions() {
     }
 }
 
+/**
+ * `StackPopAnimationOptions`: the animation of `pop`, and `preview`: whether a back gesture over the stack previews the
+ * pop of its top (Android 14+); `false` pops it when the gesture is released, as on Android 13.
+ */
+class StackPopAnimationOptions : StackAnimationOptions() {
+    @JvmField var preview: Bool = NullBool()
+
+    override fun hasValue(): Boolean = super.hasValue() || preview.hasValue()
+
+    fun mergeWith(other: StackPopAnimationOptions) {
+        super.mergeWith(other)
+        if (other.preview.hasValue()) preview = other.preview
+    }
+
+    fun mergeWithDefault(defaults: StackPopAnimationOptions) {
+        super.mergeWithDefault(defaults)
+        if (!preview.hasValue()) preview = defaults.preview
+    }
+
+    override fun copy(): StackPopAnimationOptions = StackPopAnimationOptions().also { it.mergeWith(this) }
+
+    // Reads the fields of this class from [map], after those of its parent.
+    private fun readStackPopAnimationOptions(map: ReadableMap) {
+        readStackAnimationOptions(map)
+        preview = BoolParser.parse(map, "preview")
+    }
+
+    companion object {
+        @JvmStatic
+        fun parse(map: ReadableMap?): StackPopAnimationOptions {
+            val options = StackPopAnimationOptions()
+            if (map == null) return options
+            options.readStackPopAnimationOptions(map)
+            return options
+        }
+    }
+}
+
 /** `SetStackRootAnimationOptions`: the animation of `setStackRoot`. */
 class SetStackRootAnimationOptions : StackAnimationOptions() {
     @JvmField var asPush: Bool = NullBool()

package/android/src/main/java/dev/apexnative/navigation/react/ArrangementStates.kt

@@ -1,7 +1,5 @@
 package dev.apexnative.navigation.react
 
-import android.content.Context
-import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import dev.apexnative.navigation.react.events.EventContract
@@ -19,11 +17,13 @@ internal object ArrangementStates {
 
     private val states = ConcurrentHashMap<String, State>()
 
-    /** Keeps the screen's state, and tells JavaScript when it changed and [notify] holds. Main thread only. */
-    fun set(context: Context, screenId: String, state: State, notify: Boolean) {
+    /**
+     * Keeps the screen's state, and tells JavaScript when it changed and [notify] holds, through [emitter], the one of
+     * the JavaScript the screen was made for: silent once it went. Main thread only.
+     */
+    fun set(screenId: String, state: State, notify: Boolean, emitter: EventEmitter) {
         if (states.put(screenId, state) == state || !notify) return
-        val reactContext = (context.applicationContext as? ReactApplication)?.reactHost?.currentReactContext ?: return
-        EventEmitter(reactContext).emitArrangementChanged(screenId, toMap(state))
+        emitter.emitArrangementChanged(screenId, toMap(state))
     }
 
     /** `{ placement, layout, front, hidden }`, empty for a screen outside a pair. Any thread. */

package/android/src/main/java/dev/apexnative/navigation/react/CommandAnswer.kt

@@ -3,13 +3,14 @@ package dev.apexnative.navigation.react
 import android.util.Log
 import com.facebook.react.bridge.Promise
 import dev.apexnative.navigation.react.events.EventEmitter
-import dev.apexnative.navigation.react.events.NavigationStateReporter
+import dev.apexnative.navigation.react.events.NavigationState
 import dev.apexnative.navigation.utils.NavigationLog
 
 /**
  * The one answer of a command with a promise: [resolve] or [reject], once; after that, and once the JavaScript it came
- * from went ([generation]), nothing. [CommandRunner] makes it on the main thread for each command; area code that takes
- * a [CommandListener] answers through [asListener]. Main thread only.
+ * from went ([generation]), nothing. It owns the command's one state step ([reportStateNow]). [CommandRunner] makes it
+ * on the main thread for each command; area code that takes a [CommandListener] answers through [asListener]. Main
+ * thread only.
  */
 internal class CommandAnswer(
     /** The method of the command: `push`, `setRoot`, … */
@@ -27,19 +28,36 @@ internal class CommandAnswer(
     var isAnswered = false
         private set
 
+    // The state step of this answer ran ([reportStateNow]).
+    private var stateReported = false
+
     /** Whether an answer now would reach the JavaScript the command came from. */
     val canAnswer: Boolean
         get() = !isAnswered && ReloadCoordinator.isCurrent(generation)
 
     /**
-     * Resolves the promise with [value]. For the commands that change what shows, the navigation state goes first,
-     * when it changed, so JavaScript has it when its `await` goes on; `ANN.CommandCompleted` follows the promise, for
-     * the commands that show or dismiss. A failure of either is logged; the promise goes all the same.
+     * 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 (`AppearanceDispatcher.endTransition`);
+     * 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.
+     */
+    fun reportStateNow() {
+        if (stateReported) return
+        stateReported = true
+        if (!ReloadCoordinator.isCurrent(generation)) return
+        guarded("report the navigation state") { events.stateNow() }
+    }
+
+    /**
+     * Resolves the promise with [value]. For the commands that change what shows (`CommandContract.STATE`), the
+     * navigation state goes first, when it changed and the command's transition didn't send it already
+     * ([reportStateNow]), so JavaScript has it when its `await` goes on; `ANN.CommandCompleted` follows the promise,
+     * for the commands that show or dismiss. A failure of either is logged; the promise goes all the same.
      */
     fun resolve(value: Any?) {
         if (!canAnswer) return
         isAnswered = true
-        if (commandName in CommandContract.STATE) guarded("report the navigation state") { events.beforeAnswer() }
+        if (commandName in CommandContract.STATE) reportStateNow()
         promise.resolve(value)
         val commandId = commandId
         if (commandName in CommandContract.COMPLETED && commandId != null) {
@@ -69,18 +87,15 @@ internal class CommandAnswer(
 
 /** What goes to JavaScript around the answer of a command. Main thread only. */
 internal interface AnswerEvents {
-    /** Right before the promise resolves: the navigation state, when it changed. */
-    fun beforeAnswer()
+    /** The answer's one state step ([CommandAnswer.reportStateNow]): the navigation state now, when it changed. */
+    fun stateNow()
 
     /** After the promise resolved: `ANN.CommandCompleted`. */
     fun commandCompleted(commandName: String, commandId: String, completionTime: Long)
 
     /** Through the sender of the JavaScript that runs now. */
     object Current : AnswerEvents {
-        override fun beforeAnswer() {
-            val emitter = EventEmitter.current()
-            if (emitter.canSend) NavigationStateReporter.updateNow(emitter)
-        }
+        override fun stateNow() = NavigationState.updateNow()
 
         override fun commandCompleted(commandName: String, commandId: String, completionTime: Long) {
             EventEmitter.current().emitCommandCompleted(commandName, commandId, completionTime)

package/android/src/main/java/dev/apexnative/navigation/react/Hinge.kt

@@ -9,7 +9,6 @@ import android.os.Build
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
-import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import dev.apexnative.navigation.react.events.EventContract
@@ -22,7 +21,8 @@ import java.lang.ref.WeakReference
  * sensor (Android 11+), in degrees to a tenth as on iOS. Android has no public state of a closed device: closed is a
  * window without a fold, or an angle under 90° ([valueOf]). No sensor and no fold: no hinge, `{}`. It runs while
  * JavaScript has a hook mounted (`setHingeUpdates`), the sensor only while the activity is resumed too; the same value
- * is not sent twice. Main thread only, but [get].
+ * is not sent twice. The values go to the JavaScript that turned the updates on (`EventEmitter.current` then): after a
+ * reload, until the updates stop, they go nowhere. Main thread only, but [get].
  */
 internal object Hinge {
     /** A value of the hinge: its state, and its angle in degrees to a tenth; none while the state is unknown. */
@@ -33,6 +33,8 @@ internal object Hinge {
     private const val CLOSED_BELOW = 90f
 
     private var enabled = false
+    // The sender of the JavaScript that turned the updates on; none while they are off.
+    private var emitter: EventEmitter? = null
     private var activity: WeakReference<Activity>? = null
     private var folds: WindowFolds? = null
     private var sensorManager: SensorManager? = null
@@ -63,9 +65,11 @@ internal object Hinge {
     fun setEnabled(activity: Activity?, enabled: Boolean) {
         this.enabled = enabled
         if (!enabled) {
+            emitter = null
             detach()
             return
         }
+        emitter = EventEmitter.current()
         activity?.let(::attachTo)
         update()
     }
@@ -134,8 +138,7 @@ internal object Hinge {
         val value = valueOf(folds.folds.firstOrNull(), sensor != null, angle)
         if (value == last) return
         last = value
-        val reactContext = (activity?.get()?.application as? ReactApplication)?.reactHost?.currentReactContext ?: return
-        EventEmitter(reactContext).emitHingeChanged(toMap(value))
+        emitter?.emitHingeChanged(toMap(value))
     }
 
     /**