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

package/ios/TopBar/ANNBarButtons.mm

@@ -2,6 +2,7 @@
 #import "ANNBarButtonComponentView.h"
 #import "ANNIconButtonImage.h"
 #import "ANNShowTextButton.h"
+#import "ANNTabsDesign.h"
 #import "ANNUIBarButtonItem.h"
 #import "ANNUserChoice.h"
 #import "UIViewController+LayoutProtocol.h"
@@ -301,6 +302,27 @@ static BOOL ANNHasComponent(ANNButtonOptions *button) {
            [button.component.componentId withDefault:nil].length > 0;
 }
 
+// The image an icon loads, for telling builds apart (NSNull without one): a source of a file, data or Metro's server
+// loads through the shared cache, which gives the same image until the file at its path changes or a failed load
+// succeeds. An SF Symbol is the system's: its name in the options says it all.
+static id ANNLoadedImageOf(Image *icon) {
+    ANNImageSource *source = icon.source;
+    if (!icon.hasValue || (source && source.kind == ANNImageSourceKindSymbol)) {
+        return NSNull.null;
+    }
+    return [icon withDefault:nil] ?: NSNull.null;
+}
+
+// The images the items of a menu load (an item with `sfSymbol` shows the symbol), at any depth.
+static void ANNAddMenuImages(NSArray<ANNMenuItemOptions *> *items, NSMutableArray *loaded) {
+    for (ANNMenuItemOptions *item in items) {
+        if (!item.sfSymbol.hasValue) {
+            [loaded addObject:ANNLoadedImageOf(item.icon)];
+        }
+        ANNAddMenuImages(item.items, loaded);
+    }
+}
+
 // The image button's background: its own `iconBackground.color`, else (only for an image icon) the side's.
 static UIColor *ANNIconBackgroundOf(ANNButtonOptions *button, Color *sideBackground) {
     UIColor *own = ANNColorOf(button.iconBackground.color);
@@ -394,6 +416,60 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
 @implementation ANNButtonPress
 @end
 
+// The same objects, one by one: what a build read by identity (a loaded image, a React button's slot) and what it put
+// on the navigation item. A string (the item's customization id) by its value.
+static BOOL ANNSameObjects(NSArray *a, NSArray *b) {
+    if (a.count != b.count) {
+        return NO;
+    }
+    for (NSUInteger index = 0; index < a.count; index++) {
+        id mine = a[index];
+        id theirs = b[index];
+        if (mine != theirs && !([mine isKindOfClass:NSString.class] && [mine isEqual:theirs])) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+// Everything the build of one side reads: the side's buttons, its colors and the customization id of the middle by
+// value; the images it loads and the slots of its React buttons by identity (a file written again at its path loads as
+// another image, a reload gives other roots); the traits it builds under (a text button's font follows the text size,
+// a drawn image the scale and the style).
+@interface ANNSideInputs : NSObject
+@property(nonatomic, strong, nullable) NSArray<ANNButtonOptions *> *buttons;
+@property(nonatomic, strong, nullable) Color *color;
+@property(nonatomic, strong, nullable) Color *disabledColor;
+@property(nonatomic, strong, nullable) Color *background;
+@property(nonatomic, strong, nullable) Text *customizationId;
+@property(nonatomic, copy) NSArray *loaded;
+@property(nonatomic, copy) NSArray *traits;
+@end
+
+@implementation ANNSideInputs
+
+- (BOOL)isSameAs:(ANNSideInputs *)other {
+    return ANNOptionValuesSame(_buttons, other.buttons) &&
+           ANNOptionValuesSame(_color, other.color) &&
+           ANNOptionValuesSame(_disabledColor, other.disabledColor) &&
+           ANNOptionValuesSame(_background, other.background) &&
+           ANNOptionValuesSame(_customizationId, other.customizationId) &&
+           ANNSameObjects(_loaded, other.loaded) && [_traits isEqualToArray:other.traits];
+}
+
+@end
+
+// The last build of one side: what it read and what the navigation item held right after it.
+@interface ANNSideBuild : NSObject
+@property(nonatomic, strong) ANNSideInputs *inputs;
+// The side went in as groups (`leadingItemGroups`, …), not as a list of items.
+@property(nonatomic) BOOL grouped;
+@property(nonatomic, copy) NSArray *placed;
+@end
+
+@implementation ANNSideBuild
+@end
+
 @implementation ANNBarButtons {
     __weak UIViewController *_screen;
     ANNReactComponentRegistry *_registry;
@@ -402,6 +478,8 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     NSMutableDictionary<NSString *, NSNumber *> *_selected;
     // What a press of each sender (an item, a button of an item) means.
     NSMapTable<id, ANNButtonPress *> *_presses;
+    // The last build of each side, by the side.
+    NSMutableDictionary<NSNumber *, ANNSideBuild *> *_builds;
 }
 
 - (instancetype)initWithScreen:(UIViewController *)screen
@@ -412,12 +490,16 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         _slots = [NSMutableDictionary new];
         _selected = [NSMutableDictionary new];
         _presses = [NSMapTable weakToStrongObjectsMapTable];
+        _builds = [NSMutableDictionary new];
     }
     return self;
 }
 
 #pragma mark - The sides
 
+// From iOS 26 UIKit animates any change of the bar's items, also to equal ones and with `animated:NO`: new items on
+// each appearance would morph, close an open menu and drop a pressed state. So a side is built again only when what
+// its build reads changed, or when the item no longer holds what the last build put there.
 - (void)applySide:(ANNBarButtonsSide)side
           options:(ANNNavigationOptions *)options
          animated:(BOOL)animated {
@@ -426,12 +508,92 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         return;
     }
     UINavigationItem *navigationItem = screen.navigationItem;
+    ANNSideInputs *inputs = [self inputsOfSide:side options:options];
+    ANNSideBuild *last = _builds[@(side)];
+    if (last && [last.inputs isSameAs:inputs]) {
+        NSArray *placed = [self placedOf:side grouped:last.grouped item:navigationItem];
+        if (ANNSameObjects(last.placed, placed)) {
+            return;
+        }
+    }
+    ANNSideBuild *build = [ANNSideBuild new];
+    build.inputs = inputs;
+    build.grouped = [self placeSide:side options:options item:navigationItem animated:animated];
+    build.placed = [self placedOf:side grouped:build.grouped item:navigationItem];
+    _builds[@(side)] = build;
+}
+
+- (ANNSideInputs *)inputsOfSide:(ANNBarButtonsSide)side options:(ANNNavigationOptions *)options {
+    ANNTopBarOptions *topBar = options.topBar;
+    ANNSideInputs *inputs = [ANNSideInputs new];
+    inputs.buttons = ANNButtonsOfSide(options, side);
+    inputs.color = ANNSideColor(topBar, side);
+    inputs.disabledColor = ANNSideDisabledColor(topBar, side);
+    inputs.background = ANNSideBackgroundColor(topBar, side);
+    inputs.customizationId = side == ANNBarButtonsSideCenter ? topBar.customizationId : nil;
+    NSMutableArray *loaded = [NSMutableArray new];
+    for (ANNButtonOptions *button in inputs.buttons ?: @[]) {
+        if (ANNHasComponent(button)) {
+            [loaded addObject:[self slotFor:button] ?: NSNull.null];
+        }
+        [loaded addObject:ANNLoadedImageOf(button.icon)];
+        ANNAddMenuImages(button.menu.items, loaded);
+    }
+    inputs.loaded = loaded;
+    UITraitCollection *traits = UITraitCollection.currentTraitCollection;
+    inputs.traits = @[
+        @(traits.userInterfaceStyle), @(traits.displayScale),
+        traits.preferredContentSizeCategory ?: @"", @(traits.legibilityWeight)
+    ];
+    return inputs;
+}
+
+// What the navigation item holds of `side` now, as the side's build put it there.
+- (NSArray *)placedOf:(ANNBarButtonsSide)side
+              grouped:(BOOL)grouped
+                 item:(UINavigationItem *)navigationItem {
+    NSMutableArray *placed = [NSMutableArray new];
+    BOOL left = side == ANNBarButtonsSideLeft;
+    switch (side) {
+        case ANNBarButtonsSideLeft:
+        case ANNBarButtonsSideRight: {
+            NSArray *shown =
+                left ? navigationItem.leftBarButtonItems : navigationItem.rightBarButtonItems;
+            if (@available(iOS 16.0, *)) {
+                if (grouped) {
+                    shown = left ? navigationItem.leadingItemGroups
+                                 : navigationItem.trailingItemGroups;
+                }
+                if (!left) {
+                    [placed addObject:navigationItem.pinnedTrailingGroup ?: NSNull.null];
+                }
+            }
+            [placed addObjectsFromArray:shown ?: @[]];
+            break;
+        }
+        case ANNBarButtonsSideCenter:
+            if (@available(iOS 16.0, *)) {
+                [placed addObjectsFromArray:navigationItem.centerItemGroups ?: @[]];
+                [placed addObject:navigationItem.customizationIdentifier ?: NSNull.null];
+            }
+            break;
+        case ANNBarButtonsSideToolbar:
+            break;
+    }
+    return placed;
+}
+
+// Builds `side` whole and puts it on the item; YES when it went in as groups.
+- (BOOL)placeSide:(ANNBarButtonsSide)side
+          options:(ANNNavigationOptions *)options
+             item:(UINavigationItem *)navigationItem
+         animated:(BOOL)animated {
     NSArray<ANNBuiltButton *> *built = [self buildSide:side options:options];
     if (side == ANNBarButtonsSideCenter) {
         if (@available(iOS 16.0, *)) {
             [self setCenter:built options:options item:navigationItem];
         }
-        return;
+        return YES;
     }
     NSMutableArray<ANNBuiltButton *> *placed = [built mutableCopy];
     if (side == ANNBarButtonsSideRight) {
@@ -440,26 +602,28 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         }
     }
     if (@available(iOS 26.0, *)) {
-        if ([self hasGroupOfSeveral:placed]) {
+        if (ANNTabsDesign.isGlass && [self hasGroupOfSeveral:placed]) {
             NSArray<UIBarButtonItemGroup *> *groups = [self groupsOf:placed];
             if (side == ANNBarButtonsSideLeft) {
                 navigationItem.leadingItemGroups = groups;
             } else {
                 navigationItem.trailingItemGroups = groups.reverseObjectEnumerator.allObjects;
             }
-            return;
+            return YES;
         }
     }
     NSMutableArray<UIBarButtonItem *> *items = [NSMutableArray new];
     for (ANNBuiltButton *button in placed) {
         if (@available(iOS 26.0, *)) {
             // Each button its own capsule: a zero-width space between neighbours, and the right ones never share the
-            // capsule of "•••".
-            if (items.count > 0) {
-                [items addObject:[UIBarButtonItem fixedSpaceItemOfWidth:0]];
-            }
-            if (side == ANNBarButtonsSideRight) {
-                button.item.sharesBackground = NO;
+            // capsule of "•••". The compatibility mode has no capsules.
+            if (ANNTabsDesign.isGlass) {
+                if (items.count > 0) {
+                    [items addObject:[UIBarButtonItem fixedSpaceItemOfWidth:0]];
+                }
+                if (side == ANNBarButtonsSideRight) {
+                    button.item.sharesBackground = NO;
+                }
             }
         }
         [items addObject:button.item];
@@ -469,6 +633,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     } else {
         [navigationItem setRightBarButtonItems:items animated:animated];
     }
+    return NO;
 }
 
 - (NSArray<ANNBuiltButton *> *)buildSide:(ANNBarButtonsSide)side
@@ -559,7 +724,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         NSMutableArray<UIBarButtonItem *> *items = [NSMutableArray new];
         for (ANNBuiltButton *button in run) {
             if (@available(iOS 26.0, *)) {
-                if (run.count == 1) {
+                if (run.count == 1 && ANNTabsDesign.isGlass) {
                     button.item.sharesBackground = NO;
                 }
             }
@@ -667,7 +832,7 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
         BOOL icon = kind == ANNBarButtonKindSymbol || kind == ANNBarButtonKindImage ||
                     kind == ANNBarButtonKindImageButton || kind == ANNBarButtonKindShowText;
         NSString *group = icon ? [button.group withDefault:nil] : nil;
-        if (@available(iOS 26.0, *)) {
+        if (ANNTabsDesign.isGlass) {
             // Only icons of one group share a capsule (the toolbar has no groups): any other neighbours get a
             // zero-width space, unless a space of the options is there already.
             BOOL sameGroup = group.length > 0 && [group isEqualToString:previousIconGroup];
@@ -835,10 +1000,12 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
     }
     BOOL prominent = [[button.style withDefault:nil] isEqualToString:@"prominent"];
     if (prominent) {
+        // The capsule of the glass; the design before it (and its compatibility mode) has the bold `done` style.
+        item.style = UIBarButtonItemStyleDone;
         if (@available(iOS 26.0, *)) {
-            item.style = UIBarButtonItemStyleProminent;
-        } else {
-            item.style = UIBarButtonItemStyleDone;
+            if (ANNTabsDesign.isGlass) {
+                item.style = UIBarButtonItemStyleProminent;
+            }
         }
     }
     // The color: the tint, and for a plain button also the text's; `prominent` takes it only into the tint, and a font
@@ -1021,9 +1188,11 @@ static UIBarButtonSystemItem ANNSystemItemOf(NSString *name) {
                  kind:(ANNBarButtonKind)kind
                    to:(UIBarButtonItem *)item {
     if (@available(iOS 26.0, *)) {
-        BOOL ownBackground =
-            kind == ANNBarButtonKindComponent || kind == ANNBarButtonKindImageButton;
-        item.hidesSharedBackground = [button.hideSharedBackground withDefault:ownBackground];
+        if (ANNTabsDesign.isGlass) {
+            BOOL ownBackground =
+                kind == ANNBarButtonKindComponent || kind == ANNBarButtonKindImageButton;
+            item.hidesSharedBackground = [button.hideSharedBackground withDefault:ownBackground];
+        }
     }
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270000
     if (@available(iOS 27.0, *)) {

package/ios/TopBar/ANNLargeTitlePresenter.mm

@@ -3,6 +3,13 @@
 #import "ANNBarAppearance.h"
 #import "ANNMainList.h"
 #import "ANNScreenBars.h"
+#import "ANNTabsDesign.h"
+
+// The glass design of iOS 26 draws the large title inside the list the bar follows: the places, fills and bands of
+// this file are for it. The compatibility mode keeps the title in the bar, as before iOS 26 (`ANNTabsDesign`).
+static BOOL ANNTitleInList(void) {
+    return ANNTabsDesign.isGlass;
+}
 
 // How far the color reaches above the list's content: as far as a pull can show.
 static const CGFloat ANNListFillHeight = 2000;
@@ -58,10 +65,8 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
         ![options.topBar.largeTitle.collapseOnScroll withDefault:YES]) {
         return NO;
     }
-    if (@available(iOS 26.0, *)) {
-        if (ANNAppDirection.reactNativeIsRightToLeft) {
-            return NO;
-        }
+    if (ANNTitleInList() && ANNAppDirection.reactNativeIsRightToLeft) {
+        return NO;
     }
     return YES;
 }
@@ -132,6 +137,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 - (void)screenInPop:(ANNNavigationOptions *)options
                list:(UIScrollView *)list
         inlineInRow:(BOOL)inlineInRow {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIViewController *screen = _screen;
         UIView *screenView = screen.viewIfLoaded;
@@ -168,6 +176,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
          inlineInRow:(BOOL)inlineInRow
                  top:(CGFloat)top
             stackTop:(CGFloat)stackTop {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIView *screenView = _screen.viewIfLoaded;
         if (!screenView || inlineInRow || !ANNLargeTitleCanShow(options) || top - stackTop <= 0) {
@@ -282,6 +293,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
                   list:(UIScrollView *)list
            inlineInRow:(BOOL)inlineInRow
    backgroundComponent:(BOOL)backgroundComponent {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIViewController *screen = _screen;
         UIColor *fill = [ANNBarAppearance solidColorOf:options.topBar.background.color
@@ -320,6 +334,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 - (void)fillTitlePlaceFrom:(CGFloat)oldBarBottom
                       list:(UIScrollView *)list
                    options:(ANNNavigationOptions *)options {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         [self removeTitlePlaceFill];
         if (!ANNLargeTitleCanShow(options) || [ANNLargeTitlePresenter collapsesIntoList:options]) {
@@ -334,6 +351,9 @@ static UINavigationItemLargeTitleDisplayMode ANNItemModeOf(NSString *mode) {
 // The pushed screen's content may render only during the push, so its list mounts later than the push starts: the
 // fill is placed again at each mount and layout until the screen appeared.
 - (void)updateTitlePlaceFill:(ANNNavigationOptions *)options list:(UIScrollView *)list {
+    if (!ANNTitleInList()) {
+        return;
+    }
     if (@available(iOS 26.0, *)) {
         UIViewController *screen = _screen;
         UIView *screenView = screen.viewIfLoaded;

package/ios/TopBar/ANNMainList.h

@@ -23,6 +23,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// search takes it, or what is in it, for the screen's list.
 + (void)excludeView:(UIView *)view;
 
+/// The view is one of those (`excludeView:`).
++ (BOOL)isExcludedView:(UIView *)view;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/TopBar/ANNMainList.mm

@@ -22,6 +22,10 @@ static const CGFloat ANNMainListTolerance = 1;
     objc_setAssociatedObject(view, ANNMainListExcludedKey, @YES, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 }
 
++ (BOOL)isExcludedView:(UIView *)view {
+    return objc_getAssociatedObject(view, ANNMainListExcludedKey) != nil;
+}
+
 - (UIScrollView *)keptList {
     UIScrollView *list = _list;
     UIView *screenView = _screenView;

package/ios/TopBar/ANNScrollEdgeEffects.h

@@ -5,9 +5,12 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// The scroll edge effect of a screen's lists (iOS 26; `scrollEdgeEffect.*`): each edge's own `hidden` / `style` beat
 /// the general ones, through the public API. No top effect under a solid `background.color` (not a clear one) or
-/// `background.component` unless the screen set its own for the top or for all edges. The screen remembers the lists it
-/// set and gives them the system values back (`hidden` NO, `style` automatic) before its content goes and when it
-/// leaves, and sets them again at its appearance. Before iOS 26 nothing. Main queue.
+/// `background.component` unless the screen set its own for the top or for all edges. The lists are the scroll views
+/// of the screen's view down to 16 levels, outside hidden views (`display: none`), not inside a list that scrolls
+/// vertically (its rows) or a text view; a scroll view that doesn't (a pager, a carousel) is looked into for its
+/// lists. The screen remembers the lists it set and gives them the system values back when it leaves, at its destroy
+/// and when they leave its view for no screen (Fabric's pool; in another screen they may be that screen's already).
+/// Before iOS 26 nothing. Main queue.
 @interface ANNScrollEdgeEffects : NSObject
 
 - (instancetype)initWithScreenView:(UIView *)screenView;
@@ -15,13 +18,26 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/// At the appearance and at a merge: every scroll view in the screen's view, set again whole.
+/// At the appearance and at a merge: the lists of the screen's view, set again whole. Without a walk (only the known
+/// lists still in the view set again) when the options it reads and the traits are the same as at the last walk and
+/// no content mounted since, while the screen's content tells all its mounts (`mountsReported`) and that walk found
+/// no pager.
 - (void)applyToAllWithOptions:(ANNNavigationOptions *)options;
 
-/// After a mount of the content: the main list only; lists React took out of the screen get the system values.
+/// The screen's content tells each of its mounts, also out of the window (a React root): without it every call walks
+/// the view.
+@property(nonatomic) BOOL mountsReported;
+
+/// After a mount of the content: the main list only; lists React took out of the screen get the system values, and
+/// the next `applyToAllWithOptions:` walks the view again.
 - (void)applyToList:(nullable UIScrollView *)list options:(ANNNavigationOptions *)options;
 
-/// The lists set get the system values back (the screen leaves, its content goes, its destroy).
+/// The screen left: its lists get the system values back (a list Fabric recycles from it comes clean), and stay
+/// known for its next appearance.
+- (void)screenDidDisappear;
+
+/// The lists set get the system values back and are forgotten (the screen's content goes, its destroy); the next
+/// `applyToAllWithOptions:` walks the view again.
 - (void)reset;
 
 @end

package/ios/TopBar/ANNScrollEdgeEffects.mm

@@ -1,5 +1,16 @@
 #import "ANNScrollEdgeEffects.h"
 #import "ANNBarAppearance.h"
+#import "ANNMainList.h"
+
+// How deep the walk looks for lists, as the main list's search.
+static const NSUInteger ANNEdgeWalkMaxDepth = 16;
+static const CGFloat ANNEdgeWalkTolerance = 1;
+
+// A list that scrolls (or bounces) vertically: what is in it is its rows, which never meet a bar themselves.
+static BOOL ANNScrollsVertically(UIScrollView *list) {
+    return list.alwaysBounceVertical ||
+           list.contentSize.height > CGRectGetHeight(list.bounds) + ANNEdgeWalkTolerance;
+}
 
 // What one edge gets: whether it is hidden and its style; `nil` style is automatic.
 typedef struct {
@@ -18,6 +29,11 @@ static ANNEdgeEffect ANNEdgeEffectOf(ANNScrollEdgeEffectOptions *effect,
 @implementation ANNScrollEdgeEffects {
     __weak UIView *_screenView;
     NSHashTable<UIScrollView *> *_lists;
+    // What the last walk read (nil: walk at the next call), and whether content mounted since or the walk found a
+    // scroll view whose lists come and go without a mount (a pager's pages).
+    NSArray *_walkInputs;
+    BOOL _mountedSinceWalk;
+    BOOL _walkFoundPager;
 }
 
 - (instancetype)initWithScreenView:(UIView *)screenView {
@@ -30,46 +46,137 @@ static ANNEdgeEffect ANNEdgeEffectOf(ANNScrollEdgeEffectOptions *effect,
 
 - (void)applyToAllWithOptions:(ANNNavigationOptions *)options {
     if (@available(iOS 26.0, *)) {
-        [self reset];
         UIView *screenView = _screenView;
-        if (screenView) {
-            [self applyIn:screenView options:options];
+        if (!screenView) {
+            [self reset];
+            return;
+        }
+        NSArray *inputs = [self inputsOf:options traits:screenView.traitCollection];
+        [self dropListsOutside:screenView];
+        // The lists are the same as at the last walk: they take the values again (the screen gave them the system
+        // ones as it went), without a walk.
+        if (_walkInputs && _mountsReported && !_mountedSinceWalk && !_walkFoundPager &&
+            ANNOptionValuesSame(_walkInputs, inputs)) {
+            for (UIScrollView *list in _lists.allObjects) {
+                [self apply:options to:list];
+            }
+            return;
+        }
+        NSMutableArray<UIScrollView *> *found = [NSMutableArray new];
+        BOOL pager = NO;
+        [self collectIn:screenView depth:0 into:found pager:&pager];
+        // The screen's lists that the walk no longer finds get the system values; the others are set again.
+        for (UIScrollView *kept in _lists.allObjects) {
+            if ([found indexOfObjectIdenticalTo:kept] == NSNotFound) {
+                [ANNScrollEdgeEffects resetList:kept];
+                [_lists removeObject:kept];
+            }
+        }
+        for (UIScrollView *list in found) {
+            [self apply:options to:list];
         }
+        _walkInputs = inputs;
+        _mountedSinceWalk = NO;
+        _walkFoundPager = pager;
     }
 }
 
-- (void)applyIn:(UIView *)view options:(ANNNavigationOptions *)options API_AVAILABLE(ios(26.0)) {
+// What the effects of a list read: the effect's options, the bar's background (a solid one hides the top), the traits
+// a clear color is told by.
+- (NSArray *)inputsOf:(ANNNavigationOptions *)options traits:(UITraitCollection *)traits {
+    ANNTopBarBackgroundOptions *background = options.topBar.background;
+    return @[
+        options.scrollEdgeEffect, background.color, background.component.name,
+        @(traits.userInterfaceStyle), @(traits.accessibilityContrast)
+    ];
+}
+
+// The lists of `view`, bounded as the main list's search: hidden views (`display: none`) and the core's own views are
+// left out with what is in them. A view at alpha 0 is not: an animation (a fade in, a transition) changes it without a
+// mount. A list that scrolls vertically and a text view are set, not looked into; a scroll view that doesn't is looked
+// into for the lists of its pages, and such a walk is never skipped.
+- (void)collectIn:(UIView *)view
+            depth:(NSUInteger)depth
+             into:(NSMutableArray<UIScrollView *> *)found
+            pager:(BOOL *)pager {
+    if (depth > ANNEdgeWalkMaxDepth) {
+        return;
+    }
     for (UIView *subview in view.subviews) {
+        if (subview.hidden || [ANNMainList isExcludedView:subview]) {
+            continue;
+        }
         if ([subview isKindOfClass:UIScrollView.class]) {
-            [self apply:options to:(UIScrollView *)subview];
+            UIScrollView *list = (UIScrollView *)subview;
+            [found addObject:list];
+            if ([list isKindOfClass:UITextView.class] || ANNScrollsVertically(list)) {
+                continue;
+            }
+            *pager = YES;
         }
-        [self applyIn:subview options:options];
+        [self collectIn:subview depth:depth + 1 into:found pager:pager];
     }
 }
 
 - (void)applyToList:(UIScrollView *)list options:(ANNNavigationOptions *)options {
+    _mountedSinceWalk = YES;
     if (@available(iOS 26.0, *)) {
-        // Lists React took out of the screen (and gave to another one) get the system values now.
-        UIView *screenView = _screenView;
-        for (UIScrollView *kept in _lists.allObjects) {
-            if (!screenView || ![kept isDescendantOfView:screenView]) {
-                [ANNScrollEdgeEffects resetList:kept];
-                [_lists removeObject:kept];
-            }
-        }
+        [self dropListsOutside:_screenView];
         if (list) {
             [self apply:options to:list];
         }
     }
 }
 
-- (void)reset {
+// Whether `view` is in some screen: one of its views is the view of a view controller, in a window or not. A list in
+// Fabric's pool is not: its component view (the list's own superview) has no superview there.
+static BOOL ANNIsInAScreen(UIView *view) {
+    for (UIView *ancestor = view; ancestor; ancestor = ancestor.superview) {
+        if ([ancestor.nextResponder isKindOfClass:UIViewController.class]) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+// A list React took out of the screen is no longer the screen's: outside every screen (in the pool Fabric recycles
+// its views from, shared by every surface) it gets the system values, so it comes clean into the screen that takes it;
+// in another screen it may be that screen's already, which set its values: it is only forgotten.
+- (void)dropListsOutside:(nullable UIView *)screenView {
+    for (UIScrollView *kept in _lists.allObjects) {
+        if (screenView && [kept isDescendantOfView:screenView]) {
+            continue;
+        }
+        if (@available(iOS 26.0, *)) {
+            if (!ANNIsInAScreen(kept)) {
+                [ANNScrollEdgeEffects resetList:kept];
+            }
+        }
+        [_lists removeObject:kept];
+    }
+}
+
+// The screen's lists get the system values; with `keepingLists` they stay known, with what the last walk read, for
+// the next appearance to set them again without a walk.
+- (void)giveBackKeepingLists:(BOOL)keepingLists {
+    [self dropListsOutside:_screenView];
     if (@available(iOS 26.0, *)) {
         for (UIScrollView *list in _lists.allObjects) {
             [ANNScrollEdgeEffects resetList:list];
         }
     }
-    [_lists removeAllObjects];
+    if (!keepingLists) {
+        [_lists removeAllObjects];
+        _walkInputs = nil;
+    }
+}
+
+- (void)screenDidDisappear {
+    [self giveBackKeepingLists:YES];
+}
+
+- (void)reset {
+    [self giveBackKeepingLists:NO];
 }
 
 + (void)resetList:(UIScrollView *)list API_AVAILABLE(ios(26.0)) {

package/ios/TopBar/ANNSearchPresenter.mm

@@ -1,6 +1,6 @@
 #import "ANNSearchPresenter.h"
 #import "ANNEventEmitter.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNSearchResultsViewController.h"
 #import "ANNUserChoice.h"
 
@@ -298,7 +298,7 @@ static ANNUserChoice *ANNScopeChoice(NSString *scope) {
     _appliedSuggestions = nil;
     if (_resultsComponentId) {
         [_componentRegistry removeChildComponent:_resultsComponentId];
-        [ANNScreenInsets removeScreenId:_resultsComponentId];
+        [ANNScreenEnvironment removeScreenId:_resultsComponentId];
     }
     _resultsKey = nil;
     _resultsComponentId = nil;

package/ios/TopBar/ANNSearchResultsViewController.mm

@@ -1,5 +1,5 @@
 #import "ANNSearchResultsViewController.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 
 @implementation ANNSearchResultsViewController {
     NSString *_componentId;
@@ -30,10 +30,10 @@
     [super viewDidLayoutSubviews];
     _reactView.frame = self.view.bounds;
     if (_componentId) {
-        [ANNScreenInsets setInsets:self.view.safeAreaInsets
-                           padding:UIEdgeInsetsZero
-                       forScreenId:_componentId
-                      eventEmitter:_eventEmitter];
+        [ANNScreenEnvironment setInsets:self.view.safeAreaInsets
+                                padding:UIEdgeInsetsZero
+                            forScreenId:_componentId
+                           eventEmitter:_eventEmitter];
     }
 }