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

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];
     }
 }
 

package/ios/TopBar/ANNTopBarPresenter.h

@@ -70,8 +70,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)screenDidLayOut;
 - (void)contentDidMount;
 
-/// The screen's content is about to go (a pop removes it before `viewDidDisappear`): its lists get the system edge
-/// effect back and the large title's color leaves them; the place of the large title during a pop leaves the screen.
+/// The screen's content is about to go (its destroy; a pop removes it before `viewDidDisappear`): its lists get the
+/// system edge effect back and the large title's color leaves them; the place of the large title during a pop leaves
+/// the screen. At `screenDidDisappear` the same, the lists of the edge effects kept for the screen's next appearance.
 - (void)releaseLists;
 
 /// Every root of the screen's bar still alive stops, once, on the main queue.

package/ios/TopBar/ANNTopBarPresenter.mm

@@ -9,7 +9,9 @@
 #import "ANNScreenBars.h"
 #import "ANNScrollEdgeEffects.h"
 #import "ANNSearchPresenter.h"
+#import "ANNSlotScreenView.h"
 #import "ANNStackController.h"
+#import "ANNTabsDesign.h"
 #import "ANNTitleComponentView.h"
 #import "ANNTitleGlassView.h"
 #import "ANNTitleView.h"
@@ -34,11 +36,27 @@ typedef NS_ENUM(NSInteger, ANNBarPhase) {
     ANNBarPhaseDidAppear,
 };
 
-static BOOL ANNIsIOS26(void) {
-    if (@available(iOS 26.0, *)) {
-        return YES;
+// The glass design of iOS 26, not its compatibility mode: the large title in the list, the title's capsule, the
+// system subtitle and the pin of the title's color are its own (`ANNTabsDesign`).
+static BOOL ANNIsGlass(void) {
+    return ANNTabsDesign.isGlass;
+}
+
+// The same look: the item's appearance is the one set last, or one equal to it.
+static BOOL ANNSameAppearance(UINavigationBarAppearance *a, UINavigationBarAppearance *b) {
+    return a == b || [a isEqual:b];
+}
+
+// The traits a look's colors and fonts resolve with: the style, the contrast, the elevation (the 1×1 background is
+// drawn with them) and the text size.
+static NSArray *ANNLookTraitsOf(UITraitCollection *traits) {
+    if (!traits) {
+        return @[];
     }
-    return NO;
+    return @[
+        @(traits.userInterfaceStyle), @(traits.accessibilityContrast), @(traits.userInterfaceLevel),
+        traits.preferredContentSizeCategory ?: @""
+    ];
 }
 
 static BOOL ANNHasComponentName(ANNComponentOptions *component) {
@@ -110,6 +128,10 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
     NSUInteger _pinToken;
     // A pop's band under the title keeps the bar's look as it is (the screen leaves for one without a band of its own).
     BOOL _bandKeepsLook;
+    // What the last look was filled from, and the two appearances the item held right after it.
+    NSArray *_lookInputs;
+    UINavigationBarAppearance *_lookStandard;
+    UINavigationBarAppearance *_lookEdge;
 }
 
 - (instancetype)initWithScreen:(UIViewController *)screen {
@@ -177,13 +199,13 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
     BOOL collapses = [ANNLargeTitlePresenter collapsesIntoList:options];
     BOOL inlineInRow = [self inlineInRow:options];
     BOOL ownEdge = [options.topBar.scrollEdgeAppearance.active withDefault:NO];
-    context.transparentEdge = ANNIsIOS26() && collapses && !inlineInRow && !ownEdge;
+    context.transparentEdge = ANNIsGlass() && collapses && !inlineInRow && !ownEdge;
     // While a pop draws the band behind the title in the title's own place, the bar's edge stays clear: UIKit grows
     // the bar's background with an interactive pop, over the screen's top where the title is.
     if ([_largeTitle drawsTitleBand] && !_bandKeepsLook && !ownEdge) {
         context.transparentEdge = YES;
     }
-    context.largeTitleNeedsBackground = ANNIsIOS26() && canShow && !collapses && !inlineInRow;
+    context.largeTitleNeedsBackground = ANNIsGlass() && canShow && !collapses && !inlineInRow;
     return context;
 }
 
@@ -367,26 +389,64 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
 
 #pragma mark - The look
 
+// Several callers ask for the look along one appearance (the screen's, a merge, the band and the pin of iOS 26): it
+// is filled only when what the fill reads changed or the item holds another look, and set only when it differs from
+// the item's. A look set again makes UIKit lay the bar out anew, and on iOS 26 copy it into the stack's bar.
 - (void)applyLook:(ANNNavigationOptions *)options {
     UIViewController *screen = _screen;
     UINavigationItem *item = screen.navigationItem;
+    UITraitCollection *traits =
+        screen.viewIfLoaded.window.traitCollection ?: screen.traitCollection;
+    ANNBarAppearanceContext context = [self appearanceContextOf:options];
+    UITraitCollection *pinned = ANNIsGlass() ? _pinnedTraits : nil;
+    NSArray *inputs = [self lookInputsOf:options context:context traits:traits pinned:pinned];
+    if (_lookInputs && ANNOptionValuesSame(_lookInputs, inputs) &&
+        ANNSameAppearance(item.standardAppearance, _lookStandard) &&
+        ANNSameAppearance(item.scrollEdgeAppearance, _lookEdge)) {
+        return;
+    }
     // The screen's own looks, filled whole and set again (the item copies them).
     UINavigationBarAppearance *standard =
         [item.standardAppearance copy] ?: [UINavigationBarAppearance new];
     UINavigationBarAppearance *edge =
         [item.scrollEdgeAppearance copy] ?: [UINavigationBarAppearance new];
-    UITraitCollection *traits =
-        screen.viewIfLoaded.window.traitCollection ?: screen.traitCollection;
     [ANNBarAppearance fillStandard:standard
                         scrollEdge:edge
                        withOptions:options
-                           context:[self appearanceContextOf:options]
+                           context:context
                             traits:traits];
-    if (_pinnedTraits && ANNIsIOS26()) {
-        [self pinTitleColorsOf:standard edge:edge options:options traits:_pinnedTraits];
+    if (pinned) {
+        [self pinTitleColorsOf:standard edge:edge options:options traits:pinned];
+    }
+    if (!ANNSameAppearance(item.standardAppearance, standard)) {
+        item.standardAppearance = standard;
     }
-    item.standardAppearance = standard;
-    item.scrollEdgeAppearance = edge;
+    if (!ANNSameAppearance(item.scrollEdgeAppearance, edge)) {
+        item.scrollEdgeAppearance = edge;
+    }
+    _lookInputs = inputs;
+    _lookStandard = item.standardAppearance;
+    _lookEdge = item.scrollEdgeAppearance;
+}
+
+// What `fillStandard:scrollEdge:withOptions:context:traits:` and the pin read: the bar's options by value, the
+// image the back button's icon loads (a file written again at its path is another image), the context, the traits.
+- (NSArray *)lookInputsOf:(ANNNavigationOptions *)options
+                  context:(ANNBarAppearanceContext)context
+                   traits:(UITraitCollection *)traits
+                   pinned:(nullable UITraitCollection *)pinned {
+    ANNTopBarOptions *topBar = options.topBar;
+    Image *backIcon = topBar.backButton.icon;
+    ANNImageSource *source = backIcon.source;
+    BOOL loads = backIcon.hasValue && !(source && source.kind == ANNImageSourceKindSymbol);
+    id backImage = loads ? [backIcon withDefault:nil] : nil;
+    return @[
+        topBar.background, topBar.scrollEdgeAppearance, topBar.noBorder, topBar.borderColor,
+        topBar.title.font, topBar.title.color, topBar.largeTitle.font, topBar.largeTitle.color,
+        topBar.backButton, backImage ?: NSNull.null, @(context.transparentEdge),
+        @(context.largeTitleNeedsBackground), ANNLookTraitsOf(traits),
+        pinned ? ANNLookTraitsOf(pinned) : NSNull.null
+    ];
 }
 
 // The title colors resolved for `traits`: fixed colors that don't follow the glass's style.
@@ -414,7 +474,7 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
 - (void)pinTitleColorAlong:(id<UIViewControllerTransitionCoordinator>)coordinator
                     traits:(UITraitCollection *)traits {
     UIViewController *screen = _screen;
-    if (!screen || !ANNIsIOS26()) {
+    if (!screen || !ANNIsGlass()) {
         return;
     }
     NSUInteger token = ++_pinToken;
@@ -461,7 +521,7 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
     NSString *glass = [title.glass withDefault:nil];
     BOOL glassShows = NO;
     if (@available(iOS 26.0, *)) {
-        glassShows = [ANNTitleGlassView isGlass:glass];
+        glassShows = ANNIsGlass() && [ANNTitleGlassView isGlass:glass];
     }
     [self applySubtitle:options glass:glassShows];
 
@@ -497,7 +557,7 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
         }
     } else if (_titleComponent) {
         titleView = _titleComponent;
-    } else if (!ANNIsIOS26() && subtitle.length > 0 && !ANNLargeTitleCanShow(options)) {
+    } else if (!ANNIsGlass() && subtitle.length > 0 && !ANNLargeTitleCanShow(options)) {
         // Before iOS 26 a subtitle is a two-label title, without a large title that can show.
         titleView = [[ANNTitleView alloc] initWithOptions:options];
     }
@@ -538,7 +598,8 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
         if (_native && !subtitle.text.hasValue) {
             return;
         }
-        if (text.length == 0) {
+        // The compatibility mode draws no system subtitle: a two-label title shows it, as before iOS 26.
+        if (text.length == 0 || !ANNIsGlass()) {
             item.attributedSubtitle = nil;
             item.largeAttributedSubtitle = nil;
             return;
@@ -590,7 +651,7 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
         return NO;
     }
     CGFloat height = ANNTitleRowHeight;
-    if (!ANNIsIOS26()) {
+    if (!ANNIsGlass()) {
         if (_screen.traitCollection.userInterfaceIdiom == UIUserInterfaceIdiomPad) {
             height = ANNTitleRowHeightPad;
         }
@@ -1029,8 +1090,10 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
         ANNNavigationOptions *options = [screen resolveOptionsWithDefault];
         [_largeTitle screenDidDisappear:options list:[self followedList]];
     }
-    // The lists the screen set leave with it; its color and its React background leave the main list.
-    [self releaseLists];
+    // The lists the screen set leave with it (the edge effects stay known for its next appearance); its color and its
+    // React background leave the main list.
+    [_edgeEffects screenDidDisappear];
+    [self releaseListsKeepingEdgeEffects:YES];
     _bandKeepsLook = NO;
     // A swipe back given up: the screen keeps the bar's own look for its next appearance.
     if (band && screen) {
@@ -1039,7 +1102,13 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
 }
 
 - (void)releaseLists {
-    [_edgeEffects reset];
+    [self releaseListsKeepingEdgeEffects:NO];
+}
+
+- (void)releaseListsKeepingEdgeEffects:(BOOL)keepEdgeEffects {
+    if (!keepEdgeEffects) {
+        [_edgeEffects reset];
+    }
     [_largeTitle removeListFill];
     [_largeTitle removeTitlePlaceFill];
     [_largeTitle removeTitleHost];
@@ -1084,6 +1153,10 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
       [weakSelf contentDidMount];
     }
                          forKey:ANNTopBarMountKey];
+    // The edge effect walks the screen again only after a mount. A native screen's views are the app's, never told; a
+    // screen of one tree (`appProvider`) hears the mounts only in the window, so it walks at each appearance.
+    [self edgeEffects].mountsReported =
+        !_native && ![content isKindOfClass:ANNSlotScreenView.class];
 }
 
 // The list the bar follows at the top edge under a large title that folds into it: the main list of a React screen;
@@ -1224,7 +1297,7 @@ static ANNUserChoice *ANNRenameChoice(NSString *title) {
         return;
     }
     ANNNavigationOptions *options = [screen resolveOptionsWithDefault];
-    BOOL eligible = ANNIsIOS26() && [self isShownTop] && screen.viewIfLoaded.window != nil &&
+    BOOL eligible = ANNIsGlass() && [self isShownTop] && screen.viewIfLoaded.window != nil &&
                     [background isShownInBar:bar] &&
                     [ANNLargeTitlePresenter collapsesIntoList:options] &&
                     ![self inlineInRow:options];