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

package/ios/Layouts/Modal/ANNModalCoordinator.mm

@@ -277,8 +277,8 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
 
 // The end steps of a record (its show presented, its dismissal ended, closed by the user) run inside UIKit's
 // completions and delegate calls, outside the runner's protection, in any state: a failure there is logged in one line,
-// rejects what of the record still waits for an answer (its show, a chain step, its dismissals), and its drive stops.
-// The gate's `done` ran before the step, as without a failure.
+// answers what of the record still waits for an answer (its show, a chain step, its dismissals:
+// `endFailedOf:showing:exception:`), and its drive stops. The gate's `done` ran before the step, as without a failure.
 + (void)protectEndOf:(ANNModal *)modal showing:(BOOL)showing step:(dispatch_block_t)step {
     @try {
         step();
@@ -288,24 +288,43 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                                : (showing ? @"show a modal" : @"dismiss a modal");
         NSString *reason = exception.reason.length > 0 ? exception.reason : exception.name;
         RCTLogWarn(@"[ApexNavigation] %@", [ANNErrorTexts couldNot:what reason:reason]);
-        [self endFailedOf:modal exception:exception];
+        [self endFailedOf:modal showing:showing exception:exception];
     }
 }
 
-+ (void)endFailedOf:(ANNModal *)modal exception:(NSException *)exception {
+// A failed end step of `modal`: its show rejects. After a failed show the dismissals that wait for it don't fail with
+// it, as on Android: on a modal that shows they run now and resolve once it went (one still `Presenting` shows: UIKit's
+// completion ran); on one that goes another way (a `dismissAllModals`, with the old root) or went already they resolve
+// with its root's id; on one in another transition (a drag, its own dismissal) they wait for that transition's end.
+// A failed dismissal rejects itself and the dismissals behind it.
++ (void)endFailedOf:(ANNModal *)modal showing:(BOOL)showing exception:(NSException *)exception {
     if (!modal) {
         return;
     }
     [self stopDriving:modal];
     NSString *show = [NSString stringWithFormat:@"show the screen '%@'", modal.rootId];
-    NSString *dismiss = [NSString stringWithFormat:@"dismiss the modal '%@'", modal.rootId];
     [modal.showAnswer reject:[ANNCommandRunner rejectionOf:exception what:show]];
-    NSString *dismissText = [ANNCommandRunner rejectionOf:exception what:dismiss];
-    [modal.dismissal.answer reject:dismissText];
-    NSArray<ANNModalDismissal *> *pending = modal.pending.copy;
-    [modal.pending removeAllObjects];
-    for (ANNModalDismissal *waiting in pending) {
-        [waiting.answer reject:dismissText];
+    ANNModalState state = modal.state;
+    BOOL goesAnotherWay = (state == ANNModalStateDismissing && modal.batch) ||
+                          state == ANNModalStateWithOldRoot ||
+                          state == ANNModalStateClosedBelow || state == ANNModalStateGone;
+    if (showing && state == ANNModalStatePresenting) {
+        modal.state = ANNModalStateShown;
+    }
+    if (showing && modal.state == ANNModalStateShown) {
+        [self runPendingOf:modal];
+    } else if (showing && goesAnotherWay) {
+        [modal.dismissal.answer resolve:modal.rootId];
+        [self resolvePendingOf:modal];
+    } else if (!showing) {
+        NSString *dismiss = [NSString stringWithFormat:@"dismiss the modal '%@'", modal.rootId];
+        NSString *dismissText = [ANNCommandRunner rejectionOf:exception what:dismiss];
+        [modal.dismissal.answer reject:dismissText];
+        NSArray<ANNModalDismissal *> *pending = modal.pending.copy;
+        [modal.pending removeAllObjects];
+        for (ANNModalDismissal *waiting in pending) {
+            [waiting.answer reject:dismissText];
+        }
     }
     // A `setRoot` chain goes on (its own steps are guarded by the root coordinator).
     void (^chainStep)(BOOL) = modal.chainStep;
@@ -333,7 +352,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
             [waiter reject:text];
         }
         for (ANNModal *modal in batch.records.copy) {
-            [self endFailedOf:modal exception:exception];
+            [self endFailedOf:modal showing:NO exception:exception];
         }
     }
 }
@@ -537,7 +556,8 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
     modal.coversUnder = under != nil && under.viewIfLoaded.window == nil;
     NSArray<UIViewController *> *hidden = modal.coversUnder ? @[ under ] : @[];
     @try {
-        // The chain step stays on the record until its events went: a failure there tells the chain (`endFailedOf:`).
+        // The chain step stays on the record until its events went: a failure there tells the chain
+        // (`endFailedOf:showing:exception:`).
         void (^chainStep)(BOOL) = modal.chainStep;
         if (chainStep) {
             [ANNAppearanceDispatcher endSwitchHiding:hidden showing:@[ root ] events:nil];
@@ -778,6 +798,11 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
         [answer reject:[ANNErrorTexts screenNotShown:componentId]];
         return;
     }
+    // The last modal over no root (shown before any `setRoot`) stays: nothing would be left to show, as on Android.
+    if ([self isLastWithoutRoot:modal]) {
+        [answer reject:[ANNErrorTexts modalWithoutRoot:componentId]];
+        return;
+    }
     // Step 1: the options, read on the main queue; one that can't be read rejects before anything changes. They merge
     // into the modal's visible screen as `mergeOptions` would.
     if (options.count > 0) {
@@ -815,6 +840,22 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
     [self dismiss:modal with:dismissal];
 }
 
+// No root in the window (the splash, or nothing yet) and no other modal that shows or comes: `modal` is all a dismissal
+// would take away. One closed below, going with the old root or gone takes nothing away, so it doesn't count.
++ (BOOL)isLastWithoutRoot:(ANNModal *)modal {
+    if (modal.state == ANNModalStateClosedBelow || modal.state == ANNModalStateGone ||
+        ApexNavigation.mainWindow.rootViewController.isLayoutNode) {
+        return NO;
+    }
+    for (ANNModal *other in ANNModals) {
+        if (other != modal && other.state != ANNModalStateClosedBelow &&
+            other.state != ANNModalStateWithOldRoot && other.state != ANNModalStateGone) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
 // The modal of `node`: the record whose root is the top of `node`'s layout.
 + (ANNModal *)modalOf:(UIViewController *)node {
     UIViewController *top = node;
@@ -897,7 +938,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                    [ANNErrorTexts couldNot:what reason:exception.reason ?: exception.name]);
         // The dismissal still open answers, and so do the dismissals waiting behind it (an answer given already
         // stays as it was).
-        [self endFailedOf:modal exception:exception];
+        [self endFailedOf:modal showing:NO exception:exception];
         done();
     }
 }

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`),

package/ios/Layouts/Root/ANNSplashViewController.mm

@@ -34,9 +34,63 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     return names;
 }
 
+static NSDictionary *ANNDictionaryOrNil(id value) {
+    return [value isKindOfClass:NSDictionary.class] ? value : nil;
+}
+
+static NSString *ANNStringOrNil(id value) {
+    return [value isKindOfClass:NSString.class] && [value length] > 0 ? value : nil;
+}
+
+// The definition that a plural key (`UILaunchScreens`, `UILaunchStoryboards`) marks as its default.
+static NSDictionary *ANNDefaultDefinition(id plural, NSString *definitionsKey,
+                                          NSString *identifierKey, NSString *defaultKey) {
+    NSDictionary *dictionary = ANNDictionaryOrNil(plural);
+    NSArray *definitions = dictionary[definitionsKey];
+    NSString *defaultIdentifier = ANNStringOrNil(dictionary[defaultKey]);
+    if (![definitions isKindOfClass:NSArray.class] || !defaultIdentifier) {
+        return nil;
+    }
+    for (id definition in definitions) {
+        NSDictionary *entry = ANNDictionaryOrNil(definition);
+        if ([entry[identifierKey] isEqual:defaultIdentifier]) {
+            return entry;
+        }
+    }
+    return nil;
+}
+
+// The launch screen that iOS builds from the Info.plist without a storyboard, or nil when it shows a storyboard. Of
+// `UILaunchStoryboardName`, `UILaunchScreen`, the default of `UILaunchStoryboards` and the default of
+// `UILaunchScreens`, the last one present wins (SplashBoard's `XBApplicationLaunchCompatibilityInfo`). A launch by a
+// link that `UILaunchScreens` maps to a screen of its own still gets the default here.
+static NSDictionary *ANNLaunchScreenConfiguration(NSBundle *bundle) {
+    NSDictionary *screen =
+        ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchScreens"],
+                             @"UILaunchScreenDefinitions", @"UILaunchScreenIdentifier",
+                             @"UIDefaultLaunchScreen");
+    if (screen) {
+        return screen;
+    }
+    if (ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchStoryboards"],
+                             @"UILaunchStoryboardDefinitions", @"UILaunchStoryboardIdentifier",
+                             @"UIDefaultLaunchStoryboard")) {
+        return nil;
+    }
+    return ANNDictionaryOrNil([bundle objectForInfoDictionaryKey:@"UILaunchScreen"]);
+}
+
 @implementation ANNSplashViewController {
     UIViewController *_content;
     UIView *_contentView;
+    NSDictionary *_launchScreen;
+    // The parts of a launch screen built from `UILaunchScreen`, laid out once the safe area is known.
+    UIImageView *_imageView;
+    BOOL _imageRespectsSafeArea;
+    UINavigationBar *_navigationBar;
+    UIImageView *_navigationBarImageView;
+    UIView *_bottomBar;
+    UIImageView *_bottomBarImageView;
 }
 
 - (instancetype)initWithContent:(UIViewController *)content
@@ -52,6 +106,12 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
 
 + (instancetype)launchScreenCopyWithBounds:(CGRect)bounds {
     NSBundle *bundle = NSBundle.mainBundle;
+    NSDictionary *launchScreen = ANNLaunchScreenConfiguration(bundle);
+    if (launchScreen) {
+        ANNSplashViewController *copy = [[self alloc] initWithContent:nil contentView:nil blank:NO];
+        copy->_launchScreen = launchScreen;
+        return copy;
+    }
     NSString *storyboardName = [bundle objectForInfoDictionaryKey:@"UILaunchStoryboardName"];
     if ([storyboardName isKindOfClass:NSString.class] && storyboardName.length > 0) {
         UIViewController *initial = nil;
@@ -97,6 +157,10 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
         view.backgroundColor = windowHasColor ? UIColor.clearColor : UIColor.systemBackgroundColor;
         return;
     }
+    if (_launchScreen) {
+        [self buildLaunchScreen];
+        return;
+    }
     UIView *contentView = _contentView;
     if (_content) {
         [self addChildViewController:_content];
@@ -109,6 +173,89 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     [_content didMoveToParentViewController:self];
 }
 
+#pragma mark - The launch screen of `UILaunchScreen`
+
+// Built as SplashBoard builds it: the named color over the whole screen, else the system background; the named image
+// at its own size in the middle of the screen or of its safe area, stretched instead when the asset has slicing; a tab
+// bar or a toolbar at the bottom and a navigation bar at the top, the system's own bars, or the bar's named image
+// stretched over the bar's place. A name the asset catalog doesn't have leaves its part out, as iOS does.
+- (void)buildLaunchScreen {
+    UIView *view = self.view;
+    NSString *colorName = ANNStringOrNil(_launchScreen[@"UIColorName"]);
+    UIColor *color = colorName ? [UIColor colorNamed:colorName] : nil;
+    view.backgroundColor = color ?: UIColor.systemBackgroundColor;
+
+    NSString *imageName = ANNStringOrNil(_launchScreen[@"UIImageName"]);
+    UIImage *image = imageName ? [UIImage imageNamed:imageName] : nil;
+    if (image) {
+        _imageView = [[UIImageView alloc] initWithImage:image];
+        _imageView.contentMode = UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero)
+                                     ? UIViewContentModeCenter
+                                     : UIViewContentModeScaleToFill;
+        id respects = _launchScreen[@"UIImageRespectsSafeAreaInsets"];
+        _imageRespectsSafeArea = [respects respondsToSelector:@selector(boolValue)] &&
+                                 [respects boolValue];
+        [view addSubview:_imageView];
+    }
+
+    // A toolbar takes the bottom before a tab bar; a navigation bar comes on top of either.
+    id toolbar = _launchScreen[@"UIToolbar"];
+    id tabBar = _launchScreen[@"UITabBar"];
+    if (toolbar || tabBar) {
+        _bottomBar = toolbar ? [UIToolbar new] : [UITabBar new];
+        _bottomBarImageView = [self addBar:_bottomBar configuration:toolbar ?: tabBar];
+    }
+    id navigationBar = _launchScreen[@"UINavigationBar"];
+    if (navigationBar) {
+        _navigationBar = [UINavigationBar new];
+        _navigationBarImageView = [self addBar:_navigationBar configuration:navigationBar];
+    }
+}
+
+// Adds the bar, or its image in its place when its configuration names one that loads.
+- (UIImageView *)addBar:(UIView *)bar configuration:(id)configuration {
+    NSString *name = ANNStringOrNil(ANNDictionaryOrNil(configuration)[@"UIImageName"]);
+    UIImage *image = name ? [UIImage imageNamed:name] : nil;
+    UIImageView *imageView = image ? [[UIImageView alloc] initWithImage:image] : nil;
+    bar.hidden = imageView != nil;
+    [self.view addSubview:bar];
+    if (imageView) {
+        [self.view addSubview:imageView];
+    }
+    return imageView;
+}
+
+// The safe area is known only in the window, so the parts are laid out here, after every change of it.
+- (void)viewDidLayoutSubviews {
+    [super viewDidLayoutSubviews];
+    if (!_launchScreen) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    _imageView.frame =
+        _imageRespectsSafeArea ? UIEdgeInsetsInsetRect(bounds, safeArea) : bounds;
+    [self layOutBar:_bottomBar imageView:_bottomBarImageView atBottom:YES];
+    [self layOutBar:_navigationBar imageView:_navigationBarImageView atBottom:NO];
+}
+
+// A bar is as tall as UIKit makes it, plus the safe area on its edge of the screen, and as wide as the screen.
+- (void)layOutBar:(UIView *)bar
+        imageView:(UIImageView *)imageView
+         atBottom:(BOOL)atBottom {
+    if (!bar) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    CGFloat height = [bar sizeThatFits:bounds.size].height +
+                     (atBottom ? safeArea.bottom : safeArea.top);
+    CGFloat y = atBottom ? CGRectGetMaxY(bounds) - height : CGRectGetMinY(bounds);
+    CGRect frame = CGRectMake(CGRectGetMinX(bounds), y, CGRectGetWidth(bounds), height);
+    bar.frame = frame;
+    imageView.frame = frame;
+}
+
 #pragma mark - The status bar, as the launch screen had it
 
 - (UIStatusBarStyle)preferredStatusBarStyle {

package/ios/Layouts/Screen/ANNComponentViewController.h

@@ -1,6 +1,7 @@
 #import "ANNArrangementScreenDelegate.h"
 #import "ANNLayoutProtocol.h"
 #import "ANNScreenAppearance.h"
+#import "ANNScreenPlace.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <UIKit/UIKit.h>
 
@@ -42,6 +43,13 @@ NS_ASSUME_NONNULL_BEGIN
 /// nobody rendered gets its content when UIKit first loads its view.
 - (void)render;
 
+/// Where the screen will show while it waits for its content out of it (parked by a stack's or `showInColumn`'s wait,
+/// `ANNParking`): it lays out with that place's safe area and bars (`ANNScreenPlace`), as it will once it shows there.
+/// Asked at each layout, and kept past the parking until UIKit gives the screen a safe area of its own in a parent
+/// (the push lays it out once before that, with none), or as it appears. Nil: its view's own. Set by the one that
+/// parks the screen.
+@property(nonatomic, copy, nullable) ANNScreenPlace *_Nullable (^placeWhileParked)(void);
+
 /// Applies the "under bars" rule to the root frame again, then gives the modules the insets, the padding and the
 /// regions of the screen. Nothing before the view loaded; the safe area only in a window.
 - (void)updateRootLayout;

package/ios/Layouts/Screen/ANNComponentViewController.mm

@@ -162,6 +162,11 @@
     [ANNSystemUI setNeedsUpdate];
     [self.arrangement screenDidChangeLayout:self];
     [ANNHinge watchForScreens];
+    // A parked screen whose place gave it no safe area at all lays out with its view's own from now on.
+    if (self.placeWhileParked && ![ANNParking isUnseen:self]) {
+        self.placeWhileParked = nil;
+        [self updateRootLayout];
+    }
     // Once JavaScript heard the appearance (a driven one ends later, with its command).
     __weak ANNComponentViewController *weakSelf = self;
     [ANNAppearanceDispatcher afterDidAppearOf:self.appearance
@@ -363,11 +368,31 @@
 }
 #endif
 
+// The place the screen waits to show in, while it is parked out of it and until UIKit gives it a safe area of its
+// own there: the push lays the screen out once before that, with none, and a list laid out then at the screen's top
+// would stay the list the bar follows. A place that shows with no safe area at all hands over as the screen appears.
+- (nullable ANNScreenPlace *)parkedPlace {
+    ANNScreenPlace * (^place)(void) = self.placeWhileParked;
+    if (!place) {
+        return nil;
+    }
+    if (![ANNParking isUnseen:self] && self.parentViewController &&
+        !UIEdgeInsetsEqualToEdgeInsets(self.view.safeAreaInsets, UIEdgeInsetsZero)) {
+        self.placeWhileParked = nil;
+        return nil;
+    }
+    return place();
+}
+
 - (CGRect)rootFrameForOptions:(ANNNavigationOptions *)options {
     UIView *view = self.view;
-    BOOL fromTop = ANNScreenIsUnderTopBar(options) || ![self hasShownTopBar];
-    BOOL toBottom = ANNScreenIsUnderTabBar(options) || ![self hasShownTabBar];
-    return ANNScreenRootFrame(view.bounds, view.safeAreaInsets, fromTop, toBottom);
+    ANNScreenPlace *place = [self parkedPlace];
+    BOOL topBarShown = place ? place.showsTopBar : [self hasShownTopBar];
+    BOOL tabBarShown = place ? place.showsTabBar : [self hasShownTabBar];
+    BOOL fromTop = ANNScreenIsUnderTopBar(options) || !topBarShown;
+    BOOL toBottom = ANNScreenIsUnderTabBar(options) || !tabBarShown;
+    UIEdgeInsets safeArea = place ? place.safeArea : view.safeAreaInsets;
+    return ANNScreenRootFrame(view.bounds, safeArea, fromTop, toBottom);
 }
 
 - (void)updateRootLayout {
@@ -421,8 +446,10 @@
         self.nodeHelper.destroyed) {
         return;
     }
-    UIEdgeInsets insets =
-        ANNScreenInsetsOverRoot(content.frame, view.bounds.size, view.safeAreaInsets);
+    // A parked screen has no safe area of its own: it takes its place's.
+    ANNScreenPlace *place = [self parkedPlace];
+    UIEdgeInsets safeArea = place ? place.safeArea : view.safeAreaInsets;
+    UIEdgeInsets insets = ANNScreenInsetsOverRoot(content.frame, view.bounds.size, safeArea);
     UINavigationController *stack = [self shownNavigation];
     ANNScreenPaddingContext context = {
         .inStack = stack != nil,

package/ios/Layouts/Screen/ANNScreenPlace.h

@@ -0,0 +1,41 @@
+#import "ANNNavigationOptions.h"
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Where an entry will show on top of a stack, as UIKit lays it out there: the safe area its screens get, and whether
+/// the stack's bar and the tab bar show for it. A screen that waits for its content out of its stack (parked,
+/// `ANNParking`) has no parent view controller, and UIKit gives its view no safe area at all: it lays out with its
+/// place's instead (`placeWhileParked` of `ANNComponentViewController`), so that its root frame, its padding, the
+/// insets JavaScript reads in its first render and its main list are those it has after the push. Nothing of it moves
+/// as the push starts: a list that moved then would lose the large title, which UIKit draws in the list the bar
+/// follows.
+///
+/// The bar's height is UIKit's own: a navigation controller of the core's, unseen in the stack's view for the moment of
+/// the measure, shows an item made like the entry's (title, display mode of the large title, looks, subtitles, prompt,
+/// style, search field) over one like the stack's top, with the stack's bar settings and the entry's toolbar. Main
+/// queue.
+@interface ANNScreenPlace : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The place of `entry` (a screen, or a pair whose screens show under its bar) on top of `stack`, with `options` the
+/// resolved options the stack shows its bar and toolbar by; nil when the stack isn't in a window. Measured again only
+/// when something the measure reads changed since the last one for `entry`.
++ (nullable ANNScreenPlace *)placeOfEntry:(UIViewController *)entry
+                                  inStack:(UINavigationController *)stack
+                                  options:(ANNNavigationOptions *)options;
+
+/// The safe area of the entry's view in the place.
+@property(nonatomic, readonly) UIEdgeInsets safeArea;
+
+/// The stack's bar shows for the entry (`topBar.visible`).
+@property(nonatomic, readonly) BOOL showsTopBar;
+
+/// A tab bar shows at the bottom for the entry: one shows now and the entry doesn't hide it.
+@property(nonatomic, readonly) BOOL showsTabBar;
+
+@end
+
+NS_ASSUME_NONNULL_END

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