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

package/ios/Layouts/Screen/ANNScreenSafeArea.mm

@@ -1,9 +1,6 @@
 #import "ANNScreenSafeArea.h"
 #import "ANNScreenBars.h"
 
-// A bar at the bottom covers more than the home indicator when the bottom inset passes it by more than this.
-static const CGFloat ANNBottomBarThreshold = 0.5;
-
 CGRect ANNScreenRootFrame(CGRect bounds, UIEdgeInsets safeArea, BOOL fromTop, BOOL toBottom) {
     CGFloat top = fromTop ? 0 : safeArea.top;
     CGFloat bottom = toBottom ? CGRectGetHeight(bounds) : CGRectGetHeight(bounds) - safeArea.bottom;
@@ -20,31 +17,32 @@ UIEdgeInsets ANNScreenInsetsOverRoot(CGRect rootFrame, CGSize viewSize, UIEdgeIn
 
 UIEdgeInsets ANNScreenPadding(UIEdgeInsets insets, ANNNavigationOptions *options,
                               ANNScreenPaddingContext context) {
+    ANNTopBarOptions *topBar = options.topBar;
+    BOOL topBarShown = [topBar.visible withDefault:YES];
+    // Under a large title the list keeps its first rows clear of the bar itself. A padded top would follow the bar as
+    // it collapses and move the list with it, and UIKit, which collapses the title by the list's offset, would keep
+    // the small title hidden.
+    BOOL largeTitleShown = topBarShown && context.inStack && ANNLargeTitleCanShow(options);
     NSArray<NSString *> *edges = options.layout.safeAreaEdges;
     if (edges) {
-        // Exactly the edges given; unknown names count for nothing (`layout.safeAreaEdges`).
-        return UIEdgeInsetsMake([edges containsObject:@"top"] ? insets.top : 0,
+        // Exactly the edges given, but the top under a large title; unknown names count for nothing
+        // (`layout.safeAreaEdges`).
+        BOOL top = [edges containsObject:@"top"] && !largeTitleShown;
+        return UIEdgeInsetsMake(top ? insets.top : 0,
                                 [edges containsObject:@"left"] ? insets.left : 0,
                                 [edges containsObject:@"bottom"] ? insets.bottom : 0,
                                 [edges containsObject:@"right"] ? insets.right : 0);
     }
     UIEdgeInsets padding = insets;
-    ANNTopBarOptions *topBar = options.topBar;
-    BOOL topBarShown = [topBar.visible withDefault:YES];
     // A bar hidden for a while (`hideOnScroll`, `hideOnTap`, `hideOnKeyboard`) still counts as shown: only
     // `topBar.visible: false` gives the content its top back. A large title that can show takes the top too: the list
     // goes under the bar that collapses it.
-    if (topBarShown && context.inStack &&
-        (ANNScreenIsUnderTopBar(options) || ANNLargeTitleCanShow(options))) {
+    if (largeTitleShown || (topBarShown && context.inStack && ANNScreenIsUnderTopBar(options))) {
         padding.top = 0;
     }
-    // A bar at the bottom over the home indicator (a tab bar, a toolbar, the bottom search field of iOS 26): the list
-    // goes under it. A tab bar at the top on iPad adds nothing to the bottom. A toolbar that hides on scroll counts as
-    // there.
-    if (insets.bottom > context.windowBottomSafeArea + ANNBottomBarThreshold ||
-        (context.inStack && context.stackShowsToolbar && [topBar.hideOnScroll withDefault:NO])) {
-        padding.bottom = 0;
-    }
+    // The bottom is free: the content goes down to the bottom of the screen, under the home indicator and under a bar
+    // at the bottom, and a list keeps its last rows clear with `useSafeAreaInsets()`.
+    padding.bottom = 0;
     BOOL behindVerticalBar = [options.layout.drawBehindVerticalBar withDefault:YES] &&
                              [options.layout.verticalBars withDefault:YES];
     if (behindVerticalBar) {

package/ios/Layouts/Stack/ANNPreviewPush.h

@@ -5,12 +5,13 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// The preview of a push (`usePreview`): a push that waits for a tap on its preview. Its screen is made and renders
-/// unseen, out of the stack, its key kept; the view with `preview.nativeID` is looked for on the source screen at once,
-/// then at each mount of the source's content (on each frame for a slot screen), for at most 0.5 s; found, the preview module (`ANNPreviewInteraction`)
-/// shows the screen from it on a long press. A tap that commits pushes the screen without an animation and without a
-/// wait, or goes back to the entry with its key; a preview that goes without being opened destroys its screen and
-/// rejects the push. Main queue.
+/// The preview of a push (`usePreview`): a push that waits for a tap on its preview. Its screen is made at once, out of
+/// the stack, its key kept, and renders unseen: a React screen with a root of its own as a press on the view starts, a
+/// native screen or one of the app's one tree at once. The view with `preview.nativeID` is looked for on the source
+/// screen at once, then at each mount of the source's content (on each frame for a slot screen), for at most 0.5 s;
+/// found, the preview module (`ANNPreviewInteraction`) shows the screen from it on a long press. A tap that commits
+/// pushes the screen without an animation (and without a wait once its content is there), or goes back to the entry
+/// with its key; a preview that goes without being opened destroys its screen and rejects the push. Main queue.
 @interface ANNPreviewPush : NSObject
 
 - (instancetype)init NS_UNAVAILABLE;

package/ios/Layouts/Stack/ANNPreviewPush.mm

@@ -1,11 +1,15 @@
 #import "ANNPreviewPush.h"
 #import "ANNAssert.h"
+#import "ANNCommandRunner.h"
+#import "ANNComponentViewController.h"
 #import "ANNErrorTexts.h"
+#import "ANNExternalViewController.h"
 #import "ANNLayoutFactory.h"
 #import "ANNParking.h"
 #import "ANNPopoverPresenter.h"
 #import "ANNPreviewInteraction.h"
 #import "ANNReloadCoordinator.h"
+#import "ANNSlotContainers.h"
 #import "ANNSlotScreenView.h"
 #import "ANNStackCommands.h"
 #import "ANNStackController.h"
@@ -34,6 +38,10 @@ static const NSTimeInterval ANNPreviewSearchInterval = 1.0 / 60;
 @property(nonatomic, weak, nullable) UIView<ANNComponentProtocol> *watched;
 @property(nonatomic) BOOL attached;
 @property(nonatomic) BOOL done;
+// The size of the preview, taken at the push.
+@property(nonatomic) CGSize size;
+// The screen rendered: at the push, or at the press for a screen of its own React root.
+@property(nonatomic) BOOL rendered;
 // The screen's unseen place in the main window, at its preview size, until UIKit takes its view for the menu.
 @property(nonatomic, strong, nullable) UIView *host;
 @property(nonatomic, strong, nullable) ANNParking *parking;
@@ -51,6 +59,15 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     return records;
 }
 
+// A React screen with a root of its own renders at the press: a view with a preview costs no React root, no render and
+// no effects of the screen until the user presses it. A native screen (a kind of component screen) renders as it is
+// made, and a screen of the app's one tree renders in JavaScript as its slot is added: both render at the push.
+static BOOL ANNPreviewRendersAtPress(UIViewController *screen) {
+    return [screen isKindOfClass:ANNComponentViewController.class] &&
+           ![screen isKindOfClass:ANNExternalViewController.class] &&
+           ![screen.layoutInfo.name hasPrefix:ANNSlotPrefix];
+}
+
 @implementation ANNPreviewPush
 
 + (void)push:(ANNLayoutNode *)layout
@@ -71,6 +88,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     ANNPreviewRecord *record = [ANNPreviewRecord new];
     record.previewId = layout.nodeId;
     record.screen = screen;
+    record.size = size;
     record.source = source;
     record.answer = answer;
     // The key applies only once the tap made the preview a screen of the stack.
@@ -81,7 +99,9 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     record.generation = answer.generation;
     ANNPreviewRecords()[record.previewId] = record;
     @try {
-        [self parkAndRender:record size:size];
+        if (!ANNPreviewRendersAtPress(screen)) {
+            [self parkAndRender:record];
+        }
     } @catch (NSException *exception) {
         [self finish:record];
         [screen destroy];
@@ -90,9 +110,11 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     [self startSearch:record];
 }
 
-// The screen renders as now: its view waits unseen in the main window, at the size of the preview, so that its content
+// The screen renders, once: its view waits unseen in the main window, at the size of the preview, so that its content
 // lays out; nothing waits for it.
-+ (void)parkAndRender:(ANNPreviewRecord *)record size:(CGSize)size {
++ (void)parkAndRender:(ANNPreviewRecord *)record {
+    record.rendered = YES;
+    CGSize size = record.size;
     UIWindow *window = ApexNavigation.mainWindow;
     if (window) {
         UIView *host = [[UIView alloc] initWithFrame:CGRectMake(0, 0, size.width, size.height)];
@@ -207,6 +229,9 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
     record.attached = YES;
     [self stopWatching:record];
     __weak ANNPreviewRecord *weakRecord = record;
+    BOOL (^prepare)(void) = ^BOOL {
+      return [ANNPreviewPush renderAtPress:weakRecord];
+    };
     BOOL (^commit)(void) = ^BOOL {
       return [ANNPreviewPush commit:weakRecord];
     };
@@ -217,10 +242,35 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
                                   toView:view
                                 reactTag:view.tag
                                   source:source
+                                 prepare:prepare
                                   commit:commit
                                dismissed:dismissed];
 }
 
+#pragma mark - The press
+
+// The press starts (UIKit asks for the menu's configuration, about half a second before it shows the preview): the
+// screen renders now if it hasn't yet, so that its content is there when the preview shows. Out of the command's
+// runner, a failure rejects the push with its text and the preview goes. YES when the screen rendered. A preview of the
+// JavaScript before a reload renders nothing: its screen would start in the new one.
++ (BOOL)renderAtPress:(ANNPreviewRecord *)record {
+    if (!record || record.done || !record.answer.isCurrent) {
+        return NO;
+    }
+    if (record.rendered) {
+        return YES;
+    }
+    @try {
+        [self parkAndRender:record];
+    } @catch (NSException *exception) {
+        [self finish:record];
+        [record.screen destroy];
+        [record.answer reject:[ANNCommandRunner rejectionOf:exception what:record.what]];
+        return NO;
+    }
+    return YES;
+}
+
 #pragma mark - The tap
 
 // YES once the core took the preview: a key that leads back to an entry, or the push the queue accepted. From then on
@@ -267,7 +317,9 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
         return YES;
     }
     // The preview grows into the screen: a push without an animation, and without a wait, as the screen rendered
-    // already; its answer at the end of the transaction.
+    // already; its answer at the end of the transaction. A screen that rendered only as the menu opened (a pointer's
+    // right click, then a quick tap) may have no content yet: its push waits for it as a push does.
+    BOOL waits = ANNPreviewRendersAtPress(screen) && !screen.reactView.isReady;
     [stack setKey:key ofEntry:screen];
     [stack.queue push:screen
              answer:record.answer
@@ -275,7 +327,7 @@ static NSMutableDictionary<NSString *, ANNPreviewRecord *> *ANNPreviewRecords(vo
         componentId:record.componentId
              source:entry
            animated:NO
-              waits:NO];
+              waits:waits];
     return YES;
 }
 

package/ios/Layouts/Tabs/ANNBottomTabsAccessoryView.h

@@ -2,6 +2,8 @@
 #import "ANNReactView.h"
 #import <UIKit/UIKit.h>
 
+NS_ASSUME_NONNULL_BEGIN
+
 /**
  * The content of the tab bar's bottom accessory (iOS 26): the React component fills it, and the
  * component gets `bottomAccessoryPlacementChanged` when UIKit moves the accessory between the
@@ -10,8 +12,17 @@
 @interface ANNBottomTabsAccessoryView : UIView
 
 - (instancetype)initWithReactView:(ANNReactView *)reactView
-                     eventEmitter:(ANNEventEmitter *)eventEmitter;
+                     eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
 
 @property(nonatomic, strong, readonly) ANNReactView *reactView;
 
+/**
+ * `handler` runs once when the view is out of a window: at once when it is already, else when it
+ * leaves it, so a replaced accessory shows to the end of whatever UIKit draws of it. nil cancels a
+ * handler not run yet.
+ */
+- (void)whenOutOfWindow:(nullable dispatch_block_t)handler;
+
 @end
+
+NS_ASSUME_NONNULL_END

package/ios/Layouts/Tabs/ANNBottomTabsAccessoryView.mm

@@ -3,6 +3,7 @@
 @implementation ANNBottomTabsAccessoryView {
     ANNEventEmitter *_eventEmitter;
     NSString *_placement;
+    dispatch_block_t _outOfWindowHandler;
 }
 
 - (instancetype)initWithReactView:(ANNReactView *)reactView
@@ -32,6 +33,28 @@
     }];
 }
 
+- (void)whenOutOfWindow:(dispatch_block_t)handler {
+    _outOfWindowHandler = nil;
+    if (!handler) {
+        return;
+    }
+    if (!self.window) {
+        handler();
+        return;
+    }
+    _outOfWindowHandler = [handler copy];
+}
+
+- (void)didMoveToWindow {
+    [super didMoveToWindow];
+    dispatch_block_t handler = _outOfWindowHandler;
+    if (self.window || !handler) {
+        return;
+    }
+    _outOfWindowHandler = nil;
+    handler();
+}
+
 // UIKit sets the environment when the accessory is shown and changes it as the tab bar minimizes
 // and expands.
 - (void)tabAccessoryEnvironmentDidChange API_AVAILABLE(ios(26.0)) {

package/ios/Layouts/Tabs/ANNBottomTabsController.mm

@@ -598,10 +598,11 @@ static void ANNStacksOfNode(UIViewController *node, NSMutableArray<ANNStackContr
     [[self tabsPresenter] tabsDidLayOut];
 }
 
-// `afterInitialTab` goes on at the tabs' first appearance at the latest.
+// `afterInitialTab` goes on at the tabs' first appearance at the latest; a dot that waited for the window shows.
 - (void)viewDidAppear:(BOOL)animated {
     [super viewDidAppear:animated];
     [self scheduleChain];
+    [[self tabsPresenter] tabsDidAppear];
 }
 
 #pragma mark - Rendering and the preload window

package/ios/Layouts/Tabs/ANNBottomTabsCustomRow.mm

@@ -126,8 +126,13 @@ static const CGFloat ANNWideRowMargin = 16;
     if (self.superview != host) {
         [host addSubview:self];
     }
-    [host bringSubviewToFront:self];
-    // The system bar keeps its place and shows nothing; UIKit makes its subviews anew on a size change.
+    if (host.subviews.lastObject != self) {
+        [host bringSubviewToFront:self];
+    }
+    // The system bar keeps its place and shows nothing; UIKit makes its subviews anew on a size change. Not the bar's
+    // `alpha`: UIKit puts it back to 1 when the bar shows, on a pop with `hidesBottomBarWhenPushed`, and on iOS 27 on
+    // a rotation and a theme change, after the tabs' layout (a check here misses it); alpha 0 also drops the system's
+    // soft fade at the bottom.
     for (UIView *subview in bar.subviews) {
         if (!subview.hidden) {
             subview.hidden = YES;
@@ -193,6 +198,7 @@ static const CGFloat ANNWideRowMargin = 16;
         extra = MAX(0, CGRectGetMinY(barFrame) - CGRectGetMinY(frame));
     }
     BOOL hidden = wide ? _hiddenByOptions : (tabs.barHidden || bar.hidden);
+    // A new size lays the cells out again by itself; the same frame changes nothing.
     if (!CGRectEqualToRect(self.frame, frame)) {
         self.frame = frame;
     }
@@ -203,7 +209,6 @@ static const CGFloat ANNWideRowMargin = 16;
         _background.layer.cornerRadius = radius;
     }
     [self setExtraSafeArea:hidden ? 0 : extra];
-    [self setNeedsLayout];
 }
 
 - (void)setHiddenByOptions:(BOOL)hiddenByOptions {

package/ios/Layouts/Tabs/ANNBottomTabsPresenter.h

@@ -55,6 +55,10 @@ NS_ASSUME_NONNULL_BEGIN
 /// The tabs laid out (and before they appear): the dots, the buttons' `testID`s, the custom row.
 - (void)tabsDidLayOut;
 
+/// The tabs appeared, in a window: a dot set while they were out of it (under a modal over the whole screen) is
+/// placed now, as no layout may follow.
+- (void)tabsDidAppear;
+
 /// The bar laid out in a window for the first time: the titles are set again, so that the bar measures them at their
 /// real place.
 - (void)barDidLayOutInWindow;

package/ios/Layouts/Tabs/ANNBottomTabsPresenter.mm

@@ -12,9 +12,6 @@
 
 // The dot of a tab before iOS 26: its default size and color.
 static const CGFloat ANNDotDefaultSize = 6;
-// A button not there yet gets its `testID` again this often, at most this many times (`bottomTab.testID`).
-static const NSTimeInterval ANNTestIDRetryInterval = 0.15;
-static const NSUInteger ANNTestIDRetries = 5;
 
 // A picture of `color` (both of its styles when it is dynamic): the bar's 1×1 background and the border's line.
 static UIImage *ANNImageOfColor(UIColor *color, CGSize size) {
@@ -63,13 +60,23 @@ static id ANNValue(NSArray *list, NSUInteger index) {
     NSMutableArray<NSNumber *> *_roleItems;
     // The identifiers the buttons had before the core gave them a `testID`, to give back.
     NSMapTable<UIView *, NSString *> *_buttonIds;
+    // What the `testID`s and the dots were last applied to: the bar's items, the button of each tab and of More, the
+    // bar's size and its traits. UIKit makes the buttons anew (rotation, text size, items moving between the bar and
+    // More), and a layout that finds other buttons applies them again.
+    NSPointerArray *_appliedButtons;
+    CGSize _appliedBarSize;
+    UITraitCollection *_appliedBarTraits;
     BOOL _tabsAreSet;
     BOOL _titlesHidden;
+    // A dot that shows was placed while its button had no window (the tabs under a full-screen modal): it hides then,
+    // and the next layout in the window places it, whatever the check of the buttons says.
+    BOOL _dotsWaitForWindow;
     // The bar's look: its options, and the background and border every item's look starts from.
     ANNBottomTabsOptions *_barOptions;
     UITabBarAppearance *_base;
     ANNBottomTabsCustomRow *_row;
-    // The accessory shown (its id), and the content view of each accessory made, kept until the tabs go.
+    // The accessory shown (its id), and the content view of each accessory made: kept while hidden, until another
+    // accessory shows or the tabs go.
     NSString *_accessoryId;
     NSMutableDictionary<NSString *, ANNBottomTabsAccessoryView *> *_accessoryViews;
     // The pictures of the bar's colors by color and size.
@@ -123,6 +130,7 @@ static id ANNValue(NSArray *list, NSUInteger index) {
     _dotViews = [NSMutableArray new];
     _roleItems = [NSMutableArray new];
     _buttonIds = [NSMapTable weakToStrongObjectsMapTable];
+    _appliedButtons = [NSPointerArray weakObjectsPointerArray];
     _accessoryViews = [NSMutableDictionary new];
     _colorImages = [NSMutableDictionary new];
     _iconLoads = [NSMutableDictionary new];
@@ -251,7 +259,7 @@ static id ANNValue(NSArray *list, NSUInteger index) {
         [_row applyOptions:resolvedOptions.bottomTabs.customRow];
     }
     [self applyAccessoryOf:resolvedOptions animated:NO];
-    [self applyButtonTestIDsWithRetries:ANNTestIDRetries];
+    [self applyButtonTestIDs];
 }
 
 #pragma mark - ANNNodePresenter
@@ -315,7 +323,7 @@ static id ANNValue(NSArray *list, NSUInteger index) {
     }
     [self buildItemAtIndex:index bottomTab:bottomTab updatesBadgeAndDot:badgeAndDot];
     [self updateCells];
-    [self applyButtonTestIDsWithRetries:mergeOptions.testID.hasValue ? ANNTestIDRetries : 0];
+    [self applyButtonTestIDs];
 }
 
 // The whole item from `bottomTab`; the badge and the dot from it only with `updatesBadgeAndDot`.
@@ -589,6 +597,7 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
     if (anyDot) {
         [bar layoutIfNeeded];
     }
+    BOOL waitsForWindow = NO;
     for (NSUInteger index = 0; index < tabs.layoutTabs.count; index++) {
         ANNTabDotView *view = ANNValue(_dotViews, index);
         if (!view) {
@@ -602,49 +611,36 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
         }
         UITabBarItem *item = tabs.layoutTabs[index].tabBarItem;
         BOOL inBar = [bar.items indexOfObjectIdenticalTo:item] != NSNotFound;
-        [view placeOverButton:inBar ? [bar viewOfItem:item] : nil inBar:bar];
+        UIView *button = inBar ? [bar viewOfItem:item] : nil;
+        waitsForWindow = waitsForWindow || (inBar && !button.window);
+        [view placeOverButton:button inBar:bar];
     }
+    _dotsWaitForWindow = waitsForWindow;
 }
 
 #pragma mark - testID (`bottomTab.testID`, `bottomTabs.moreTestID`)
 
-// Each tab's button carries its `testID`; a button not there yet gets it again after 0.15 s, at most 5 times; a
-// removed `testID` gives the button its identifier back.
-- (void)applyButtonTestIDsWithRetries:(NSUInteger)retries {
+// Each tab's button carries its `testID`; a removed `testID` gives the button its identifier back. A button not
+// there yet gets it at the layout that finds it (`tabsDidLayOut`).
+- (void)applyButtonTestIDs {
     ANNBottomTabsController *tabs = self.tabs;
     UITabBar *bar = tabs.tabBar;
     if (!tabs || !bar) {
         return;
     }
-    BOOL missing = NO;
     for (NSUInteger index = 0; index < tabs.layoutTabs.count; index++) {
         UITabBarItem *item = tabs.layoutTabs[index].tabBarItem;
-        NSString *testID = item.accessibilityIdentifier;
         UIView *button = [bar viewOfItem:item];
-        if (!button) {
-            missing = missing || testID.length > 0;
-            continue;
+        if (button) {
+            [self setTestID:item.accessibilityIdentifier ofButton:button];
         }
-        [self setTestID:testID ofButton:button];
     }
     if (tabs.layoutTabs.count > 5) {
-        NSString *moreTestID = [_barOptions.moreTestID withDefault:nil];
         UIView *button = [bar viewOfItem:tabs.moreNavigationController.tabBarItem];
         if (button) {
-            [self setTestID:moreTestID ofButton:button];
-        } else {
-            missing = missing || moreTestID.length > 0;
+            [self setTestID:[_barOptions.moreTestID withDefault:nil] ofButton:button];
         }
     }
-    if (!missing || retries == 0) {
-        return;
-    }
-    __weak ANNBottomTabsPresenter *weakSelf = self;
-    dispatch_after(
-        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(ANNTestIDRetryInterval * NSEC_PER_SEC)),
-        dispatch_get_main_queue(), ^{
-          [weakSelf applyButtonTestIDsWithRetries:retries - 1];
-        });
 }
 
 - (void)setTestID:(NSString *)testID ofButton:(UIView *)button {
@@ -728,8 +724,9 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
                     warned = YES;
                     RCTLogWarn(
                         @"[ApexNavigation] bottomTabs.backgroundColor is ignored with Liquid "
-                        @"Glass (iOS 26). It applies with UIDesignRequiresCompatibility and on "
-                        @"earlier iOS versions.");
+                        @"Glass (iOS 26). It applies before iOS 26 and where UIKit keeps the "
+                        @"earlier design for UIDesignRequiresCompatibility (iOS 26; iOS 27 only "
+                        @"for an app built with an SDK before iOS 27).");
                 }
             }
         }
@@ -969,14 +966,15 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
         [tabs updateRootLayoutOfShownScreens];
     }
     if (mergeOptions.testID.hasValue || mergeOptions.moreTestID.hasValue) {
-        [self applyButtonTestIDsWithRetries:ANNTestIDRetries];
+        [self applyButtonTestIDs];
     }
 }
 
 #pragma mark - The accessory (iOS 26)
 
-// No name or `visible: false`: no accessory. The same id shown: nothing; another: a new one. A root of an id stays
-// with the tabs once made, so one hidden and shown again keeps its state.
+// No name or `visible: false`: no accessory. The same id shown: nothing; another: a new one. A hidden accessory keeps
+// its root, so one hidden and shown again keeps its state; the roots of the other ids stop once another accessory
+// shows and theirs is out of the window.
 - (void)applyAccessoryOf:(ANNNavigationOptions *)options animated:(BOOL)animated {
     if (@available(iOS 26.0, *)) {
         ANNBottomTabsController *tabs = self.tabs;
@@ -1012,8 +1010,37 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
             return;
         }
         _accessoryId = componentId;
+        [view whenOutOfWindow:nil];
         UITabAccessory *tabAccessory = [[UITabAccessory alloc] initWithContentView:view];
         [tabs setBottomAccessory:tabAccessory animated:animated && inWindow];
+        [self stopAccessoriesOtherThan:componentId];
+    }
+}
+
+// The roots of the accessories not shown stop, each once its view is out of the window, unless it shows again first.
+- (void)stopAccessoriesOtherThan:(NSString *)shownId {
+    ANNBottomTabsController *tabs = self.tabs;
+    __weak ANNBottomTabsPresenter *weakSelf = self;
+    __weak ANNReactComponentRegistry *weakComponents = tabs.components;
+    for (NSString *componentId in _accessoryViews.allKeys) {
+        if ([componentId isEqualToString:shownId]) {
+            continue;
+        }
+        ANNBottomTabsAccessoryView *view = _accessoryViews[componentId];
+        __weak ANNBottomTabsAccessoryView *weakView = view;
+        [view whenOutOfWindow:^{
+          ANNBottomTabsPresenter *presenter = weakSelf;
+          ANNBottomTabsAccessoryView *gone = weakView;
+          if (!presenter || !gone || presenter->_accessoryViews[componentId] != gone ||
+              [presenter->_accessoryId isEqualToString:componentId]) {
+              return;
+          }
+          [presenter->_accessoryViews removeObjectForKey:componentId];
+          ANNReactComponentRegistry *components = weakComponents;
+          if ([components existingComponent:componentId] == gone.reactView) {
+              [components removeChildComponent:componentId];
+          }
+        }];
     }
 }
 
@@ -1062,18 +1089,78 @@ static ANNBottomTabOptions *ANNWithIcons(ANNBottomTabOptions *bottomTab, NSArray
     [self updateCells];
 }
 
+// The `testID`s and the dots go on the buttons again only when the bar has other buttons than they were applied to,
+// another size or other traits; a merge and a rebuilt item apply them at once. A dot placed out of the window waits
+// for the next layout.
 - (void)tabsDidLayOut {
     if (!_tabsAreSet) {
         return;
     }
     [self updateHiddenTitles];
-    if (!ANNTabsDesign.isGlass) {
+    BOOL changed = [self barChangedSinceApplied];
+    if ((changed || _dotsWaitForWindow) && !ANNTabsDesign.isGlass) {
         [self placeDots];
     }
-    [self applyButtonTestIDsWithRetries:0];
+    if (changed) {
+        [self applyButtonTestIDs];
+    }
     [_row layOutInTabs];
 }
 
+- (void)tabsDidAppear {
+    if (_tabsAreSet && _dotsWaitForWindow && !ANNTabsDesign.isGlass) {
+        [self placeDots];
+    }
+}
+
+// The bar's items and the button of each tab and of More, by pointer, against those last seen; no walk through the
+// buttons. An item moving between the bar and More changes the items. The tabs lay out before the bar does: a tab in
+// the bar without its button yet makes the bar lay out first.
+- (BOOL)barChangedSinceApplied {
+    ANNBottomTabsController *tabs = self.tabs;
+    UITabBar *bar = tabs.tabBar;
+    if (!tabs || !bar) {
+        return NO;
+    }
+    NSArray<UIViewController *> *layoutTabs = tabs.layoutTabs;
+    NSArray<UITabBarItem *> *barItems = bar.items;
+    NSUInteger tabCount = layoutTabs.count + (layoutTabs.count > 5 ? 1 : 0);
+    NSMutableArray *seen = [NSMutableArray arrayWithArray:barItems];
+    BOOL laidOut = NO;
+    for (NSUInteger index = 0; index < tabCount; index++) {
+        UITabBarItem *item = index < layoutTabs.count ? layoutTabs[index].tabBarItem
+                                                      : tabs.moreNavigationController.tabBarItem;
+        UIView *button = [bar viewOfItem:item];
+        if (!button && !laidOut && bar.window &&
+            [barItems indexOfObjectIdenticalTo:item] != NSNotFound) {
+            laidOut = YES;
+            [bar layoutIfNeeded];
+            button = [bar viewOfItem:item];
+        }
+        [seen addObject:button ?: NSNull.null];
+    }
+    NSUInteger count = seen.count;
+    BOOL changed = _appliedButtons.count != count;
+    for (NSUInteger index = 0; index < count && !changed; index++) {
+        id object = seen[index] == NSNull.null ? nil : seen[index];
+        changed = (__bridge void *)object != [_appliedButtons pointerAtIndex:index];
+    }
+    CGSize size = bar.bounds.size;
+    UITraitCollection *traits = bar.traitCollection;
+    changed = changed || !CGSizeEqualToSize(size, _appliedBarSize) ||
+              ![traits isEqual:_appliedBarTraits];
+    if (!changed) {
+        return NO;
+    }
+    _appliedButtons.count = 0;
+    for (id object in seen) {
+        [_appliedButtons addPointer:object == NSNull.null ? NULL : (__bridge void *)object];
+    }
+    _appliedBarSize = size;
+    _appliedBarTraits = traits;
+    return YES;
+}
+
 // The glass bar measures a title when it is set and keeps that size: a title set before the bar was ever in a window
 // was measured in a button of its first layout there, when the bar's floating platter had no size yet, and stays cut
 // short ("Sec…") and lower than a title measured later. Neither a layout of the bar nor of its buttons measures it

package/ios/Layouts/Tabs/ANNTabsDesign.h

@@ -2,16 +2,17 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// Which design UIKit draws the bars in: the Liquid Glass of iOS 26, or the design before it, which iOS 26 keeps when
-/// the app's Info.plist has `UIDesignRequiresCompatibility = YES` (the compatibility mode). The key is read once per
-/// process. Every place of the core that depends on the design asks here (the module `UITabBar+utils` keeps its own
-/// copy).
+/// Which design UIKit draws the bars in: the Liquid Glass of iOS 26, or the design before it, which UIKit keeps when
+/// the app's Info.plist has `UIDesignRequiresCompatibility = YES` (the compatibility mode): on iOS 26, and on iOS 27
+/// only for an app built with an SDK before iOS 27. The key is read once per process. Every place of the core that
+/// depends on the design asks here.
 @interface ANNTabsDesign : NSObject
 
 /// iOS 26 or later, and not the compatibility mode.
 @property(class, nonatomic, readonly) BOOL isGlass;
 
-/// iOS 26 or later with `UIDesignRequiresCompatibility = YES`: the bars look as before iOS 26.
+/// iOS 26 or later with `UIDesignRequiresCompatibility = YES`, where UIKit honors it (not on iOS 27 and later for an
+/// app built with the iOS 27 SDK): the bars look as before iOS 26.
 @property(class, nonatomic, readonly) BOOL isCompatibilityMode;
 
 /// iOS 18 and later on an iPad or a Mac in a regular width: the system's tab bar is on top (or in the sidebar), and