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

package/ios/Layouts/Screen/ANNScreenPlace.mm

@@ -0,0 +1,175 @@
+#import "ANNScreenPlace.h"
+#import "ANNAssert.h"
+#import "ANNBottomTabsController.h"
+#import <objc/runtime.h>
+
+static const void *ANNScreenPlaceKey = &ANNScreenPlaceKey;
+
+// The measuring navigation controller of each stack: its first item stands for the stack's top, the second for the
+// entry. Weak keys: it goes with its stack.
+static NSMapTable<UINavigationController *, UINavigationController *> *ANNPlaceProbes(void) {
+    static NSMapTable<UINavigationController *, UINavigationController *> *probes;
+    if (!probes) {
+        probes = [NSMapTable weakToStrongObjectsMapTable];
+    }
+    return probes;
+}
+
+static UINavigationController *ANNPlaceProbeOf(UINavigationController *stack) {
+    UINavigationController *probe = [ANNPlaceProbes() objectForKey:stack];
+    if (!probe) {
+        probe = [[UINavigationController alloc] initWithRootViewController:[UIViewController new]];
+        [probe pushViewController:[UIViewController new] animated:NO];
+        [ANNPlaceProbes() setObject:probe forKey:stack];
+    }
+    return probe;
+}
+
+// What UIKit sizes the bar by, from the entry's item. The search field is a field of its own with the same placement:
+// a search controller shows in one item only.
+static void ANNCopyBarItem(UINavigationItem *from, UINavigationItem *to) {
+    to.title = from.title;
+    to.prompt = from.prompt;
+    to.largeTitleDisplayMode = from.largeTitleDisplayMode;
+    to.standardAppearance = from.standardAppearance;
+    to.scrollEdgeAppearance = from.scrollEdgeAppearance;
+    to.compactAppearance = from.compactAppearance;
+    to.compactScrollEdgeAppearance = from.compactScrollEdgeAppearance;
+    to.hidesSearchBarWhenScrolling = from.hidesSearchBarWhenScrolling;
+    to.searchController =
+        from.searchController ? [[UISearchController alloc] initWithSearchResultsController:nil] : nil;
+    if (@available(iOS 16.0, *)) {
+        to.style = from.style;
+        to.preferredSearchBarPlacement = from.preferredSearchBarPlacement;
+    }
+    if (@available(iOS 26.0, *)) {
+        to.attributedSubtitle = from.attributedSubtitle;
+        to.largeAttributedSubtitle = from.largeAttributedSubtitle;
+    }
+}
+
+// Everything the measure reads: the same answer while none of it changed.
+static NSString *ANNPlaceSignature(UINavigationItem *item, UINavigationController *stack, BOOL showsTopBar,
+                                   BOOL showsToolbar) {
+    UIView *stackView = stack.view;
+    NSMutableString *signature = [NSMutableString
+        stringWithFormat:@"%@|%@|%ld|%p|%p|%p|%p|%p|%d|%d|%d|%d|%@|%@", item.title, item.prompt,
+                         (long)item.largeTitleDisplayMode, item.standardAppearance,
+                         item.scrollEdgeAppearance, item.compactAppearance,
+                         item.compactScrollEdgeAppearance, item.searchController,
+                         item.hidesSearchBarWhenScrolling, stack.navigationBar.prefersLargeTitles,
+                         showsTopBar, showsToolbar, NSStringFromCGSize(stackView.bounds.size),
+                         NSStringFromUIEdgeInsets(stackView.safeAreaInsets)];
+    [signature appendFormat:@"|%p|%ld", stack,
+                            (long)stack.topViewController.navigationItem.largeTitleDisplayMode];
+    if (@available(iOS 16.0, *)) {
+        [signature appendFormat:@"|%ld|%ld", (long)item.style, (long)item.preferredSearchBarPlacement];
+    }
+    if (@available(iOS 26.0, *)) {
+        [signature appendFormat:@"|%@|%@", item.attributedSubtitle, item.largeAttributedSubtitle];
+    }
+    return signature;
+}
+
+@implementation ANNScreenPlace {
+    NSString *_signature;
+}
+
+- (instancetype)initWithSafeArea:(UIEdgeInsets)safeArea
+                     showsTopBar:(BOOL)showsTopBar
+                     showsTabBar:(BOOL)showsTabBar
+                       signature:(NSString *)signature {
+    if (self = [super init]) {
+        _safeArea = safeArea;
+        _showsTopBar = showsTopBar;
+        _showsTabBar = showsTabBar;
+        _signature = [signature copy];
+    }
+    return self;
+}
+
++ (ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                         inStack:(UINavigationController *)stack
+                         options:(ANNNavigationOptions *)options {
+    ANNAssertMainQueue();
+    UIView *stackView = stack.viewIfLoaded;
+    UIWindow *window = stackView.window;
+    if (!window) {
+        return nil;
+    }
+    BOOL showsTopBar = [options.topBar.visible withDefault:YES];
+    BOOL showsToolbar = options.toolbar.shouldShow;
+    BOOL showsTabBar = !entry.hidesBottomBarWhenPushed &&
+                       [[ANNBottomTabsController tabsOf:entry] showsTabBarForScreen:entry];
+    NSString *signature =
+        ANNPlaceSignature(entry.navigationItem, stack, showsTopBar, showsToolbar);
+    ANNScreenPlace *kept = objc_getAssociatedObject(entry, ANNScreenPlaceKey);
+    if (kept && kept.showsTabBar == showsTabBar && [kept->_signature isEqualToString:signature]) {
+        return kept;
+    }
+    UIEdgeInsets safeArea = [self measureEntry:entry
+                                       inStack:stack
+                                   showsTopBar:showsTopBar
+                                  showsToolbar:showsToolbar];
+    // The measure stands in the stack's view, whose safe area has the tab bar shown now: an entry that hides it gets
+    // the window's bottom there.
+    if (!showsTabBar) {
+        CGFloat tabBar = stackView.safeAreaInsets.bottom - window.safeAreaInsets.bottom;
+        if (tabBar > 0) {
+            safeArea.bottom = MAX(safeArea.bottom - tabBar, 0);
+        }
+    }
+    ANNScreenPlace *place = [[ANNScreenPlace alloc] initWithSafeArea:safeArea
+                                                          showsTopBar:showsTopBar
+                                                          showsTabBar:showsTabBar
+                                                            signature:signature];
+    objc_setAssociatedObject(entry, ANNScreenPlaceKey, place, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    return place;
+}
+
+// The probe lays out at the stack's size in the stack's view, unseen and for this moment only, and leaves no search
+// field behind.
++ (UIEdgeInsets)measureEntry:(UIViewController *)entry
+                     inStack:(UINavigationController *)stack
+                 showsTopBar:(BOOL)showsTopBar
+                showsToolbar:(BOOL)showsToolbar {
+    UINavigationController *probe = ANNPlaceProbeOf(stack);
+    UIViewController *below = probe.viewControllers.firstObject;
+    UIViewController *top = probe.topViewController;
+    UINavigationBar *bar = probe.navigationBar;
+    UINavigationBar *stackBar = stack.navigationBar;
+    bar.prefersLargeTitles = stackBar.prefersLargeTitles;
+    bar.standardAppearance = stackBar.standardAppearance;
+    bar.scrollEdgeAppearance = stackBar.scrollEdgeAppearance;
+    bar.compactAppearance = stackBar.compactAppearance;
+    below.navigationItem.largeTitleDisplayMode =
+        stack.topViewController.navigationItem.largeTitleDisplayMode;
+    ANNCopyBarItem(entry.navigationItem, top.navigationItem);
+    top.toolbarItems =
+        showsToolbar ? @[ [[UIBarButtonItem alloc] initWithTitle:@" "
+                                                           style:UIBarButtonItemStylePlain
+                                                          target:nil
+                                                          action:nil] ]
+                     : nil;
+    __block UIEdgeInsets safeArea = UIEdgeInsetsZero;
+    UIView *stackView = stack.view;
+    UIView *probeView = probe.view;
+    [UIView performWithoutAnimation:^{
+      [probe setNavigationBarHidden:!showsTopBar animated:NO];
+      [probe setToolbarHidden:!showsToolbar animated:NO];
+      probeView.alpha = 0;
+      probeView.userInteractionEnabled = NO;
+      probeView.accessibilityElementsHidden = YES;
+      probeView.frame = stackView.bounds;
+      [stackView insertSubview:probeView atIndex:0];
+      [probeView layoutIfNeeded];
+      [top.view layoutIfNeeded];
+      safeArea = top.view.safeAreaInsets;
+      [probeView removeFromSuperview];
+    }];
+    top.navigationItem.searchController = nil;
+    top.toolbarItems = nil;
+    return safeArea;
+}
+
+@end

package/ios/Layouts/SplitView/ANNSplitViewCommands.h

@@ -15,8 +15,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// `showInColumn`: the push's checks of the layout (the options of the tree, what the core makes), then the screen is
 /// made and waits by the push's rules. Once it is ready, by the state then: the source in a split view not collapsed
 /// into its compact layout — the split view shows the screen in `column`, unless a later request of that column began
-/// meanwhile (the last one wins); else the source in a stack — a push over it; else a rejection. The answer is the
-/// shown screen's id; every rejection destroys the screen.
+/// meanwhile (the last one wins; the superseded one answers when the last one does, with its own screen's id whatever
+/// the last one's outcome, as on Android); else the source in a stack — a push over it; else a rejection. The answer
+/// is the shown screen's id; every rejection destroys the screen.
 + (void)showInColumn:(NSString *)column
               layout:(ANNLayoutNode *)layout
          componentId:(NSString *)componentId

package/ios/Layouts/SplitView/ANNSplitViewCommands.mm

@@ -15,14 +15,19 @@
 #import "ANNRenderWait.h"
 #import "ANNShownScreens.h"
 #import "ANNStackCommands.h"
+#import "ANNStackController.h"
 #import "ANNStackQueue.h"
 #import "ApexNavigation+Internal.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <React/RCTLog.h>
 
-// The limits of the bar components of a push: title and background 1 s, buttons 0.5 s.
+// The limits of the bar components of a push: title and background 1 s, buttons 0.5 s. With `waitForRender` unset they
+// count from the wait's start, as a stack's push; with `true`, from the content's end.
 static const ANNBarWaitLimits ANNColumnBarLimits = {1, 0.5};
 
+// How long the push's wait waits for the screen's first content when `waitForRender` is not set, as a stack's push.
+static const NSTimeInterval ANNColumnRenderLimit = 0.5;
+
 // The split view of `node`: the node itself or the nearest of its layout parents that has columns.
 static UIViewController *ANNSplitViewOf(UIViewController *node) {
     for (UIViewController *parent = node; parent; parent = parent.layoutParent) {
@@ -45,17 +50,26 @@ static BOOL ANNIsOnScreen(UIViewController *node) {
 
 @class ANNColumnRequest;
 
+// A request the newest of its column superseded: its answer and the id it resolves with, its own screen's (each
+// `showInColumn` answers its own screen, as on Android).
+@interface ANNSupersededRequest : NSObject
+@property(nonatomic, strong) ANNCommandAnswer *answer;
+@property(nonatomic, copy) NSString *value;
+@end
+
+@implementation ANNSupersededRequest
+@end
+
 // "The last request of a column" (`showInColumn` step 2): one per split view and column. The newest request decides
-// what the requests it superseded answer: its id, or its rejection.
+// when the requests it superseded answer; each of them resolves with its own screen's id whatever the newest one's
+// outcome, as on Android.
 @interface ANNColumnRecord : NSObject
 @property(nonatomic, weak, nullable) UIViewController *splitView;
 @property(nonatomic, copy) NSString *column;
 // Weakly: what runs the newest request holds it (the waiting requests, the split view's call, the push).
 @property(nonatomic, weak, nullable) ANNColumnRequest *newest;
-@property(nonatomic, strong) NSMutableArray<ANNCommandAnswer *> *superseded;
+@property(nonatomic, strong) NSMutableArray<ANNSupersededRequest *> *superseded;
 @property(nonatomic) BOOL ended;
-@property(nonatomic, copy, nullable) NSString *value;
-@property(nonatomic, copy, nullable) NSString *rejection;
 @end
 
 @implementation ANNColumnRecord
@@ -184,10 +198,11 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
     return record;
 }
 
-// Step 1, the push's wait: `waitForRender` unset waits for the bar components only, `true` for the content as long as
-// it takes (with the rule for content nobody knows of), then the bar components; `false` for nothing; nothing either
-// while the source's place isn't seen. Read from the screen's own options over the defaults: it has no place yet. With
-// content, the screen waits unseen in the source's window, as a layer that waits to show.
+// Step 1, the push's wait, as a stack's push: `waitForRender` unset waits for the content at most 0.5 s, `true` as long
+// as it takes (with the rule for content nobody knows of), then the bar components; `false` for nothing; nothing either
+// while the source's place isn't seen. The content's end waits for the calls JavaScript made by then, so that the
+// options of the screen's first commit are applied before it shows. Read from the screen's own options over the
+// defaults: it has no place yet. The screen waits unseen in the source's window, as a layer that waits to show.
 + (void)startWaitOf:(ANNColumnRequest *)request {
     UIViewController *screen = request.screen;
     Bool *waitForRender = [screen resolveOptionsWithDefault].animations.push.waitForRender;
@@ -198,20 +213,22 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
         [self readyOnNextTurnOf:request];
         return;
     }
-    BOOL content = waitForRender.hasValue;
+    BOOL bounded = !waitForRender.hasValue;
     __weak UIViewController *weakScreen = screen;
     NSArray<UIViewController *> * (^screens)(void) = ^NSArray<UIViewController *> * {
       UIViewController *waited = weakScreen;
       return waited ? waited.waitedComponentViewControllers : @[];
     };
-    ANNRenderWaitContent waited = content ? ANNRenderWaitContentNode : ANNRenderWaitContentNone;
-    ANNRenderWait *wait = [[ANNRenderWait alloc] initWithContent:waited
-                                                            node:content ? screen : nil
-                                                         screens:screens
-                                                           limit:0
-                                                             bar:ANNRenderWaitBarAfterContent
-                                                       barLimits:ANNColumnBarLimits];
-    wait.unknownContentRule = content;
+    ANNRenderWait *wait =
+        [[ANNRenderWait alloc] initWithContent:ANNRenderWaitContentNode
+                                          node:screen
+                                       screens:screens
+                                         limit:bounded ? ANNColumnRenderLimit : 0
+                                           bar:ANNRenderWaitBarAfterContent
+                                     barLimits:ANNColumnBarLimits];
+    wait.unknownContentRule = !bounded;
+    wait.settlesThroughJavaScript = YES;
+    wait.barLimitsFromStart = bounded;
     __weak ANNColumnRequest *weakRequest = request;
     wait.canEnd = ^BOOL {
       ANNColumnRequest *waiting = weakRequest;
@@ -225,7 +242,7 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
       if (!ready) {
           return;
       }
-      // Without content the screen makes it right before it shows (as a push does).
+      // A screen that didn't render while parked makes its content right before it shows (as a push does).
       [ANNSplitViewCommands render:ready];
       if (ready.starting) {
           [ANNSplitViewCommands readyOnNextTurnOf:ready];
@@ -233,14 +250,12 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
           [ANNSplitViewCommands readyOf:ready];
       }
     };
-    if (content) {
-        wait.setUp = ^{
-          ANNColumnRequest *waiting = weakRequest;
-          if (waiting) {
-              [ANNSplitViewCommands park:waiting];
-          }
-        };
-    }
+    wait.setUp = ^{
+      ANNColumnRequest *waiting = weakRequest;
+      if (waiting) {
+          [ANNSplitViewCommands park:waiting];
+      }
+    };
     request.wait = wait;
     request.starting = YES;
     @try {
@@ -281,6 +296,13 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
         [screen setWaitForRender:YES];
     }
     if (window) {
+        __weak ANNColumnRequest *placed = request;
+        ANNScreenPlace * (^place)(void) = ^ANNScreenPlace * {
+          return [ANNSplitViewCommands placeOf:placed];
+        };
+        for (ANNComponentViewController *each in ANNStackScreensOfEntry(screen)) {
+            each.placeWhileParked = place;
+        }
         request.parking = [ANNParking new];
         [request.parking park:screen inView:window];
     }
@@ -304,6 +326,34 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
     }
 }
 
+// Where the parked screen will show, as far as it is known now: the column's stack (whose screens it replaces), the
+// navigation controller UIKit keeps a column that is a screen alone in, or the source's stack while the split view
+// shows as one stack. Nil without one: the screen lays out with its view's own safe area.
++ (nullable ANNScreenPlace *)placeOf:(ANNColumnRequest *)request {
+    UIViewController *screen = request.screen;
+    UIViewController *source = request.source;
+    if (!screen || !source) {
+        return nil;
+    }
+    UIViewController *splitView = ANNSplitViewOf(source);
+    UINavigationController *stack = nil;
+    if (splitView && !ANNIsCollapsedIntoCompact(splitView)) {
+        UIViewController *columnNode =
+            [(id<ANNLayoutProtocol>)splitView viewControllerOfColumn:request.column];
+        stack = [columnNode isKindOfClass:UINavigationController.class]
+                    ? (UINavigationController *)columnNode
+                    : columnNode.navigationController;
+    } else {
+        stack = [ANNStackCommands stackOf:source].shownNavigationController;
+    }
+    if (!stack) {
+        return nil;
+    }
+    return [ANNScreenPlace placeOfEntry:screen
+                                inStack:stack
+                                options:[ANNStackOptionsScreen(screen) resolveOptionsWithDefault]];
+}
+
 // The screen leaves its place and the waiting requests; UIKit ends its departure from the window here (it shows in
 // this turn, or goes).
 + (void)leaveWaitingPlace:(ANNColumnRequest *)request {
@@ -353,18 +403,23 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
     [self request:request endedWithValue:nil rejection:text];
 }
 
-// Superseded at its readiness: its screen goes without having shown (no events), and its answer is the newest
-// request's, at once when that answered.
+// Superseded at its readiness: its screen goes without having shown (no events). It answers when the newest request
+// does, at once when that answered, with its own screen's id: the newest one's rejection (a container for a stack
+// column, a split view that went) is about that request only.
 + (void)supersede:(ANNColumnRequest *)request {
     [self leaveWaitingPlace:request];
     request.done = YES;
+    NSString *value = ANNStackAnswerIdOf(request.screen, ANNStackAnswerCommandShowInColumn);
     [request.screen destroy];
     ANNColumnRecord *record = request.record;
     if (record.ended) {
-        [self answer:request.answer value:record.value rejection:record.rejection];
+        [request.answer resolve:value];
         return;
     }
-    [record.superseded addObject:request.answer];
+    ANNSupersededRequest *superseded = [ANNSupersededRequest new];
+    superseded.answer = request.answer;
+    superseded.value = value;
+    [record.superseded addObject:superseded];
 }
 
 // (a) The split view shows the screen in the column: a stack column's screens are replaced without an animation and
@@ -373,14 +428,26 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
 // `DidDisappear` of the screens that left, `DidAppear` of the new one, the state, then the answer.
 + (void)show:(ANNColumnRequest *)request inSplitView:(UIViewController *)splitView {
     UIViewController *screen = request.screen;
+    UIViewController *columnNode =
+        [(id<ANNLayoutProtocol>)splitView viewControllerOfColumn:request.column];
+    // A stack column takes what a stack takes, a screen or a pair; any other layout rejects `columnIsStack`, as on
+    // Android. A column that is a screen alone takes any layout in its place.
+    if ([columnNode isKindOfClass:UINavigationController.class] &&
+        [ANNLayoutValidator checkStackChild:request.layout
+                                    stackId:columnNode.layoutInfo.componentId ?: @""]) {
+        [self leaveWaitingPlace:request];
+        [screen destroy];
+        [self request:request
+            endedWithValue:nil
+                 rejection:[ANNErrorTexts columnIsStack:request.componentId column:request.column]];
+        return;
+    }
     // Before the parking lets go of it, so that UIKit's calls stay silent until the end.
     [ANNAppearanceDispatcher driveAppearanceOf:@[ screen ]];
     request.driven = YES;
     [self leaveWaitingPlace:request];
     // A screen alone in a column has the split view as its parent by the layout (UIKit puts it into a navigation
     // controller of its own); a stack column's stack is its parent.
-    UIViewController *columnNode =
-        [(id<ANNLayoutProtocol>)splitView viewControllerOfColumn:request.column];
     if (columnNode && ![columnNode isKindOfClass:UINavigationController.class]) {
         [screen setExplicitLayoutParent:splitView];
     }
@@ -485,7 +552,8 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
 
 #pragma mark - The answers
 
-// The request answers once; when it is the newest of its column, the requests it superseded answer the same.
+// The request answers once; when it is the newest of its column, the requests it superseded answer then, each with its
+// own screen's id.
 + (void)request:(ANNColumnRequest *)request
     endedWithValue:(NSString *)value
          rejection:(NSString *)rejection {
@@ -499,13 +567,11 @@ static NSMapTable<UIViewController *, ANNColumnRecordsOfSplitView *> *ANNColumnR
         return;
     }
     record.ended = YES;
-    record.value = value;
-    record.rejection = rejection;
     record.newest = nil;
-    NSArray<ANNCommandAnswer *> *superseded = [record.superseded copy];
+    NSArray<ANNSupersededRequest *> *superseded = [record.superseded copy];
     [record.superseded removeAllObjects];
-    for (ANNCommandAnswer *answer in superseded) {
-        [self answer:answer value:value rejection:rejection];
+    for (ANNSupersededRequest *each in superseded) {
+        [each.answer resolve:each.value];
     }
     // A request that begins from now on starts a record of its own.
     UIViewController *splitView = record.splitView;

package/ios/Layouts/SplitView/ANNSplitViewController.mm

@@ -214,19 +214,21 @@ static UISplitViewControllerColumn ANNSplitViewColumn(NSString *name) {
             completion:(ANNTransitionCompletionBlock)completion
              rejection:(ANNTransitionRejectionBlock)rejection {
     UIViewController *previous = _columns[column];
-    NSString *fromId = fromViewController.layoutInfo.componentId;
+    NSString *fromId = fromViewController.layoutInfo.componentId ?: @"";
     if (!previous) {
         rejection([ANNErrorTexts noSuchColumn:fromId column:column], nil);
         return;
     }
     if ([previous isKindOfClass:UINavigationController.class]) {
-        // UIKit does not take a navigation controller among the screens of another.
+        // UIKit does not take a navigation controller among the screens of another. The core rejects every layout a
+        // stack doesn't take before it asks; this guards the module's own call.
         if ([screen isKindOfClass:UINavigationController.class]) {
             rejection([ANNErrorTexts columnIsStack:fromId column:column], nil);
             return;
         }
         // In place, as a column of UIKit apps changes; UIKit animates a column it brings on top.
         [(UINavigationController *)previous setStackChildren:@[ screen ]
+                                                    inColumn:column
                                           fromViewController:fromViewController
                                                     animated:NO
                                                   completion:^{

package/ios/Layouts/Stack/ANNStackCommands.mm

@@ -274,6 +274,7 @@
     if (target == stack.queue.entries.lastObject) {
         [stack.queue noneWithValue:componentId
                             answer:answer
+                              what:what
                        componentId:componentId
                             source:target];
         return;

package/ios/Layouts/Stack/ANNStackController.mm

@@ -1102,6 +1102,11 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     if (change == ANNStackChangePush && animated) {
         lowerBarBottom = [self lowerBarBottomOf:navigation leaving:coveredTop];
     }
+    // The large title of a screen that comes with its content takes its place for the transition before UIKit's push.
+    if (change == ANNStackChangePush && animated) {
+        UIViewController *arriving = ANNStackOptionsScreen(entries.lastObject);
+        [[ANNTopBarPresenter presenterOfScreen:arriving] arrivesByPushOn:navigation];
+    }
     // The revealed screen's large title takes its place for the transition before UIKit lays the screen out for it.
     if (change == ANNStackChangePop && animated) {
         [self popReveals:entries.lastObject leaving:coveredTop on:navigation];
@@ -1428,10 +1433,28 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 
 // The screen waits in the window at the stack's size, under UIKit's container view ( `ANNParking`): it isn't a child of
 // anything there, gets no touches, is hidden from accessibility, and its appearance is driven, so UIKit's callbacks
-// report nothing for it. Each path that ends the wait gives the view back as it was; UIKit's push of the entry
-// re-parents it in the same turn, so its departure is not ended here.
+// report nothing for it. UIKit gives such a view no safe area: its screens lay out with that of their place on top of
+// the stack meanwhile (`ANNScreenPlace`). Each path that ends the wait gives the view back as it was; UIKit's push of
+// the entry re-parents it in the same turn, so its departure is not ended here.
 - (void)stackPark:(UIViewController *)entry {
-    [_parking park:entry inView:self.shownNavigationController.view];
+    UINavigationController *navigation = self.shownNavigationController;
+    // Its screens lay out as on top of the stack, with the bar and the toolbar the entry shows there.
+    __weak UIViewController *weakEntry = entry;
+    __weak UINavigationController *weakNavigation = navigation;
+    ANNScreenPlace * (^place)(void) = ^ANNScreenPlace * {
+      UIViewController *parked = weakEntry;
+      UINavigationController *stack = weakNavigation;
+      if (!parked || !stack) {
+          return nil;
+      }
+      return [ANNScreenPlace placeOfEntry:parked
+                                  inStack:stack
+                                  options:[ANNStackOptionsScreen(parked) resolveOptionsWithDefault]];
+    };
+    for (ANNComponentViewController *screen in ANNStackScreensOfEntry(entry)) {
+        screen.placeWhileParked = place;
+    }
+    [_parking park:entry inView:navigation.view];
 }
 
 - (void)stackUnpark:(UIViewController *)entry {

package/ios/Layouts/Stack/ANNStackQueue.h

@@ -166,9 +166,11 @@ typedef NS_ENUM(NSInteger, ANNStackChange) {
          completion:(nullable dispatch_block_t)completion
           rejection:(nullable ANNTransitionRejectionBlock)rejection;
 
-/// A command that moves nothing (`popTo` of the top) answers `value` in its turn.
+/// A command that moves nothing (`popTo` of the top) answers `value` in its turn; a failure meanwhile rejects with the
+/// command's own `what`.
 - (void)noneWithValue:(id)value
                answer:(ANNCommandAnswer *)answer
+                 what:(NSString *)what
           componentId:(NSString *)componentId
                source:(nullable UIViewController *)source;