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

package/ios/Core/ANNRenderWait.mm

@@ -1,12 +1,26 @@
 #import "ANNRenderWait.h"
 #import "ANNAssert.h"
 #import "ANNComponentViewController.h"
+#import "ANNJavaScriptCalls.h"
 #import "ANNScreenReadiness.h"
 #import "UIViewController+LayoutProtocol.h"
+#import <QuartzCore/QuartzCore.h>
 
 // A screen whose rendered state stays unknown counts as ready after this, with `unknownContentRule`.
 static const NSTimeInterval ANNUnknownContentLimit = 1;
 
+// What a kind of the bar whose limit passed in the content phase still gets, with `barLimitsFromStart`: a limit of 0
+// would mean none of its own.
+static const NSTimeInterval ANNPassedBarLimit = 0.001;
+
+// What is left of a bar kind's `limit` after `spent`; no limit of its own stays none.
+static NSTimeInterval ANNBarLimitLeft(NSTimeInterval limit, NSTimeInterval spent) {
+    if (limit <= 0) {
+        return limit;
+    }
+    return MAX(limit - spent, ANNPassedBarLimit);
+}
+
 // The number of the last wait made: each wait listens under a key of its own.
 static NSUInteger ANNRenderWaitCount;
 
@@ -18,19 +32,25 @@ static NSUInteger ANNRenderWaitCount;
     ANNRenderWaitBar _bar;
     ANNBarWaitLimits _barLimits;
     NSString *_key;
+    // When the running wait started (`barLimitsFromStart`).
+    CFTimeInterval _startTime;
     // The token: each start, phase and end takes the next one, so that what an earlier one set up does nothing.
     NSUInteger _number;
     // Inside `start`: a step runs as it is, under the caller's protection.
     BOOL _starting;
     // Inside `setUp`: a ready handler leaves the node to the readiness test after it.
     BOOL _settingUp;
+    // The content is there and the phase waits for the calls JavaScript made by then (`settlesThroughJavaScript`); the
+    // number of that settle, so that one of an earlier take does nothing.
+    BOOL _settling;
+    NSUInteger _settleNumber;
     // The content nodes still waited, and every node the wait set its ready handler on.
     NSHashTable<UIViewController *> *_waited;
     NSHashTable<UIViewController *> *_listened;
-    // The waited screens of the "root mounted" kind (a subset of `_waited`), and whether their limit passed in this
-    // start (a retake waits for them no more then).
-    NSHashTable<UIViewController *> *_mountWaited;
-    BOOL _mountLimitPassed;
+    // The waited screens of the "unseen" kind (a subset of `_waited`), and whether their limit passed in this start (a
+    // retake waits for them no more then).
+    NSHashTable<UIViewController *> *_unseenWaited;
+    BOOL _unseenLimitPassed;
     ANNBarComponentsWait *_barWait;
     // What the last take of the running phase took: its screens (weakly) and, in the content phase, what the take read
     // of each to decide what it waits for (`takeStateOfScreens:`). A retake that would take the same does nothing.
@@ -55,7 +75,7 @@ static NSUInteger ANNRenderWaitCount;
             stringWithFormat:@"ApexNavigation.renderWait.%lu", (unsigned long)++ANNRenderWaitCount];
         _waited = [NSHashTable weakObjectsHashTable];
         _listened = [NSHashTable weakObjectsHashTable];
-        _mountWaited = [NSHashTable weakObjectsHashTable];
+        _unseenWaited = [NSHashTable weakObjectsHashTable];
     }
     return self;
 }
@@ -69,7 +89,8 @@ static NSUInteger ANNRenderWaitCount;
     }
     _isWaiting = YES;
     _isInBarPhase = NO;
-    _mountLimitPassed = NO;
+    _unseenLimitPassed = NO;
+    _startTime = CACurrentMediaTime();
     NSUInteger number = ++_number;
     _starting = YES;
     @try {
@@ -87,10 +108,10 @@ static NSUInteger ANNRenderWaitCount;
                          [weakSelf limitOfNumber:number];
                        });
     }
-    if (_mountLimit > 0) {
-        int64_t delay = (int64_t)(_mountLimit * NSEC_PER_SEC);
+    if (_unseenLimit > 0) {
+        int64_t delay = (int64_t)(_unseenLimit * NSEC_PER_SEC);
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, delay), dispatch_get_main_queue(), ^{
-          [weakSelf mountLimitOfNumber:number];
+          [weakSelf unseenLimitOfNumber:number];
         });
     }
     if (_unknownContentRule) {
@@ -117,11 +138,9 @@ static NSUInteger ANNRenderWaitCount;
     if (![self runs:number]) {
         return;
     }
-    if (_content == ANNRenderWaitContentNode && _node && [self screensAreReady]) {
-        [_waited removeObject:_node];
-    }
+    [self testNode];
     if (_waited.count == 0 && !_barWait) {
-        [self phaseOfNumber:number endedMarkingReady:NO];
+        [self contentOfNumber:number];
     }
 }
 
@@ -143,8 +162,8 @@ static NSUInteger ANNRenderWaitCount;
         case ANNRenderWaitContentNone:
             break;
         case ANNRenderWaitContentEachScreen:
-            // Each screen by the readiness it needs: its content, or the first mount of its root (an unselected
-            // tab's screen). A screen with no content to wait for (a native screen) is ready.
+            // Each screen by its content; an unselected tab's to the unseen limit. A screen with no content to wait
+            // for (a native screen) is ready.
             for (UIViewController *node in screens) {
                 if (![node isKindOfClass:ANNComponentViewController.class]) {
                     continue;
@@ -158,25 +177,11 @@ static NSUInteger ANNRenderWaitCount;
                     [self listenTo:screen number:number];
                     continue;
                 }
-                if (_mountLimitPassed) {
-                    continue;
-                }
-                [_mountWaited addObject:screen];
-                // A slot screen's readiness is its mount: its ready handler serves.
-                if (![content respondsToSelector:@selector(whenMounted:)]) {
-                    [self listenTo:screen number:number];
-                    continue;
-                }
-                if (content.hasMounted) {
-                    [_mountWaited removeObject:screen];
+                if (_unseenLimitPassed) {
                     continue;
                 }
-                [_waited addObject:screen];
-                __weak ANNRenderWait *weakSelf = self;
-                __weak UIViewController *weakScreen = screen;
-                [content whenMounted:^{
-                  [weakSelf node:weakScreen readyOfNumber:number];
-                }];
+                [_unseenWaited addObject:screen];
+                [self listenTo:screen number:number];
             }
             break;
         case ANNRenderWaitContentNode:
@@ -206,7 +211,7 @@ static NSUInteger ANNRenderWaitCount;
     }
     [_waited removeObject:node];
     if (_waited.count == 0 && !_barWait) {
-        [self phaseOfNumber:number endedMarkingReady:NO];
+        [self contentOfNumber:number];
     }
 }
 
@@ -219,30 +224,69 @@ static NSUInteger ANNRenderWaitCount;
     if (_waited.count > 0) {
         return;
     }
+    [self contentOfNumber:number];
+}
+
+// What the running phase waited for came by its signals, or was there already. The content phase with
+// `settlesThroughJavaScript` ends once the calls JavaScript made by now are applied: the commit that mounted the content
+// ran its layout effects (`useScreenOptions`) in the same task of the JavaScript thread, so their `mergeOptions` are on
+// their way to the main queue ahead of the settle. Content that was there already (as the wait starts or takes its
+// screens again) may have mounted in a commit that ran just now: it settles too. The bar phase, and screens without
+// React content (a native screen), end at once.
+- (void)contentOfNumber:(NSUInteger)number {
+    if (!_settlesThroughJavaScript || _isInBarPhase || ![self hasReactScreen]) {
+        [self phaseOfNumber:number endedMarkingReady:NO];
+        return;
+    }
+    if (_settling) {
+        return;
+    }
+    _settling = YES;
+    NSUInteger settle = ++_settleNumber;
+    __weak ANNRenderWait *weakSelf = self;
+    [ANNJavaScriptCalls afterCallsMadeSoFar:^{
+      [weakSelf settleOfNumber:number settle:settle];
+    }];
+}
+
+- (void)settleOfNumber:(NSUInteger)number settle:(NSUInteger)settle {
+    if (![self runs:number] || !_settling || settle != _settleNumber) {
+        return;
+    }
+    _settling = NO;
     [self phaseOfNumber:number endedMarkingReady:NO];
 }
 
-// The screens of the "root mounted" kind are waited no longer: nobody sees them, nothing of theirs is held.
-- (void)mountLimitOfNumber:(NSUInteger)number {
+// The screens of the "unseen" kind are waited no longer: nobody sees them, nothing of theirs is held.
+- (void)unseenLimitOfNumber:(NSUInteger)number {
     if (![self runs:number]) {
         return;
     }
-    _mountLimitPassed = YES;
-    if (_mountWaited.count == 0) {
+    _unseenLimitPassed = YES;
+    if (_unseenWaited.count == 0) {
         return;
     }
-    for (UIViewController *node in _mountWaited.allObjects) {
+    for (UIViewController *node in _unseenWaited.allObjects) {
         [_waited removeObject:node];
     }
-    [_mountWaited removeAllObjects];
+    [_unseenWaited removeAllObjects];
     if (_waited.count == 0 && !_barWait) {
         [self phaseOfNumber:number endedMarkingReady:NO];
     }
 }
 
-// The limit: what is still waited counts as rendered from now on, its held events go at once.
+// The limit: what is still waited counts as rendered from now on, its held events go at once. A phase that only waits
+// for the calls of JavaScript (its content is there) ends without marking anything.
 - (void)limitOfNumber:(NSUInteger)number {
-    if (![self runs:number] || (_waited.count == 0 && !_barWait)) {
+    if (![self runs:number]) {
+        return;
+    }
+    if (_settling) {
+        [self stopSettling];
+        [self phaseOfNumber:number endedMarkingReady:NO];
+        return;
+    }
+    if (_waited.count == 0 && !_barWait) {
         return;
     }
     [self phaseOfNumber:number endedMarkingReady:YES];
@@ -288,7 +332,7 @@ static NSUInteger ANNRenderWaitCount;
           [self markContentReady];
       }
       if (self->_bar == ANNRenderWaitBarAfterContent && !self->_isInBarPhase) {
-          [self startBarPhase];
+          [self startBarPhaseWithLimits:[self barLimitsAfterContent]];
           return;
       }
       [self finish];
@@ -309,9 +353,10 @@ static NSUInteger ANNRenderWaitCount;
 
 #pragma mark - The bar phase
 
-// The content is there: the bar components of the screens now, each kind to its own limit from now. Nothing to wait
-// for ends the wait at once.
-- (void)startBarPhase {
+// The content is there: the bar components of the screens now, each kind to its limit in `limits` from now. Nothing to
+// wait for ends the wait at once.
+- (void)startBarPhaseWithLimits:(ANNBarWaitLimits)limits {
+    [self stopSettling];
     [_barWait cancel];
     _barWait = nil;
     [self releaseContent];
@@ -321,7 +366,7 @@ static NSUInteger ANNRenderWaitCount;
     NSArray<UIViewController *> *barScreens = [self barScreens];
     [self rememberTakenScreens:barScreens states:nil];
     ANNBarComponentsWait *barWait = [ANNBarComponentsWait waitForScreens:barScreens
-                                                                  limits:_barLimits
+                                                                  limits:limits
                                                                     done:^{
                                                                       [weakSelf barOfNumber:number];
                                                                     }];
@@ -344,23 +389,28 @@ static NSUInteger ANNRenderWaitCount;
     }
     if (_isInBarPhase) {
         [self runStep:^{
-          [self startBarPhase];
+          [self startBarPhaseWithLimits:self->_barLimits];
         }];
         return;
     }
     // The same token: the limit set at the start stays.
     NSUInteger number = _number;
+    [self stopSettling];
     [self releaseContent];
     [_barWait cancel];
     _barWait = nil;
-    if (take) {
-        [self takeScreensOfNumber:number];
-    } else {
+    if (!take) {
         _takenScreens = nil;
         _takenStates = nil;
+        [self phaseOfNumber:number endedMarkingReady:NO];
+        return;
     }
+    // As at the start: a node ready already counts at once (its ready handler waits for the next time), and content
+    // that is there settles again, the settle of the last take having stopped.
+    [self takeScreensOfNumber:number];
+    [self testNode];
     if (_waited.count == 0 && !_barWait) {
-        [self phaseOfNumber:number endedMarkingReady:NO];
+        [self contentOfNumber:number];
     }
 }
 
@@ -382,6 +432,7 @@ static NSUInteger ANNRenderWaitCount;
 
 // The wait lets go of everything: its handlers, its bar wait; its limits find another token.
 - (void)stop {
+    [self stopSettling];
     _isWaiting = NO;
     _isInBarPhase = NO;
     _takenScreens = nil;
@@ -399,21 +450,26 @@ static NSUInteger ANNRenderWaitCount;
     }
     [_listened removeAllObjects];
     [_waited removeAllObjects];
-    [_mountWaited removeAllObjects];
+    [_unseenWaited removeAllObjects];
 }
 
 #pragma mark - Helpers
 
+// A settle on its way does nothing from now on.
+- (void)stopSettling {
+    _settling = NO;
+    _settleNumber++;
+}
+
 // What the content phase's take reads of each screen to decide what it waits for: the readiness it needs, whether it
-// has its content yet, whether that content is ready, and whether its root mounted.
+// has its content yet, and whether that content is ready.
 - (NSArray<NSNumber *> *)takeStateOfScreens:(NSArray<UIViewController *> *)screens {
     NSMutableArray<NSNumber *> *states = [NSMutableArray arrayWithCapacity:screens.count];
     for (UIViewController *node in screens) {
-        NSUInteger state = (NSUInteger)ANNWaitedReadinessOf(node) << 3;
+        NSUInteger state = (NSUInteger)ANNWaitedReadinessOf(node) << 2;
         if ([node isKindOfClass:ANNComponentViewController.class]) {
             UIView<ANNComponentProtocol> *content = ((ANNComponentViewController *)node).reactView;
-            BOOL mounted = [content respondsToSelector:@selector(hasMounted)] && content.hasMounted;
-            state |= (content ? 1 : 0) | (content.isReady ? 2 : 0) | (mounted ? 4 : 0);
+            state |= (content ? 1 : 0) | (content.isReady ? 2 : 0);
         }
         [states addObject:@(state)];
     }
@@ -470,6 +526,37 @@ static NSUInteger ANNRenderWaitCount;
     return screens;
 }
 
+// With `ANNRenderWaitContentNode`, the node counts as ready when every screen of it is.
+- (void)testNode {
+    if (_content == ANNRenderWaitContentNode && _node && [self screensAreReady]) {
+        [_waited removeObject:_node];
+    }
+}
+
+// The limits of the bar phase that follows the content phase: with `barLimitsFromStart`, what is left of each since the
+// wait started.
+- (ANNBarWaitLimits)barLimitsAfterContent {
+    ANNBarWaitLimits limits = _barLimits;
+    if (!_barLimitsFromStart) {
+        return limits;
+    }
+    NSTimeInterval spent = CACurrentMediaTime() - _startTime;
+    limits.titleAndBackground = ANNBarLimitLeft(limits.titleAndBackground, spent);
+    limits.buttons = ANNBarLimitLeft(limits.buttons, spent);
+    return limits;
+}
+
+// A screen with React content is among the screens: a commit of React mounted it.
+- (BOOL)hasReactScreen {
+    for (UIViewController *node in [self screens]) {
+        if ([node isKindOfClass:ANNComponentViewController.class] &&
+            ((ANNComponentViewController *)node).reactView) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
 // Every screen has no content to wait for (a native screen) or its content is ready.
 - (BOOL)screensAreReady {
     for (UIViewController *node in [self screens]) {

package/ios/Core/ANNSceneDelegate.mm

@@ -1,9 +1,10 @@
 #import "ANNSceneDelegate.h"
+#import "ANNDeepLinkQueue.h"
 #import "ApexNavigation.h"
-#import <React/RCTLinkingManager.h>
 
 // On the scene life cycle UIKit stops calling the app delegate's URL, user activity and foreground/background
-// methods. The scene forwards them, so AppDelegate overrides (and the deep links of ANNDeepLinkQueue) keep working.
+// methods. The scene forwards them, so AppDelegate overrides (and the deep links of ANNDeepLinkQueue) keep working; the
+// links keep their scene, through which React Native 0.88 and newer take them.
 @implementation ANNSceneDelegate
 
 - (void)scene:(UIScene *)scene
@@ -15,21 +16,21 @@
     self.window = [ApexNavigation attachToWindowScene:(UIWindowScene *)scene];
 
     for (UIOpenURLContext *context in connectionOptions.URLContexts) {
-        [self ann_openURLContext:context];
+        [self ann_openURLContext:context ofScene:scene];
     }
     for (NSUserActivity *activity in connectionOptions.userActivities) {
-        [self ann_continueUserActivity:activity];
+        [self ann_continueUserActivity:activity ofScene:scene];
     }
 }
 
 - (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
     for (UIOpenURLContext *context in URLContexts) {
-        [self ann_openURLContext:context];
+        [self ann_openURLContext:context ofScene:scene];
     }
 }
 
 - (void)scene:(UIScene *)scene continueUserActivity:(NSUserActivity *)userActivity {
-    [self ann_continueUserActivity:userActivity];
+    [self ann_continueUserActivity:userActivity ofScene:scene];
 }
 
 - (void)sceneDidBecomeActive:(UIScene *)scene {
@@ -62,7 +63,7 @@
 
 #pragma mark - private
 
-- (void)ann_openURLContext:(UIOpenURLContext *)context {
+- (void)ann_openURLContext:(UIOpenURLContext *)context ofScene:(UIScene *)scene {
     UIApplication *application = UIApplication.sharedApplication;
     id<UIApplicationDelegate> appDelegate = application.delegate;
     if ([appDelegate respondsToSelector:@selector(application:openURL:options:)]) {
@@ -70,22 +71,31 @@
         options[UIApplicationOpenURLOptionsSourceApplicationKey] = context.options.sourceApplication;
         options[UIApplicationOpenURLOptionsAnnotationKey] = context.options.annotation;
         options[UIApplicationOpenURLOptionsOpenInPlaceKey] = @(context.options.openInPlace);
-        [appDelegate application:application openURL:context.URL options:options];
+        [ANNDeepLinkQueue forwardURLContext:context
+                                    ofScene:scene
+                                    through:^{
+                                      [appDelegate application:application openURL:context.URL options:options];
+                                    }];
     } else {
-        [RCTLinkingManager application:application openURL:context.URL options:@{}];
+        [ANNDeepLinkQueue dispatchURLContext:context ofScene:scene];
     }
 }
 
-- (void)ann_continueUserActivity:(NSUserActivity *)activity {
+- (void)ann_continueUserActivity:(NSUserActivity *)activity ofScene:(UIScene *)scene {
     UIApplication *application = UIApplication.sharedApplication;
     id<UIApplicationDelegate> appDelegate = application.delegate;
     if ([appDelegate respondsToSelector:@selector(application:continueUserActivity:restorationHandler:)]) {
-        [appDelegate application:application
-             continueUserActivity:activity
-               restorationHandler:^(NSArray<id<UIUserActivityRestoring>> *restorableObjects){
-               }];
+        [ANNDeepLinkQueue forwardUserActivity:activity
+                                      ofScene:scene
+                                      through:^{
+                                        [appDelegate application:application
+                                             continueUserActivity:activity
+                                               restorationHandler:^(
+                                                   NSArray<id<UIUserActivityRestoring>> *restorableObjects){
+                                               }];
+                                      }];
     } else if ([activity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) {
-        [RCTLinkingManager application:application openURL:activity.webpageURL options:@{}];
+        [ANNDeepLinkQueue dispatchUserActivity:activity ofScene:scene];
     }
 }
 

package/ios/Core/ANNSystemUI.h

@@ -36,8 +36,9 @@ typedef NS_ENUM(NSInteger, ANNSystemUIQuestion) {
 /// The owner adds the asks UIKit doesn't make — a merge, a side menu at rest, an overlay, a root replaced, the bar of a
 /// stack shown or hidden, the orientation after an appearance — and makes them once per turn of the main queue: a
 /// trigger marks groups, the marks of a turn are coalesced, and at its end UIKit is asked again for each marked group
-/// in the main window and every overlay window. It keeps no values but the last status bar of each window, which only
-/// chooses whether a change of the style animates. Never a wait. Main queue.
+/// in the main window and every overlay window. Each ask of the status bar also lays out the screens' blurs under it
+/// (`statusBar.blur`), then and on the next turn. It keeps no values but the last status bar of each window, which
+/// only chooses whether a change of the style animates. Never a wait. Main queue.
 @interface ANNSystemUI : NSObject
 
 - (instancetype)init NS_UNAVAILABLE;

package/ios/Core/ANNSystemUI.mm

@@ -1,5 +1,6 @@
 #import "ANNSystemUI.h"
 #import "ANNAssert.h"
+#import "ANNComponentPresenter.h"
 #import "ANNComponentViewController.h"
 #import "ANNDefaultOptions.h"
 #import "ANNOverlayCoordinator.h"
@@ -280,6 +281,12 @@ static NSArray<UIViewController *> *ANNChainOf(UIWindow *window) {
             ask();
         }
     }
+    // The status bar hidden or shown moves no view where the safe area stays (a device with a notch): the blurs under
+    // it take its frame now, and once more on the next turn of the main queue, in case UIKit settles it after the ask.
+    [ANNComponentPresenter statusBarDidChange];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [ANNComponentPresenter statusBarDidChange];
+    });
 }
 
 // A controller that is no node of the layout (React Native's `<Modal>`, an alert, the splash) animates as UIKit's

package/ios/Core/ANNUtils.h

@@ -23,6 +23,13 @@ NS_ASSUME_NONNULL_BEGIN
 /// The key window of `scene`; nil when none of its windows is key.
 + (nullable UIWindow *)keyWindowOfScene:(nullable UIWindowScene *)scene;
 
+/// A new window of `windowClass` (`UIWindow` or a subclass) for the core: in the navigation window's scene, or at the
+/// size of `mainScreen` before that window has one. It takes the navigation window's `overrideUserInterfaceStyle`:
+/// React Native's `Appearance.setColorScheme` sets the style once, on the windows there are at that moment, and a
+/// window of the system's style would show its screens in the other theme and switch the app's theme in JS when its
+/// hosting views move in. Every window the core makes but the main window, the style's source, comes from here.
++ (__kindof UIWindow *)makeWindowOfClass:(Class)windowClass;
+
 /// The status bar's frame in the navigation window's scene (its status bar manager); `CGRectZero` without a scene.
 @property(class, nonatomic, readonly) CGRect statusBarFrame;
 

package/ios/Core/ANNUtils.mm

@@ -26,6 +26,16 @@
     return windows;
 }
 
++ (UIWindow *)makeWindowOfClass:(Class)windowClass {
+    UIWindowScene *scene = self.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.
+    UIWindow *window = scene ? [[windowClass alloc] initWithWindowScene:scene]
+                             : [[windowClass alloc] initWithFrame:self.mainScreen.bounds];
+    window.overrideUserInterfaceStyle = self.mainWindow.overrideUserInterfaceStyle;
+    return window;
+}
+
 + (UIWindow *)keyWindowOfScene:(UIWindowScene *)scene {
     for (UIWindow *window in scene.windows) {
         if (window.isKeyWindow) {

package/ios/Core/ApexNavigation+Internal.h

@@ -18,7 +18,7 @@ NS_ASSUME_NONNULL_BEGIN
 + (nullable ANNNativeScreenCreator)nativeScreenCreatorForName:(NSString *)name;
 
 /// Whether a native screen is registered under the name by `registerNativeScreen:creator:` (the registration of 8.x is
-/// gone). Any thread: the layout of a command is checked on the module's queue.
+/// gone). Any thread (the layout check of a command reads it on the main queue).
 + (BOOL)hasNativeScreenNamed:(NSString *)name;
 
 @end

package/ios/Core/ApexNavigation.mm

@@ -9,7 +9,6 @@
 #import "ANNReloadCoordinator.h"
 #import "ANNSlotHost.h"
 #import "ANNSplashViewController.h"
-#import "ANNTabsPreloadWindow.h"
 #import "ANNUtils.h"
 #import <React/RCTLog.h>
 #import <ReactCommon/RCTHost.h>
@@ -45,8 +44,9 @@ static UIWindowScene *ANNConnectedWindowScene(void) {
     }
 }
 
-// Once, on the main queue: the generated native screens before any other part, then the core's parts, the `<Modal>`
-// replacement before any React content, the window with the copy of the launch screen, and the watch of the bundles.
+// Once, on the main queue: the generated native screens before any other part, then the core's parts, the queue of the
+// links, the `<Modal>` replacement before any React content, the window with the copy of the launch screen, and the
+// watch of the bundles.
 + (void)bootstrapWithHost:(RCTHost *)host {
     ANNAssertMainQueue();
     if (ANNBootstrapped) {
@@ -55,6 +55,9 @@ static UIWindowScene *ANNConnectedWindowScene(void) {
     ANNBootstrapped = YES;
     [self registerGeneratedScreens];
     ANNHost = host;
+    // The links that come before React content wait for it; the launch link waits for the scene. Here, not in
+    // `ANNAppDelegate`, so an app delegate of the app's own keeps its launch link.
+    [ANNDeepLinkQueue start];
     // React Native lets a class with the descriptor of `ModalHostView` stand in for its own.
     [ANNModalHostViewComponentView registerForModalHostView];
     [self makeMainWindowInScene:nil];
@@ -145,9 +148,7 @@ static UIWindowScene *ANNConnectedWindowScene(void) {
     ANNMainWindow.windowScene = windowScene;
     ANNMainWindow.frame = windowScene.coordinateSpace.bounds;
     [ANNMainWindow makeKeyAndVisible];
-    // The tabs' preload windows, the overlay windows and the slot host's window made before the scene go where the
-    // main window is.
-    [ANNTabsPreloadWindow mainWindowSceneDidConnect:windowScene];
+    // The overlay windows and the slot host's window made before the scene go where the main window is.
     [ANNOverlayCoordinator mainWindowSceneDidConnect:windowScene];
     [ANNSlotHost mainWindowSceneDidConnect:windowScene];
     // A direction the app set before the window had a scene takes the scene now.

package/ios/Core/UIViewController+LayoutProtocol.h

@@ -64,10 +64,17 @@ FOUNDATION_EXPORT ANNWaitedReadiness ANNWaitedReadinessOf(UIViewController *scre
 /// The own options merged with `options` (`ANNNodeHelper mergeOwnOptions:`).
 - (void)mergeOwnOptions:(ANNNavigationOptions *)options;
 
-/// A change of the own options on a copy (`ANNNodeHelper changeOwnOptions:`): the way a presenter or a module keeps a
-/// choice of the user (a scope, tokens, a checked menu item, a toggled button).
+/// A change of the own options on a copy (`ANNNodeHelper changeOwnOptions:`): what the core keeps of the app's merges.
 - (void)changeOwnOptions:(void (^)(ANNNavigationOptions *options))change;
 
+/// A choice of the user in the node's user layer (`ANNNodeHelper setUserChoice:forKey:`): the way a presenter or a
+/// module keeps what the user did (a scope, tokens, a checked menu item, a toggled button, a renamed title). Nil
+/// removes it.
+- (void)setUserChoice:(nullable ANNUserChoice *)choice forKey:(NSString *)key;
+
+/// The choice of the user layer under `key`, or nil (`ANNNodeHelper userChoiceForKey:`).
+- (nullable ANNUserChoice *)userChoiceForKey:(NSString *)key;
+
 #pragma mark - Readiness
 
 /// A ready handler of the node under the waiter's own key (`ANNNodeHelper setReadyHandler:forKey:`): it runs once, the

package/ios/Core/UIViewController+LayoutProtocol.mm

@@ -125,6 +125,14 @@ ANNWaitedReadiness ANNWaitedReadinessOf(UIViewController *screen) {
     [self.nodeHelper changeOwnOptions:change];
 }
 
+- (void)setUserChoice:(ANNUserChoice *)choice forKey:(NSString *)key {
+    [self.nodeHelper setUserChoice:choice forKey:key];
+}
+
+- (ANNUserChoice *)userChoiceForKey:(NSString *)key {
+    return [self.nodeHelper userChoiceForKey:key];
+}
+
 #pragma mark - Readiness
 
 - (void)setReadyHandler:(dispatch_block_t)handler forKey:(NSString *)key {

package/ios/Layouts/Arrangement/ANNArrangementState.h

@@ -1,30 +1,15 @@
-#import "ANNEventEmitter.h"
 #import <UIKit/UIKit.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// The state of each screen of an arrangement (`useArrangement`): `{ placement, layout, front, hidden }`, which view of
-/// the pair it is and how the pair lies. The native side keeps it on the main queue; JavaScript reads it from its own
-/// thread for a screen's first render, and gets every change as `ANN.ArrangementChanged`.
+/// Whether the app can show pairs at all. The state of each screen of a pair (`useArrangement`) is kept for JavaScript
+/// by `ANNScreenEnvironment`.
 @interface ANNArrangementState : NSObject
 
 /// Whether the app shows arrangements (`getStartInfo().arrangements`): built with the iOS 27.1 SDK and running on
 /// iOS 27.1 or later. Without them JavaScript sends only the primary, as a screen. Any thread.
 + (BOOL)canShowArrangements;
 
-/// Keeps the screen's state and tells when it changed; nothing goes without an emitter. Main queue.
-+ (void)setState:(NSDictionary<NSString *, id> *)state
-     forScreenId:(NSString *)screenId
-    eventEmitter:(nullable ANNEventEmitter *)eventEmitter;
-
-/// The screen's state, or nil for a screen outside a pair. Any thread.
-+ (nullable NSDictionary<NSString *, id> *)stateForScreenId:(NSString *)screenId;
-
-+ (void)removeScreenId:(NSString *)screenId;
-
-/// Forgets every screen: after a reload the new JavaScript counts its ids anew. Main queue.
-+ (void)removeAll;
-
 @end
 
 NS_ASSUME_NONNULL_END