@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.10

package/ios/Layouts/Screen/ANNScreenSettling.h

@@ -0,0 +1,32 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Posted on the main queue when the screens' geometry has settled: each screen sends its insets, padding and regions
+/// once.
+extern NSNotificationName const ANNScreenSettlingDidEndNotification;
+
+/// iPhone Duo (iOS 27.1) folds and unfolds in steps: around the size transition, UIKit gives the views safe areas and a
+/// vertical bar edge that are neither the old nor the new ones (the bar on the other side, insets on both sides,
+/// twice its width) and tells of the bar's edge and of the safe area at other moments. While the geometry settles the
+/// screens lay out as always but send nothing to JavaScript: the settling ends once the transition is over and the
+/// values of the screens have stood still for a short while, and the screens send what they have then. Only on a
+/// device with a hinge: elsewhere a rotation gives the new safe area at once, and it goes at once. Main queue.
+@interface ANNScreenSettling : NSObject
+
+/// A size transition starts: the settling runs at least until it ends.
++ (void)beginWithTransition:(id<UIViewControllerTransitionCoordinator>)coordinator;
+
+/// The vertical bar's edge changed: the size transition, when one follows, comes a little later. The hinge's moves
+/// begin the settling too (`ANNHingeDidMoveNotification`): UIKit may give a new safe area before either.
++ (void)beginForTraitChange;
+
+/// Whether the screens hold their insets now.
++ (BOOL)isSettling;
+
+/// A screen's values changed while settling: the quiet time starts again.
++ (void)valuesDidChange;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Screen/ANNScreenSettling.mm

@@ -0,0 +1,137 @@
+#import "ANNScreenSettling.h"
+#import "ANNEventContract.h"
+#import "ANNHinge.h"
+#import <QuartzCore/QuartzCore.h>
+
+NSNotificationName const ANNScreenSettlingDidEndNotification = @"ANNScreenSettlingDidEnd";
+
+// How long the values of the screens stand still before the settling ends. On iPhone Duo UIKit's last step of a fold
+// comes some 30 ms after the size transition's end, and the size transition some 50 ms after the bar's new edge.
+static const CFTimeInterval ANNScreenSettlingQuietTime = 0.15;
+// The settling holds the insets no longer than this after its last start, whatever keeps changing.
+static const CFTimeInterval ANNScreenSettlingLongest = 1.0;
+// The degrees the hinge turns before it counts as a move: a device held half open trembles a little.
+static const double ANNScreenSettlingHingeStep = 2;
+
+static BOOL ANNSettling;
+// The size transitions that began and haven't ended: each screen counts its own call of the same transition.
+static NSInteger ANNSettlingTransitions;
+static CFTimeInterval ANNSettlingStart;
+static CFTimeInterval ANNSettlingLastChange;
+// Only the check scheduled last runs.
+static NSUInteger ANNSettlingCheckGeneration;
+// One more at each end: a transition that began before it no longer counts.
+static NSUInteger ANNSettlingEpoch;
+// The hinge's state and angle at its first value and at its last move that counted; none without a hinge.
+static id ANNSettlingHingeState;
+static NSNumber *ANNSettlingHingeAngle;
+
+@implementation ANNScreenSettling
+
+// The screens ask `isSettling` from their first layout on, before any fold.
++ (void)initialize {
+    if (self == ANNScreenSettling.class) {
+        [NSNotificationCenter.defaultCenter addObserver:self
+                                               selector:@selector(hingeDidMove:)
+                                                   name:ANNHingeDidMoveNotification
+                                                 object:nil];
+    }
+}
+
+// A fold starts with the hinge, and the display it shows on changes as it moves.
++ (void)hingeDidMove:(NSNotification *)notification {
+    NSDictionary<NSString *, id> *value = [ANNHinge lastValue];
+    const auto &keys = ANNEventContract.HingeChanged;
+    id state = value[keys.state];
+    NSNumber *angle = value[keys.angle];
+    // The first value, and the hinge's coming or going, are no move.
+    if (!state || !ANNSettlingHingeState) {
+        ANNSettlingHingeState = state;
+        ANNSettlingHingeAngle = angle;
+        return;
+    }
+    double turned = fabs(angle.doubleValue - ANNSettlingHingeAngle.doubleValue);
+    BOOL moved = ![state isEqual:ANNSettlingHingeState] || !angle || !ANNSettlingHingeAngle ||
+                 turned >= ANNScreenSettlingHingeStep;
+    if (!moved) {
+        return;
+    }
+    ANNSettlingHingeState = state;
+    ANNSettlingHingeAngle = angle;
+    [self beginForTraitChange];
+}
+
++ (void)beginWithTransition:(id<UIViewControllerTransitionCoordinator>)coordinator {
+    if (![ANNHinge isPresent]) {
+        return;
+    }
+    [self begin];
+    ANNSettlingTransitions += 1;
+    NSUInteger epoch = ANNSettlingEpoch;
+    void (^ended)(id<UIViewControllerTransitionCoordinatorContext>) =
+        ^(id<UIViewControllerTransitionCoordinatorContext> context) {
+          if (epoch != ANNSettlingEpoch) {
+              return;
+          }
+          ANNSettlingTransitions = MAX(0, ANNSettlingTransitions - 1);
+          [ANNScreenSettling valuesDidChange];
+          [ANNScreenSettling checkAfter:ANNScreenSettlingQuietTime];
+        };
+    [coordinator animateAlongsideTransition:nil completion:ended];
+    // The longest still holds should the transition's end never come.
+    [self checkAfter:ANNScreenSettlingLongest];
+}
+
+// Only iPhone Duo has a vertical bar: no need to ask for the hinge.
++ (void)beginForTraitChange {
+    [self begin];
+    [self checkAfter:ANNScreenSettlingQuietTime];
+}
+
++ (void)begin {
+    CFTimeInterval now = CACurrentMediaTime();
+    ANNSettling = YES;
+    ANNSettlingStart = now;
+    ANNSettlingLastChange = now;
+}
+
++ (BOOL)isSettling {
+    return ANNSettling;
+}
+
++ (void)valuesDidChange {
+    ANNSettlingLastChange = CACurrentMediaTime();
+}
+
++ (void)checkAfter:(CFTimeInterval)delay {
+    NSUInteger generation = ++ANNSettlingCheckGeneration;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     if (generation == ANNSettlingCheckGeneration) {
+                         [ANNScreenSettling check];
+                     }
+                   });
+}
+
+// Ends once no transition runs and the values stood still for the quiet time, or at the longest; else looks again
+// when that can be the case. A change since the check was scheduled moves the end on.
++ (void)check {
+    if (!ANNSettling) {
+        return;
+    }
+    CFTimeInterval now = CACurrentMediaTime();
+    CFTimeInterval longest = ANNSettlingStart + ANNScreenSettlingLongest;
+    CFTimeInterval quiet = ANNSettlingLastChange + ANNScreenSettlingQuietTime;
+    if (now >= longest || (ANNSettlingTransitions == 0 && now >= quiet)) {
+        ANNSettling = NO;
+        ANNSettlingTransitions = 0;
+        ANNSettlingEpoch += 1;
+        [NSNotificationCenter.defaultCenter postNotificationName:ANNScreenSettlingDidEndNotification
+                                                          object:nil];
+        return;
+    }
+    CFTimeInterval next = ANNSettlingTransitions > 0 ? longest : MIN(quiet, longest);
+    [self checkAfter:next - now];
+}
+
+@end

package/ios/Layouts/SideMenu/ANNSideMenuTypes.h

@@ -12,6 +12,14 @@ typedef NS_ENUM(NSInteger, ANNSideMenuOpenMode) {
     ANNSideMenuOpenModeAboveContent,
 };
 
+/** `sideMenu.menusAttachMode`: when the screens of the menus are made, with the side menu, after its first
+ * appearance, or each as it first starts to open. */
+typedef NS_ENUM(NSInteger, ANNSideMenuAttachMode) {
+    ANNSideMenuAttachModeTogether,
+    ANNSideMenuAttachModeAfterCenter,
+    ANNSideMenuAttachModeOnOpen,
+};
+
 /** `sideMenu.openGestureMode`: a pan from anywhere on the center, or from its edges only. */
 typedef NS_ENUM(NSInteger, ANNSideMenuOpenGestureMode) {
     ANNSideMenuOpenGestureModeEntireScreen,

package/ios/Layouts/SideMenu/ANNSideMenuViewController.mm

@@ -12,6 +12,24 @@ static const CGFloat ANNSideMenuDimAlpha = 0.5;
 static const CGFloat ANNSideMenuMaxStretch = 1.1;
 static const NSTimeInterval ANNSideMenuMinimumDuration = 0.1;
 
+// `sideMenu.menusAttachMode` of the side menu's own options, else of the defaults; any other value, and none, is
+// `together`.
+static ANNSideMenuAttachMode ANNSideMenuAttachModeOf(ANNNavigationOptions *options,
+                                                     ANNNavigationOptions *defaultOptions) {
+    Text *value = options.sideMenu.menusAttachMode;
+    if (!value.hasValue) {
+        value = defaultOptions.sideMenu.menusAttachMode;
+    }
+    NSString *mode = [value withDefault:nil];
+    if ([mode isEqualToString:@"afterCenter"]) {
+        return ANNSideMenuAttachModeAfterCenter;
+    }
+    if ([mode isEqualToString:@"onOpen"]) {
+        return ANNSideMenuAttachModeOnOpen;
+    }
+    return ANNSideMenuAttachModeTogether;
+}
+
 static UINavigationController *ANNStackOfResponder(UIResponder *responder) {
     for (; responder; responder = responder.nextResponder) {
         if ([responder isKindOfClass:UINavigationController.class]) {
@@ -65,6 +83,8 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
 @property(nonatomic) BOOL glass;
 @property(nonatomic) ANNSideMenuAppearance appearance;
 @property(nonatomic, copy) NSString *scrimTestID;
+// The menu's part is in its container and renders (`menusAttachMode`).
+@property(nonatomic) BOOL attached;
 @end
 
 @implementation ANNSideMenuSideState
@@ -95,6 +115,8 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     ANNSideMenuSideState *_leftState;
     ANNSideMenuSideState *_rightState;
     ANNSideMenuOpenGestureMode _openGestureMode;
+    ANNSideMenuAttachMode _attachMode;
+    BOOL _firstAppeared;
     NSString *_animationType;
     UIView *_centerContainer;
     UIView *_leftContainer;
@@ -132,6 +154,7 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     _leftState = [ANNSideMenuSideState new];
     _rightState = [ANNSideMenuSideState new];
     _openGestureMode = ANNSideMenuOpenGestureModeBezel;
+    _attachMode = ANNSideMenuAttachModeOf(options, defaultOptions);
     [self setSideMenuChildren:childViewControllers];
 
     self.presenter = presenter;
@@ -181,10 +204,15 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
 
 - (void)viewDidLoad {
     [super viewDidLoad];
-    _leftContainer = [self containerForChild:self.left];
-    _rightContainer = [self containerForChild:self.right];
-    _centerContainer = [self containerForChild:self.center];
+    _leftContainer = [self makeContainer];
+    _rightContainer = [self makeContainer];
+    _centerContainer = [self makeContainer];
+    [self putChild:self.center into:_centerContainer];
     _centerContainer.hidden = NO;
+    if (_attachMode == ANNSideMenuAttachModeTogether) {
+        [self attachMenu:ANNSideMenuSideLeft];
+        [self attachMenu:ANNSideMenuSideRight];
+    }
     [self applyGlassOf:ANNSideMenuSideLeft];
     [self applyGlassOf:ANNSideMenuSideRight];
 
@@ -200,32 +228,65 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     [self.view addGestureRecognizer:_pan];
 }
 
-// A child in a view of its own, which the menu moves; a menu's container is hidden while closed.
-- (UIView *)containerForChild:(UIViewController *)child {
+// The view of a part, which the menu moves; a menu's container is hidden while closed.
+- (UIView *)makeContainer {
     UIView *container = [[UIView alloc] initWithFrame:self.view.bounds];
     container.hidden = YES;
     [self.view addSubview:container];
-    if (child) {
-        [self addChildViewController:child];
-        child.view.frame = container.bounds;
-        child.view.autoresizingMask =
-            UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-        [container addSubview:child.view];
-        [child didMoveToParentViewController:self];
-    }
     return container;
 }
 
+// A part in its container, over the container's glass. Loading the part's view loads its node's, which renders.
+- (void)putChild:(UIViewController *)child into:(UIView *)container {
+    if (!child) {
+        return;
+    }
+    [self addChildViewController:child];
+    child.view.frame = container.bounds;
+    child.view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    [container addSubview:child.view];
+    [child didMoveToParentViewController:self];
+}
+
+// The menu's part goes into its container and renders, once: with the side menu's view (`together`), after its first
+// appearance (`afterCenter`), or as the menu first starts to open (`onOpen`, and any mode for a menu that opens
+// earlier). A menu not attached yet keeps its node and options; only its view and content wait.
+- (void)attachMenu:(ANNSideMenuSide)side {
+    ANNSideMenuChildViewController *menu = [self menuOf:side];
+    if (!menu || [self stateOf:side].attached || self.nodeHelper.destroyed) {
+        return;
+    }
+    [self loadViewIfNeeded];
+    ANNSideMenuSideState *state = [self stateOf:side];
+    if (state.attached) {
+        return;
+    }
+    state.attached = YES;
+    [self putChild:menu into:[self containerOf:side]];
+    [menu render];
+}
+
+// The current part renders, and every other part that is attached or will be with the side menu's view.
 - (void)render {
     [self.nodeHelper render];
     UIViewController *currentChild = self.getCurrentChild;
     for (UIViewController *vc in _sideMenuChildren) {
-        if (vc != currentChild) {
+        if (vc != currentChild && [self rendersPart:vc]) {
             [vc render];
         }
     }
 }
 
+- (BOOL)rendersPart:(UIViewController *)part {
+    if (part == self.left) {
+        return _attachMode == ANNSideMenuAttachModeTogether || _leftState.attached;
+    }
+    if (part == self.right) {
+        return _attachMode == ANNSideMenuAttachModeTogether || _rightState.attached;
+    }
+    return YES;
+}
+
 #pragma mark - Options
 
 - (ANNSideMenuSideState *)stateOf:(ANNSideMenuSide)side {
@@ -380,6 +441,7 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
 
 // The menu on screen in its place under or over the center, its screens about to appear.
 - (void)show:(ANNSideMenuSide)side {
+    [self attachMenu:side];
     _side = side;
     [self orderSide:side];
     [self containerOf:side].hidden = NO;
@@ -586,6 +648,13 @@ typedef NS_ENUM(NSInteger, ANNSideMenuAppearance) {
     if (_side != ANNSideMenuSideNone) {
         [self side:_side transitionEnded:YES];
     }
+    if (!_firstAppeared) {
+        _firstAppeared = YES;
+        if (_attachMode == ANNSideMenuAttachModeAfterCenter) {
+            [self attachMenu:ANNSideMenuSideLeft];
+            [self attachMenu:ANNSideMenuSideRight];
+        }
+    }
 }
 
 - (void)viewWillDisappear:(BOOL)animated {

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

@@ -1,5 +1,6 @@
 #import "ANNSplitViewController.h"
 #import "ANNErrorHandler.h"
+#import "ANNErrorTexts.h"
 #import "ANNShownScreens.h"
 #import "UISplitViewController+ANNOptions.h"
 #import "UIViewController+LayoutProtocol.h"
@@ -213,23 +214,21 @@ static UISplitViewControllerColumn ANNSplitViewColumn(NSString *name) {
             completion:(ANNTransitionCompletionBlock)completion
              rejection:(ANNTransitionRejectionBlock)rejection {
     UIViewController *previous = _columns[column];
+    NSString *fromId = fromViewController.layoutInfo.componentId ?: @"";
     if (!previous) {
-        rejection([NSString stringWithFormat:@"the split view of the screen '%@' has no '%@' column",
-                                             fromViewController.layoutInfo.componentId, column],
-                  nil);
+        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([NSString stringWithFormat:@"the '%@' column of the split view of the screen '%@' is a "
-                                                 @"stack: it takes a screen, not a stack",
-                                                 column, fromViewController.layoutInfo.componentId],
-                      nil);
+            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:^{