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

package/ios/Layouts/Arrangement/ANNArrangementState.mm

@@ -1,16 +1,8 @@
 #import "ANNArrangementState.h"
 #import "ANNArrangementViewController.h"
 
-static NSMutableDictionary<NSString *, NSDictionary<NSString *, id> *> *ANNArrangementStateById;
-
 @implementation ANNArrangementState
 
-+ (void)initialize {
-    if (self == ANNArrangementState.class) {
-        ANNArrangementStateById = [NSMutableDictionary new];
-    }
-}
-
 + (BOOL)canShowArrangements {
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
     if (@available(iOS 27.1, *)) {
@@ -20,34 +12,4 @@ static NSMutableDictionary<NSString *, NSDictionary<NSString *, id> *> *ANNArran
     return NO;
 }
 
-+ (void)setState:(NSDictionary<NSString *, id> *)state
-     forScreenId:(NSString *)screenId
-    eventEmitter:(ANNEventEmitter *)eventEmitter {
-    @synchronized(ANNArrangementStateById) {
-        if ([ANNArrangementStateById[screenId] isEqualToDictionary:state]) {
-            return;
-        }
-        ANNArrangementStateById[screenId] = state;
-    }
-    [eventEmitter sendArrangementChanged:screenId state:state];
-}
-
-+ (NSDictionary<NSString *, id> *)stateForScreenId:(NSString *)screenId {
-    @synchronized(ANNArrangementStateById) {
-        return ANNArrangementStateById[screenId];
-    }
-}
-
-+ (void)removeScreenId:(NSString *)screenId {
-    @synchronized(ANNArrangementStateById) {
-        [ANNArrangementStateById removeObjectForKey:screenId];
-    }
-}
-
-+ (void)removeAll {
-    @synchronized(ANNArrangementStateById) {
-        [ANNArrangementStateById removeAllObjects];
-    }
-}
-
 @end

package/ios/Layouts/Arrangement/ANNArrangementViewController.mm

@@ -2,9 +2,10 @@
 
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
 
-#import "ANNArrangementState.h"
 #import "ANNComponentViewController.h"
+#import "ANNEventContract.h"
 #import "ANNExternalViewController.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNShownScreens.h"
 #import "ANNUtils.h"
 
@@ -130,11 +131,12 @@ static BOOL ANNKeepsState(UIViewController *screen) {
 
 static NSDictionary<NSString *, id> *ANNStateOf(NSString *placement, NSString *layout, BOOL front,
                                                 BOOL hidden) {
+    const auto &keys = ANNEventContract.ArrangementChanged;
     return @{
-        @"placement" : placement,
-        @"layout" : layout,
-        @"front" : @(front),
-        @"hidden" : @(hidden),
+        keys.placement : placement,
+        keys.layout : layout,
+        keys.front : @(front),
+        keys.hidden : @(hidden),
     };
 }
 
@@ -296,9 +298,9 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
          ofScreen:(UIViewController *)screen
      eventEmitter:(ANNEventEmitter *)eventEmitter {
     if (ANNKeepsState(screen)) {
-        [ANNArrangementState setState:state
-                          forScreenId:screen.layoutInfo.componentId
-                         eventEmitter:eventEmitter];
+        [ANNScreenEnvironment setArrangement:state
+                                 forScreenId:screen.layoutInfo.componentId
+                                eventEmitter:eventEmitter];
     }
 }
 

package/ios/Layouts/Modal/ANNModalCoordinator.h

@@ -25,7 +25,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `dismissModal`: the record of `componentId` (its root's id or any id inside, also of a modal closed below or by the
 /// user), the options merged into its visible screen, the animation from the command's screen, then its state decides.
-/// Answers with the root's id.
+/// Answers with the root's id. The last modal over no root rejects `[ANNErrorTexts modalWithoutRoot:]`, as on Android.
 + (void)dismissModal:(NSString *)componentId
              options:(nullable NSDictionary *)options
               answer:(ANNCommandAnswer *)answer;

package/ios/Layouts/Modal/ANNModalCoordinator.mm

@@ -233,7 +233,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
                   limit:contentFirst ? 0 : ANNModalRenderLimit
                     bar:contentFirst ? ANNRenderWaitBarAfterContent : ANNRenderWaitBarWithContent
               barLimits:contentFirst ? ownPhase : withContent];
-    wait.mountLimit = ANNModalRenderLimit;
+    wait.unseenLimit = ANNModalRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNModalCoordinator protect:weakModal step:step];
     };
@@ -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];
         }
     }
 }
@@ -407,7 +426,7 @@ static void ANNCollectIds(UIViewController *node, NSMutableSet<NSString *> *ids)
         ANNNavigationOptions *resolved = [root resolveOptionsWithDefault];
         ANNModalPresentation *presentation =
             [[ANNModalPresentation alloc] initWithOptions:resolved animated:modal.animatedOverride];
-        NSString *problem = [presentation problemPresentingFrom:presenting windowRoot:windowRoot];
+        NSString *problem = [presentation fitToPresenting:presenting windowRoot:windowRoot];
         if (problem) {
             [self failShowOf:modal reason:problem];
             done();
@@ -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/Modal/ANNModalPresentation.h

@@ -20,7 +20,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// `modalPresentationStyle`: one to one; unset is UIKit's automatic style; an unknown string full screen.
 @property(nonatomic, readonly) UIModalPresentationStyle style;
-/// `modalTransitionStyle`: `coverVertical` unless one of the others is given.
+/// `modalTransitionStyle`: `coverVertical` unless one of the others is given; `partialCurl` only where UIKit curls
+/// (`fitToPresenting:windowRoot:`).
 @property(nonatomic, readonly) UIModalTransitionStyle transitionStyle;
 /// The present is animated: `enter.enabled` is not `false`.
 @property(nonatomic, readonly) BOOL animated;
@@ -47,10 +48,12 @@ NS_ASSUME_NONNULL_BEGIN
                                     animation:(nullable ANNModalAnimationOptions *)animation
                                         under:(nullable UIViewController *)under;
 
-/// Why UIKit can't make this show from `presenting` (`partialCurl` only full screen, to and from), as the reason of the
-/// rejection; nil when it can. `windowRoot` is the main window's root.
-- (nullable NSString *)problemPresentingFrom:(UIViewController *)presenting
-                                  windowRoot:(nullable UIViewController *)windowRoot;
+/// Fits the show to `presenting`, before `prepare:…`: `partialCurl` stays only for a full-screen modal over a
+/// controller that fills the screen (`presenting` is `windowRoot`, the main window's root, or a full-screen modal);
+/// otherwise `transitionStyle` becomes `coverVertical`. Returns why UIKit can't make the show (`presenting` was shown
+/// with `partialCurl`), as the reason of the rejection; nil when it can.
+- (nullable NSString *)fitToPresenting:(UIViewController *)presenting
+                            windowRoot:(nullable UIViewController *)windowRoot;
 
 /// Before `presentViewController:`: the style and the transition, the presentation's delegate, the popover kept a
 /// popover (`adaptive: false`), the sheet, the size, the popover's source on `presentingLayout`, the hold, the

package/ios/Layouts/Modal/ANNModalPresentation.mm

@@ -118,21 +118,21 @@ static NSDictionary<NSString *, NSNumber *> *ANNTransitionStyles(void) {
     return nil;
 }
 
-// UIKit takes `partialCurl` only for a full-screen modal over a controller that fills the screen, and a controller
-// shown with `partialCurl` presents nothing more: the command rejects before it asks UIKit.
-- (NSString *)problemPresentingFrom:(UIViewController *)presenting
-                         windowRoot:(UIViewController *)windowRoot {
+// UIKit curls only a full-screen modal over a controller that fills the screen: elsewhere `partialCurl` is
+// `coverVertical`, so the modal still shows. A controller shown with `partialCurl` presents nothing more: the command
+// rejects before it asks UIKit.
+- (NSString *)fitToPresenting:(UIViewController *)presenting
+                   windowRoot:(UIViewController *)windowRoot {
     if (presenting.presentingViewController &&
         presenting.modalTransitionStyle == UIModalTransitionStylePartialCurl) {
-        return @"partialCurl needs a full screen modal";
+        return @"a modal shown with partialCurl can't show another modal";
     }
-    if (_transitionStyle != UIModalTransitionStylePartialCurl) {
-        return nil;
-    }
-    BOOL presentingFills = presenting == windowRoot ||
-                           presenting.modalPresentationStyle == UIModalPresentationFullScreen;
-    if (_style != UIModalPresentationFullScreen || !presentingFills) {
-        return @"partialCurl needs a full screen modal";
+    if (_transitionStyle == UIModalTransitionStylePartialCurl) {
+        BOOL presentingFills = presenting == windowRoot ||
+                               presenting.modalPresentationStyle == UIModalPresentationFullScreen;
+        if (_style != UIModalPresentationFullScreen || !presentingFills) {
+            _transitionStyle = UIModalTransitionStyleCoverVertical;
+        }
     }
     return nil;
 }

package/ios/Layouts/Modal/ANNSheetPresenter.mm

@@ -1,6 +1,7 @@
 #import "ANNSheetPresenter.h"
 #import "ANNModalSizePresenter.h"
 #import "ANNReactView.h"
+#import "ANNUtils.h"
 #import "UIViewController+LayoutProtocol.h"
 #import <React/RCTLog.h>
 #import <objc/runtime.h>
@@ -53,7 +54,7 @@ static NSString *const ANNContentDetent = @"content";
 + (void)applyOptions:(ANNSheetOptions *)options toSheet:(UISheetPresentationController *)sheet {
     if (options.detents) {
         NSMutableArray<UISheetPresentationControllerDetent *> *detents = [NSMutableArray new];
-        for (id value in options.detents) {
+        for (id value in [self sortedDetents:options.detents ofSheet:sheet]) {
             UISheetPresentationControllerDetent *detent = [self detentFor:value ofSheet:sheet];
             if (detent) {
                 [detents addObject:detent];
@@ -81,6 +82,85 @@ static NSString *const ANNContentDetent = @"content";
     }
 }
 
+// UIKit wants the detents once each, from the lowest to the highest: it takes the last for the largest and closes the
+// sheet on a drag down from the first. The options may give them in any order and more than once; the first of a
+// repeat stays, and detents of the same height keep their order.
++ (NSArray *)sortedDetents:(NSArray *)values ofSheet:(UISheetPresentationController *)sheet {
+    NSMutableArray *detents = [NSMutableArray new];
+    NSMutableSet<NSString *> *identifiers = [NSMutableSet new];
+    for (id value in values) {
+        NSString *identifier = [self identifierFor:value];
+        if (identifier && ![identifiers containsObject:identifier]) {
+            [identifiers addObject:identifier];
+            [detents addObject:value];
+        }
+    }
+    CGFloat maximum = [self maximumDetentHeightOf:sheet];
+    return [detents sortedArrayWithOptions:NSSortStable
+                           usingComparator:^NSComparisonResult(id a, id b) {
+                             return [self compareHeightOf:a
+                                                     with:b
+                                                  maximum:maximum
+                                                  ofSheet:sheet];
+                           }];
+}
+
+// The content of a sheet sized to it changed its height, and with it maybe its place among the other detents.
++ (void)sortDetentsOfSheet:(UISheetPresentationController *)sheet API_AVAILABLE(ios(16.0)) {
+    CGFloat maximum = [self maximumDetentHeightOf:sheet];
+    NSArray<UISheetPresentationControllerDetent *> *detents = sheet.detents;
+    NSArray<UISheetPresentationControllerDetent *> *sorted = [detents
+        sortedArrayWithOptions:NSSortStable
+               usingComparator:^NSComparisonResult(UISheetPresentationControllerDetent *a,
+                                                   UISheetPresentationControllerDetent *b) {
+                 return [self compareHeightOf:[self detentForIdentifier:a.identifier]
+                                         with:[self detentForIdentifier:b.identifier]
+                                      maximum:maximum
+                                      ofSheet:sheet];
+               }];
+    if (![sorted isEqualToArray:detents]) {
+        sheet.detents = sorted;
+    }
+}
+
++ (NSComparisonResult)compareHeightOf:(id)a
+                                 with:(id)b
+                              maximum:(CGFloat)maximum
+                              ofSheet:(UISheetPresentationController *)sheet {
+    CGFloat heightA = [self heightOf:a maximum:maximum ofSheet:sheet];
+    CGFloat heightB = [self heightOf:b maximum:maximum ofSheet:sheet];
+    return heightA < heightB ? NSOrderedAscending
+                             : heightA > heightB ? NSOrderedDescending : NSOrderedSame;
+}
+
+// The height a detent of the options stands at, to sort them, as its resolver gives it: 'medium' half of the largest
+// height (UIKit's is about half), 'large' all of it, a height capped at it, 'content' the content's height now, all of
+// it while the content isn't measured.
++ (CGFloat)heightOf:(id)value
+            maximum:(CGFloat)maximum
+            ofSheet:(UISheetPresentationController *)sheet {
+    if ([value isEqual:@"medium"]) {
+        return maximum / 2;
+    }
+    if ([value isKindOfClass:NSNumber.class]) {
+        return MIN([value doubleValue], maximum);
+    }
+    if ([value isEqual:ANNContentDetent]) {
+        CGFloat height = [self contentHeightOf:sheet.presentedViewController];
+        return height > 0 ? MIN(height, maximum) : maximum;
+    }
+    return maximum;
+}
+
+// About the largest height of a sheet: its container, or the window before it is shown, below the top safe area.
++ (CGFloat)maximumDetentHeightOf:(UISheetPresentationController *)sheet {
+    UIView *view = sheet.containerView ?: ANNUtils.mainWindow;
+    if (!view) {
+        return ANNUtils.mainScreen.bounds.size.height;
+    }
+    return view.bounds.size.height - view.safeAreaInsets.top;
+}
+
 + (UISheetPresentationControllerDetent *)detentFor:(id)value
                                            ofSheet:(UISheetPresentationController *)sheet {
     if ([value isEqual:@"medium"]) {
@@ -180,6 +260,7 @@ static NSString *const ANNContentDetent = @"content";
               }
               height = newHeight;
               [strongSheet animateChanges:^{
+                [self sortDetentsOfSheet:strongSheet];
                 [strongSheet invalidateDetents];
               }];
             }
@@ -201,6 +282,7 @@ static NSString *const ANNContentDetent = @"content";
             // The new screen's content mounts may come later: its mounts resolve the detents again too.
             [self followContentOfSheet:sheet when:YES];
             [sheet animateChanges:^{
+              [self sortDetentsOfSheet:sheet];
               [sheet invalidateDetents];
             }];
         }

package/ios/Layouts/Overlay/ANNOverlayCoordinator.mm

@@ -179,7 +179,7 @@ static NSMutableArray<ANNOverlay *> *ANNOverlays;
                   limit:ANNOverlayRenderLimit
                     bar:ANNRenderWaitBarWithContent
               barLimits:withContent];
-    wait.mountLimit = ANNOverlayRenderLimit;
+    wait.unseenLimit = ANNOverlayRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNOverlayCoordinator protectWaitOf:weakOverlay step:step];
     };
@@ -238,13 +238,7 @@ static NSMutableArray<ANNOverlay *> *ANNOverlays;
                 [self dismiss:shown answer:nil];
             }
         }
-        UIWindow *mainWindow = ApexNavigation.mainWindow;
-        UIWindowScene *scene = mainWindow.windowScene;
-        // `initWithFrame:` is deprecated from iOS 26 on and warns only with a deployment target from 26: a window
-        // without a scene is made so, and joins the scene as the main window gets it.
-        ANNOverlayWindow *window =
-            scene ? [[ANNOverlayWindow alloc] initWithWindowScene:scene]
-                  : [[ANNOverlayWindow alloc] initWithFrame:ANNUtils.mainScreen.bounds];
+        ANNOverlayWindow *window = [ANNUtils makeWindowOfClass:ANNOverlayWindow.class];
         window.windowLevel = UIWindowLevelNormal;
         window.backgroundColor = UIColor.clearColor;
         window.previousWindow = [self keyWindow];

package/ios/Layouts/Root/ANNRootCoordinator.mm

@@ -69,7 +69,10 @@ typedef NS_ENUM(NSInteger, ANNRootShowState) {
 // The nodes whose appearance the transition reports itself (`driveAppearanceOf:`), while `driving`.
 @property(nonatomic, copy) NSArray<UIViewController *> *driven;
 @property(nonatomic) BOOL driving;
+// The snapshot of the window as it was: it dissolves over the new root (`dissolves`), plays its `exit` (`custom`), or
+// only covers the old root's modals while they go, and leaves as the new root is the window's.
 @property(nonatomic, strong, nullable) UIView *snapshot;
+@property(nonatomic) BOOL dissolves;
 // The root is the window's root: the old root's modals went before it (`startTransitionOf:done:`).
 @property(nonatomic) BOOL installed;
 // The root's view waits in the window under the current root (`park:`).
@@ -80,6 +83,10 @@ typedef NS_ENUM(NSInteger, ANNRootShowState) {
 @property(nonatomic, strong, nullable) ANNFrameDriver *driver;
 @property(nonatomic, copy, nullable) NSArray<ANNViewTracks *> *tracks;
 @property(nonatomic) BOOL animating;
+// The new root's view takes no touches while it animates, and whether it took them before: Core Animation draws it
+// elsewhere than where it is (the view itself stays in place), so a tap on the old screen would reach it.
+@property(nonatomic, weak, nullable) UIView *untouchableRoot;
+@property(nonatomic) BOOL rootTouchesBefore;
 @property(nonatomic) BOOL layersShown;
 @end
 
@@ -293,7 +300,7 @@ static __weak ANNRootShow *ANNAnimatingShow;
               barLimits:contentFirst ? ownPhase : withContent];
     // A screen the user won't see at once (an unselected tab's) never holds the root longer than the limit, also with
     // `waitForRender: true`.
-    wait.mountLimit = ANNRootRenderLimit;
+    wait.unseenLimit = ANNRootRenderLimit;
     wait.protect = ^(dispatch_block_t step) {
       [ANNRootCoordinator protect:weakShow step:step];
     };
@@ -415,9 +422,14 @@ static __weak ANNRootShow *ANNAnimatingShow;
     BOOL seen = !window.hidden && scene != nil &&
                 scene.activationState != UISceneActivationStateBackground;
     BOOL dissolves = !overSplash && !enterDisabled && !custom && seen;
+    show.dissolves = dissolves;
     show.custom = custom && seen;
-    UIView *snapshot =
-        dissolves || show.custom ? [window snapshotViewAfterScreenUpdates:NO] : nil;
+    // UIKit draws the dismissal of the old root's modals, without animation too (a sheet's dim goes a frame before
+    // its card): with nothing to dissolve, the snapshot covers them until the new root is in place.
+    BOOL covers = seen && old.presentedViewController != nil;
+    UIView *snapshot = dissolves || show.custom || covers
+                           ? [window snapshotViewAfterScreenUpdates:NO]
+                           : nil;
 
     show.state = ANNRootShowStateTransition;
     // It shows from here: a stack in it counts as on screen.
@@ -480,7 +492,8 @@ static __weak ANNRootShow *ANNAnimatingShow;
         [self endTransitionOf:show];
         return;
     }
-    if (!snapshot) {
+    // A snapshot that only covered the old root's modals leaves in this turn, with the new root in place under it.
+    if (!snapshot || !show.dissolves) {
         [self endTransitionOf:show];
         return;
     }
@@ -524,20 +537,43 @@ static __weak ANNRootShow *ANNAnimatingShow;
     NSMutableArray<ANNViewTracks *> *tracks = [NSMutableArray new];
     ANNViewAnimationOptions *enter = [ANNAnimationRules playingSide:animation.enter];
     ANNViewAnimationOptions *exit = [ANNAnimationRules playingSide:animation.exit];
-    if (enter && rootView) {
-        [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
-                                                         side:enter
-                                                  alphaBefore:rootView.alpha]];
-    }
-    if (exit && snapshot) {
-        [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
-                                                         side:exit
-                                                  alphaBefore:snapshot.alpha]];
-    }
     NSTimeInterval length =
         MAX([ANNAnimationRules lengthOfSide:enter], [ANNAnimationRules lengthOfSide:exit]);
+    if (UIAccessibilityIsReduceMotionEnabled() && length > 0) {
+        // With the system's Reduce Motion on, nothing moves: the new root fades in over the snapshot in the same
+        // length, or the snapshot fades out without a new root's view.
+        if (rootView) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
+                                                         fadeFrom:0
+                                                               to:rootView.alpha
+                                                         duration:length
+                                                      alphaBefore:rootView.alpha]];
+        } else if (snapshot) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
+                                                         fadeFrom:snapshot.alpha
+                                                               to:0
+                                                         duration:length
+                                                      alphaBefore:snapshot.alpha]];
+        }
+    } else {
+        if (enter && rootView) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
+                                                             side:enter
+                                                      alphaBefore:rootView.alpha]];
+        }
+        if (exit && snapshot) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
+                                                             side:exit
+                                                      alphaBefore:snapshot.alpha]];
+        }
+    }
     show.tracks = tracks;
     show.animating = YES;
+    if (rootView) {
+        show.untouchableRoot = rootView;
+        show.rootTouchesBefore = rootView.userInteractionEnabled;
+        rootView.userInteractionEnabled = NO;
+    }
     ANNAnimatingShow = show;
     show.driver = [[ANNFrameDriver alloc] initWithClients:tracks length:length];
     // The layers' state from here on: the chain may start and a newer `setRoot` stops it.
@@ -574,8 +610,8 @@ static __weak ANNRootShow *ANNAnimatingShow;
     [self finishLayersOf:show];
 }
 
-// The animation stops at its end state (its end, a newer `setRoot`, a reload, a failure): the views get back what they
-// had and the snapshot goes.
+// The animation stops (its end, a newer `setRoot`, a reload, a failure): its animations go, the views get back what
+// they had and the snapshot goes.
 + (void)stopAnimationOf:(ANNRootShow *)show {
     if (!show.animating) {
         return;
@@ -583,13 +619,16 @@ static __weak ANNRootShow *ANNAnimatingShow;
     show.animating = NO;
     [show.driver cancel];
     show.driver = nil;
+    show.untouchableRoot.userInteractionEnabled = show.rootTouchesBefore;
+    show.untouchableRoot = nil;
     for (ANNViewTracks *tracks in show.tracks) {
         [tracks restore];
     }
     show.tracks = nil;
-    // UIKit works out the safe area of the window's root view from where the view is drawn: moved away from the top
-    // edge by `enter` (from the bottom, scaled down) it has no top inset, and putting the transform back doesn't make
-    // UIKit work it out again. A layout now gives the root, its bars and its screens the window's safe area back.
+    // UIKit works out the safe area of the window's root view from where the view is: moved away from the top edge by
+    // a transform it has no top inset, and putting the transform back doesn't make UIKit work it out again. `enter`
+    // moves only what Core Animation draws now; the layout stays, so the root, its bars and its screens end with the
+    // window's safe area whatever moved them.
     UIView *rootView = show.root.viewIfLoaded;
     [rootView setNeedsLayout];
     [rootView layoutIfNeeded];

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