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

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/ANNPreviewPush.h

@@ -6,11 +6,11 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// The preview of a push (`usePreview`): a push that waits for a tap on its preview. Its screen is made and renders
-/// unseen, out of the stack, its key kept; the view with `preview.nativeID` is looked for on the source screen at once
-/// and on the next frames, 30 tries in all; found, the preview module (`ANNPreviewInteraction`) shows the screen from
-/// it on a long press. A tap that commits pushes the screen without an animation and without a wait, or goes back to
-/// the entry with its key; a preview that goes without being opened destroys its screen and rejects the push. Main
-/// queue.
+/// unseen, out of the stack, its key kept; the view with `preview.nativeID` is looked for on the source screen at once,
+/// then at each mount of the source's content (on each frame for a slot screen), for at most 0.5 s; found, the preview module (`ANNPreviewInteraction`)
+/// shows the screen from it on a long press. A tap that commits pushes the screen without an animation and without a
+/// wait, or goes back to the entry with its key; a preview that goes without being opened destroys its screen and
+/// rejects the push. Main queue.
 @interface ANNPreviewPush : NSObject
 
 - (instancetype)init NS_UNAVAILABLE;

package/ios/Layouts/Stack/ANNPreviewPush.mm

@@ -6,14 +6,16 @@
 #import "ANNPopoverPresenter.h"
 #import "ANNPreviewInteraction.h"
 #import "ANNReloadCoordinator.h"
+#import "ANNSlotScreenView.h"
 #import "ANNStackCommands.h"
 #import "ANNStackController.h"
 #import "ApexNavigation+Internal.h"
 #import "UIViewController+LayoutProtocol.h"
 
-// The view of a component mounts a frame or so after the command that rendered it: it is looked for this many times,
-// a frame apart.
-static const NSUInteger ANNPreviewSearchTries = 30;
+// The view of a component mounts a frame or so after the command that rendered it: it is looked for at each mount of
+// the source's content until this limit (30 frames), then the preview goes, as with a `nativeID` no view has.
+static const NSTimeInterval ANNPreviewSearchLimit = 30.0 / 60;
+// Where the source's mounts can't be heard, a frame apart.
 static const NSTimeInterval ANNPreviewSearchInterval = 1.0 / 60;
 
 // One preview from its push to its end: the tap took it, or it went.
@@ -28,7 +30,8 @@ static const NSTimeInterval ANNPreviewSearchInterval = 1.0 / 60;
 @property(nonatomic, copy) NSString *componentId;
 @property(nonatomic, copy) NSString *what;
 @property(nonatomic) NSUInteger generation;
-@property(nonatomic) NSUInteger tries;
+// The content whose mounts the search hears, while it looks.
+@property(nonatomic, weak, nullable) UIView<ANNComponentProtocol> *watched;
 @property(nonatomic) BOOL attached;
 @property(nonatomic) BOOL done;
 // The screen's unseen place in the main window, at its preview size, until UIKit takes its view for the menu.
@@ -84,7 +87,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
         [screen destroy];
         @throw;
     }
-    [self search:record];
+    [self startSearch:record];
 }
 
 // The screen renders as now: its view waits unseen in the main window, at the size of the preview, so that its content
@@ -110,41 +113,99 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
 
 #pragma mark - The search
 
-// Each try asks first whether the preview still lives: a source that went makes it go, a reload stops it silently.
-+ (void)search:(ANNPreviewRecord *)record {
-    if (record.done || record.attached) {
+// The view is looked for at once; else again at each mount of the source's content, where it comes with one of them,
+// and a last time at the limit, when the preview goes. Both later steps keep the generation they were made with: after
+// a reload they do nothing.
++ (void)startSearch:(ANNPreviewRecord *)record {
+    if ([self search:record last:NO]) {
         return;
     }
+    UIViewController *source = record.source;
+    // A source that is a container (a stack) is heard through the screen it shows.
+    UIView<ANNComponentProtocol> *content =
+        source.reactView ?: source.presentedComponentViewController.reactView;
+    __weak ANNPreviewRecord *weakRecord = record;
+    NSUInteger generation = record.generation;
+    // A slot screen hears only the first mount of its slot, not those deeper in it, and a container may show no React
+    // content yet: there the view is looked for on each frame until the limit.
+    if (!content || [content isKindOfClass:ANNSlotScreenView.class]) {
+        [self searchNextFrame:record];
+    } else {
+        record.watched = content;
+        [content setContentDidMount:^{
+          ANNPreviewRecord *searching = weakRecord;
+          if (searching && generation == ANNReloadCoordinator.generation) {
+              [ANNPreviewPush search:searching last:NO];
+          }
+        }
+                             forKey:[self mountKeyOf:record]];
+    }
+    int64_t delay = (int64_t)(ANNPreviewSearchLimit * NSEC_PER_SEC);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
+      ANNPreviewRecord *searching = weakRecord;
+      if (searching && generation == ANNReloadCoordinator.generation) {
+          [ANNPreviewPush search:searching last:YES];
+      }
+    });
+}
+
+// One more search on the next frame, and so on until the view is found or the preview goes; after a reload, none.
++ (void)searchNextFrame:(ANNPreviewRecord *)record {
+    __weak ANNPreviewRecord *weakRecord = record;
+    NSUInteger generation = record.generation;
+    int64_t delay = (int64_t)(ANNPreviewSearchInterval * NSEC_PER_SEC);
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
+      ANNPreviewRecord *searching = weakRecord;
+      if (searching && generation == ANNReloadCoordinator.generation &&
+          ![ANNPreviewPush search:searching last:NO]) {
+          [ANNPreviewPush searchNextFrame:searching];
+      }
+    });
+}
+
+// YES when the search is over: the view was found, or the preview went or stopped. Each search asks first whether the
+// preview still lives: a source that went makes it go, a reload stops it silently. The last one, not finding the view,
+// makes the preview go.
++ (BOOL)search:(ANNPreviewRecord *)record last:(BOOL)last {
+    if (record.done || record.attached) {
+        return YES;
+    }
     if (record.generation != ANNReloadCoordinator.generation) {
-        return;
+        return YES;
     }
     UIViewController *source = record.source;
     if (!source || source.nodeHelper.destroyed) {
         [self gone:record];
-        return;
+        return YES;
     }
     // Read only: the view is found by its `nativeID`, and its tag is its current Fabric tag.
     UIView *view = [ANNPopoverPresenter viewWithNativeID:record.nativeID in:source.viewIfLoaded];
     if (view) {
         [self attach:record toView:view source:source];
-        return;
+        return YES;
     }
-    if (++record.tries >= ANNPreviewSearchTries) {
+    if (last) {
         [self gone:record];
-        return;
+        return YES;
     }
-    __weak ANNPreviewRecord *weakRecord = record;
-    int64_t delay = (int64_t)(ANNPreviewSearchInterval * NSEC_PER_SEC);
-    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
-      ANNPreviewRecord *searching = weakRecord;
-      if (searching) {
-          [ANNPreviewPush search:searching];
-      }
-    });
+    return NO;
+}
+
+// The key of the search's mount handler: one per preview, so that two previews of one source don't replace each other.
++ (NSString *)mountKeyOf:(ANNPreviewRecord *)record {
+    return [@"preview." stringByAppendingString:record.previewId];
+}
+
+// The search stops hearing the mounts: only its own handler goes.
++ (void)stopWatching:(ANNPreviewRecord *)record {
+    UIView<ANNComponentProtocol> *content = record.watched;
+    record.watched = nil;
+    [content setContentDidMount:nil forKey:[self mountKeyOf:record]];
 }
 
 + (void)attach:(ANNPreviewRecord *)record toView:(UIView *)view source:(UIViewController *)source {
     record.attached = YES;
+    [self stopWatching:record];
     __weak ANNPreviewRecord *weakRecord = record;
     BOOL (^commit)(void) = ^BOOL {
       return [ANNPreviewPush commit:weakRecord];
@@ -231,9 +292,10 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     [record.answer reject:[ANNErrorTexts previewGone:record.previewId]];
 }
 
-// The record is done: the screen leaves its unseen place, the table forgets it.
+// The record is done: the search stops, the screen leaves its unseen place, the table forgets it.
 + (void)finish:(ANNPreviewRecord *)record {
     record.done = YES;
+    [self stopWatching:record];
     [self unpark:record];
     if (ANNPreviewRecords()[record.previewId] == record) {
         [ANNPreviewRecords() removeObjectForKey:record.previewId];
@@ -286,6 +348,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     NSMutableArray<UIViewController *> *screens = [NSMutableArray new];
     for (ANNPreviewRecord *record in ANNPreviewRecords().allValues) {
         record.done = YES;
+        [self stopWatching:record];
         [self unpark:record];
         if (!record.attached) {
             [screens addObject:record.screen];

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;