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

package/ios/Core/ANNDeepLinkQueue.mm

@@ -71,19 +71,19 @@ static ANNLaunchLinkCompletion ANNWaitingLaunchLinkCompletion;
                                            selector:@selector(applicationDidBecomeActive:)
                                                name:UIApplicationDidBecomeActiveNotification
                                              object:nil];
+    // Started once the app is active (an app that starts React Native later, on demand), the queue missed the scene's
+    // connection and the notification: the links that launched the app went elsewhere, and none waits for them.
+    if (UIApplication.sharedApplication.applicationState == UIApplicationStateActive) {
+        [self launchLinksKnown];
+    }
 }
 
 + (void)dispatchURL:(NSURL *)url {
-    ANNAssertMainQueue();
     // The URL of the scene's link keeps its context; one the app delegate changed is a URL of its own.
     ANNDeepLink *link = [ANNForwardedSceneLink.url isEqual:url]
                             ? ANNForwardedSceneLink
                             : [[ANNDeepLink alloc] initWithURL:url context:nil activity:nil scene:nil];
-    if (ANNReactContentAppeared && ANNWaitingLaunchLinkCompletion == nil) {
-        [self openLink:link];
-        return;
-    }
-    [ANNPendingDeepLinks addObject:link];
+    [self dispatchLink:link];
 }
 
 + (void)forwardURLContext:(UIOpenURLContext *)context
@@ -104,15 +104,18 @@ static ANNLaunchLinkCompletion ANNWaitingLaunchLinkCompletion;
               through:forward];
 }
 
-+ (void)openURLContext:(UIOpenURLContext *)context ofScene:(UIScene *)scene {
-    [self openLink:[[ANNDeepLink alloc] initWithURL:context.URL context:context activity:nil scene:scene]];
++ (void)dispatchURLContext:(UIOpenURLContext *)context ofScene:(UIScene *)scene {
+    [self dispatchLink:[[ANNDeepLink alloc] initWithURL:context.URL context:context activity:nil scene:scene]];
 }
 
-+ (void)openUserActivity:(NSUserActivity *)activity ofScene:(UIScene *)scene {
++ (void)dispatchUserActivity:(NSUserActivity *)activity ofScene:(UIScene *)scene {
     if (activity.webpageURL == nil) {
         return;
     }
-    [self openLink:[[ANNDeepLink alloc] initWithURL:activity.webpageURL context:nil activity:activity scene:scene]];
+    [self dispatchLink:[[ANNDeepLink alloc] initWithURL:activity.webpageURL
+                                                context:nil
+                                               activity:activity
+                                                  scene:scene]];
 }
 
 + (void)windowSceneDidConnect {
@@ -191,6 +194,15 @@ static ANNLaunchLinkCompletion ANNWaitingLaunchLinkCompletion;
     completion(url);
 }
 
++ (void)dispatchLink:(ANNDeepLink *)link {
+    ANNAssertMainQueue();
+    if (ANNReactContentAppeared && ANNWaitingLaunchLinkCompletion == nil) {
+        [self openLink:link];
+        return;
+    }
+    [ANNPendingDeepLinks addObject:link];
+}
+
 + (void)forwardLink:(ANNDeepLink *)link through:(NS_NOESCAPE dispatch_block_t)forward {
     ANNAssertMainQueue();
     ANNDeepLink *outer = ANNForwardedSceneLink;

package/ios/Core/ANNJavaScriptCalls.h

@@ -5,28 +5,27 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /// The way of the calls JavaScript makes to `ANNTurboModule`, for a step that must come after them. A call without an
-/// answer (`mergeOptions`) leaves the JavaScript thread as it is made, goes to the module's queue (React Native's
-/// `ModuleNativeMethodCallInvoker`, a `dispatch_async` to it) and from there to the main queue (`ANNCommandRunner`):
-/// a step that takes the same three hops after them comes after them on the main queue, as each of the three runs its
-/// work in order. The module tells its call invoker and its queue when React Native made it, and that it went when
-/// React Native invalidates it (a reload). Any thread, except `afterCallsMadeSoFar:`.
+/// answer (`mergeOptions`) leaves the JavaScript thread as it is made, as a task on the main queue, the module's queue
+/// (React Native's `ModuleNativeMethodCallInvoker`, a `dispatch_async` to it), and runs whole in that task
+/// (`ANNCommandRunner`). A step sent from the JavaScript thread to the main queue after them comes after them: the
+/// JavaScript thread runs its tasks in order, and the main queue runs what it is given in the order it was given. The
+/// module tells its call invoker when React Native made it, and that it went when React Native invalidates it (a
+/// reload). Any thread, except `afterCallsMadeSoFar:`.
 @interface ANNJavaScriptCalls : NSObject
 
 - (instancetype)init NS_UNAVAILABLE;
 + (instancetype)new NS_UNAVAILABLE;
 
-/// The module of the JavaScript that runs now, its call invoker (the JavaScript thread) and its queue.
-+ (void)setCallInvoker:(nullable RCTCallInvoker *)callInvoker
-           methodQueue:(nullable dispatch_queue_t)methodQueue
-              ofModule:(id)module;
+/// The module of the JavaScript that runs now and its call invoker (the JavaScript thread).
++ (void)setCallInvoker:(nullable RCTCallInvoker *)callInvoker ofModule:(id)module;
 
 /// The module went: with no newer module told since, no JavaScript runs to wait for.
 + (void)moduleWent:(id)module;
 
 /// `block` runs on the main queue once every call JavaScript made to the module before the next task of its thread is
-/// applied on the main queue: a task on the JavaScript thread, from there one on the module's queue, from there one on
-/// the main queue. With no JavaScript to ask (none yet, a reload), at once. Main queue. A JavaScript thread that never
-/// runs the task again (its runtime went) never runs `block`: a caller that can't wait for long has a limit of its own.
+/// applied: a task on the JavaScript thread, from there one on the main queue. With no JavaScript to ask (none yet, a
+/// reload), at once. Main queue. A JavaScript thread that never runs the task again (its runtime went) never runs
+/// `block`: a caller that can't wait for long has a limit of its own.
 + (void)afterCallsMadeSoFar:(dispatch_block_t)block;
 
 @end

package/ios/Core/ANNJavaScriptCalls.mm

@@ -1,23 +1,18 @@
 #import "ANNJavaScriptCalls.h"
 #import "ANNAssert.h"
 #import <React/RCTCallInvoker.h>
-#import <React/RCTUtils.h>
 #import <ReactCommon/CallInvoker.h>
 
-// The module told last, weakly: a module that went takes its invoker and its queue with it.
+// The module told last, weakly: a module that went takes its invoker with it.
 static __weak id ANNCallsModule;
 static RCTCallInvoker *ANNCallsInvoker;
-static dispatch_queue_t ANNCallsQueue;
 
 @implementation ANNJavaScriptCalls
 
-+ (void)setCallInvoker:(RCTCallInvoker *)callInvoker
-           methodQueue:(dispatch_queue_t)methodQueue
-              ofModule:(id)module {
++ (void)setCallInvoker:(RCTCallInvoker *)callInvoker ofModule:(id)module {
     @synchronized(self) {
         ANNCallsModule = module;
         ANNCallsInvoker = callInvoker;
-        ANNCallsQueue = methodQueue;
     }
 }
 
@@ -28,33 +23,29 @@ static dispatch_queue_t ANNCallsQueue;
         }
         ANNCallsModule = nil;
         ANNCallsInvoker = nil;
-        ANNCallsQueue = nil;
     }
 }
 
 + (void)afterCallsMadeSoFar:(dispatch_block_t)block {
     ANNAssertMainQueue();
     RCTCallInvoker *callInvoker = nil;
-    dispatch_queue_t queue = nil;
     @synchronized(self) {
         if (ANNCallsModule) {
             callInvoker = ANNCallsInvoker;
-            queue = ANNCallsQueue;
         }
     }
     std::shared_ptr<facebook::react::CallInvoker> invoker =
         callInvoker ? callInvoker.callInvoker : nullptr;
-    if (!invoker || !queue) {
+    if (!invoker) {
         block();
         return;
     }
     dispatch_block_t done = [block copy];
     // The JavaScript thread runs the task after the one it runs now, which made the calls of this moment (a commit of
-    // React and its layout effects); the module's queue then has those calls before this hop, and the main queue too.
-    invoker->invokeAsync([queue, done](facebook::jsi::Runtime &) {
-        dispatch_async(queue, ^{
-          RCTExecuteOnMainQueue(done);
-        });
+    // React and its layout effects). Each of those calls went to the main queue as it was made, so this hop, sent from
+    // the same thread later, reaches the main queue behind them (a serial queue, in the order it was given).
+    invoker->invokeAsync([done](facebook::jsi::Runtime &) {
+        dispatch_async(dispatch_get_main_queue(), done);
     });
 }
 

package/ios/Core/ANNReloadCoordinator.mm

@@ -1,5 +1,4 @@
 #import "ANNReloadCoordinator.h"
-#import "ANNArrangementState.h"
 #import "ANNAssert.h"
 #import "ANNErrorTexts.h"
 #import "ANNHinge.h"
@@ -12,9 +11,8 @@
 #import "ANNPreviewInteraction.h"
 #import "ANNPreviewPush.h"
 #import "ANNRootCoordinator.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNScreenReadiness.h"
-#import "ANNScreenRegions.h"
 #import "ANNSplashViewController.h"
 #import "ANNSplitViewCommands.h"
 #import "ANNTabsPreloadWindow.h"
@@ -154,12 +152,10 @@ static BOOL ANNWatchingBundles;
     [oldScreens addObjectsFromArray:[ANNSplitViewCommands takeAllForReload]];
     // The new JavaScript counts its ids anew: nothing the safe area views of the old screens said stays ready for a new
     // screen with the same id. The old surfaces are stopped or silent. The same for what the old screens kept for
-    // JavaScript: their insets and padding, regions and arrangement states (an old screen still in a window writes no
-    // insets or regions again: its emitter is not current).
+    // JavaScript, their environment: insets and padding, regions and arrangements (an old screen still in a window
+    // writes no insets or regions again: its emitter is not current).
     [ANNScreenReadiness reset];
-    [ANNScreenInsets removeAll];
-    [ANNScreenRegions removeAll];
-    [ANNArrangementState removeAll];
+    [ANNScreenEnvironment removeAll];
     // 6. The window shows the blank screen, which counts as the splash: a reload is not a launch. The
     // reset runs from the second bundle of the process on.
     if (window) {

package/ios/Core/ANNSceneDelegate.mm

@@ -77,7 +77,7 @@
                                       [appDelegate application:application openURL:context.URL options:options];
                                     }];
     } else {
-        [ANNDeepLinkQueue openURLContext:context ofScene:scene];
+        [ANNDeepLinkQueue dispatchURLContext:context ofScene:scene];
     }
 }
 
@@ -95,7 +95,7 @@
                                                }];
                                       }];
     } else if ([activity.activityType isEqualToString:NSUserActivityTypeBrowsingWeb]) {
-        [ANNDeepLinkQueue openUserActivity:activity ofScene:scene];
+        [ANNDeepLinkQueue dispatchUserActivity:activity ofScene:scene];
     }
 }
 

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

@@ -45,8 +45,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 +56,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];

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

package/ios/Layouts/Arrangement/ANNArrangementState.mm

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

package/ios/Layouts/Arrangement/ANNArrangementViewController.mm

@@ -2,10 +2,10 @@
 
 #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 270100
 
-#import "ANNArrangementState.h"
 #import "ANNComponentViewController.h"
 #import "ANNEventContract.h"
 #import "ANNExternalViewController.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNShownScreens.h"
 #import "ANNUtils.h"
 
@@ -298,9 +298,9 @@ static BOOL ANNIsShown(UIViewController *screen, UIArrangementViewState *state,
          ofScreen:(UIViewController *)screen
      eventEmitter:(ANNEventEmitter *)eventEmitter {
     if (ANNKeepsState(screen)) {
-        [ANNArrangementState setState:state
-                          forScreenId:screen.layoutInfo.componentId
-                         eventEmitter:eventEmitter];
+        [ANNScreenEnvironment setArrangement:state
+                                 forScreenId:screen.layoutInfo.componentId
+                                eventEmitter:eventEmitter];
     }
 }
 

package/ios/Layouts/Root/ANNRootCoordinator.mm

@@ -83,6 +83,10 @@ typedef NS_ENUM(NSInteger, ANNRootShowState) {
 @property(nonatomic, strong, nullable) ANNFrameDriver *driver;
 @property(nonatomic, copy, nullable) NSArray<ANNViewTracks *> *tracks;
 @property(nonatomic) BOOL animating;
+// The new root's view takes no touches while it animates, and whether it took them before: Core Animation draws it
+// elsewhere than where it is (the view itself stays in place), so a tap on the old screen would reach it.
+@property(nonatomic, weak, nullable) UIView *untouchableRoot;
+@property(nonatomic) BOOL rootTouchesBefore;
 @property(nonatomic) BOOL layersShown;
 @end
 
@@ -533,20 +537,43 @@ static __weak ANNRootShow *ANNAnimatingShow;
     NSMutableArray<ANNViewTracks *> *tracks = [NSMutableArray new];
     ANNViewAnimationOptions *enter = [ANNAnimationRules playingSide:animation.enter];
     ANNViewAnimationOptions *exit = [ANNAnimationRules playingSide:animation.exit];
-    if (enter && rootView) {
-        [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
-                                                         side:enter
-                                                  alphaBefore:rootView.alpha]];
-    }
-    if (exit && snapshot) {
-        [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
-                                                         side:exit
-                                                  alphaBefore:snapshot.alpha]];
-    }
     NSTimeInterval length =
         MAX([ANNAnimationRules lengthOfSide:enter], [ANNAnimationRules lengthOfSide:exit]);
+    if (UIAccessibilityIsReduceMotionEnabled() && length > 0) {
+        // With the system's Reduce Motion on, nothing moves: the new root fades in over the snapshot in the same
+        // length, or the snapshot fades out without a new root's view.
+        if (rootView) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
+                                                         fadeFrom:0
+                                                               to:rootView.alpha
+                                                         duration:length
+                                                      alphaBefore:rootView.alpha]];
+        } else if (snapshot) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
+                                                         fadeFrom:snapshot.alpha
+                                                               to:0
+                                                         duration:length
+                                                      alphaBefore:snapshot.alpha]];
+        }
+    } else {
+        if (enter && rootView) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:rootView
+                                                             side:enter
+                                                      alphaBefore:rootView.alpha]];
+        }
+        if (exit && snapshot) {
+            [tracks addObject:[[ANNViewTracks alloc] initWithView:snapshot
+                                                             side:exit
+                                                      alphaBefore:snapshot.alpha]];
+        }
+    }
     show.tracks = tracks;
     show.animating = YES;
+    if (rootView) {
+        show.untouchableRoot = rootView;
+        show.rootTouchesBefore = rootView.userInteractionEnabled;
+        rootView.userInteractionEnabled = NO;
+    }
     ANNAnimatingShow = show;
     show.driver = [[ANNFrameDriver alloc] initWithClients:tracks length:length];
     // The layers' state from here on: the chain may start and a newer `setRoot` stops it.
@@ -583,8 +610,8 @@ static __weak ANNRootShow *ANNAnimatingShow;
     [self finishLayersOf:show];
 }
 
-// The animation stops at its end state (its end, a newer `setRoot`, a reload, a failure): the views get back what they
-// had and the snapshot goes.
+// The animation stops (its end, a newer `setRoot`, a reload, a failure): its animations go, the views get back what
+// they had and the snapshot goes.
 + (void)stopAnimationOf:(ANNRootShow *)show {
     if (!show.animating) {
         return;
@@ -592,13 +619,16 @@ static __weak ANNRootShow *ANNAnimatingShow;
     show.animating = NO;
     [show.driver cancel];
     show.driver = nil;
+    show.untouchableRoot.userInteractionEnabled = show.rootTouchesBefore;
+    show.untouchableRoot = nil;
     for (ANNViewTracks *tracks in show.tracks) {
         [tracks restore];
     }
     show.tracks = nil;
-    // UIKit works out the safe area of the window's root view from where the view is drawn: moved away from the top
-    // edge by `enter` (from the bottom, scaled down) it has no top inset, and putting the transform back doesn't make
-    // UIKit work it out again. A layout now gives the root, its bars and its screens the window's safe area back.
+    // UIKit works out the safe area of the window's root view from where the view is: moved away from the top edge by
+    // a transform it has no top inset, and putting the transform back doesn't make UIKit work it out again. `enter`
+    // moves only what Core Animation draws now; the layout stays, so the root, its bars and its screens end with the
+    // window's safe area whatever moved them.
     UIView *rootView = show.root.viewIfLoaded;
     [rootView setNeedsLayout];
     [rootView layoutIfNeeded];

package/ios/Layouts/Screen/ANNComponentViewController.h

@@ -11,8 +11,8 @@ NS_ASSUME_NONNULL_BEGIN
 ///
 /// Its view has the size of the screen of the navigation window's scene; the content sits in the root frame, by the one
 /// "under bars" rule (`ANNScreenBars`). Every recompute of the frame (a layout, a change of the safe area or the
-/// traits, `mergeOptions`, an appearance) gives the modules the screen's insets, padding and regions
-/// (`ANNScreenInsets`, `ANNScreenRegions`). Its presenter is an `ANNComponentPresenter`.
+/// traits, `mergeOptions`, an appearance) gives the store the screen's insets, padding and regions
+/// (`ANNScreenEnvironment`). Its presenter is an `ANNComponentPresenter`.
 ///
 /// The screen answers UIKit's questions about the system UI (native screens too): the status bar's style and visibility
 /// (never animated), the orientations, the home indicator, the deferred edges and the vertical bars, from its resolved

package/ios/Layouts/Screen/ANNComponentViewController.mm

@@ -1,9 +1,7 @@
 #import "ANNComponentViewController.h"
 #import "ANNAppearanceDispatcher.h"
-#import "ANNArrangementState.h"
 #import "ANNBottomTabsController.h"
 #import "ANNComponentPresenter.h"
-#import "ANNEventContract.h"
 #import "ANNHinge.h"
 #import "ANNKeyCommands.h"
 #import "ANNNodeRegistry.h"
@@ -11,11 +9,12 @@
 #import "ANNPendingLayers.h"
 #import "ANNPreviewPush.h"
 #import "ANNScreenBars.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNScreenReadiness.h"
 #import "ANNScreenRegions.h"
 #import "ANNScreenSafeArea.h"
 #import "ANNStackController.h"
+#import "ANNSurfaceHostingView.h"
 #import "ANNSystemUI.h"
 #import "ANNTopBarPresenter.h"
 #import "ANNUtils.h"
@@ -105,10 +104,12 @@
 }
 
 // UIKit names the size transition as the moment the status bar's frame changes (a rotation, a new window size): the
-// blur follows it along the animation and takes the final frame at its end.
+// blur follows it along the animation and takes the final frame at its end. The React content takes its new size
+// without animation meanwhile, or what it draws itself is stretched along the animation (`ANNSurfaceHostingView`).
 - (void)viewWillTransitionToSize:(CGSize)size
        withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
     [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
+    [ANNSurfaceHostingView followSizeTransition:coordinator];
     __weak ANNComponentViewController *weakSelf = self;
     [coordinator
         animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> context) {
@@ -432,7 +433,7 @@
     return UIRectEdgeNone;
 }
 
-// The insets and the padding of a React screen or a slot screen go to the module, which keeps them, gives JavaScript
+// The insets and the padding of a React screen or a slot screen go to the store, which keeps them, gives JavaScript
 // what still covers the content and tells only of changes; the regions in the same pass. Only in a window and with an
 // id; never after the destroy, which removed them (a late layout would bring them back), nor for the JavaScript that
 // went (an old screen held after a reload: the new JavaScript may give its id to a new screen).
@@ -453,22 +454,18 @@
     UINavigationController *stack = [self shownNavigation];
     ANNScreenPaddingContext context = {
         .inStack = stack != nil,
-        // The stack's toolbar, by the rule the stack shows it with: one that `topBar.hideOnScroll`
-        // hid with the bar still counts.
-        .stackShowsToolbar = stack != nil && options.toolbar.shouldShow,
-        .windowBottomSafeArea = window.safeAreaInsets.bottom,
         .verticalBarSide = [self verticalBarSide],
     };
     UIEdgeInsets padding = ANNScreenPadding(insets, options, context);
-    [ANNScreenInsets setInsets:insets
-                       padding:padding
-                   forScreenId:componentId
-                  eventEmitter:eventEmitter];
+    [ANNScreenEnvironment setInsets:insets
+                            padding:padding
+                        forScreenId:componentId
+                       eventEmitter:eventEmitter];
     [self updateRegions];
 }
 
 // The regions in the same pass, and on the next turn after a change of the hinge's state (`hingeDidChange:`). Nil
-// before iOS 27.1: nothing to keep. An empty first result is not sent.
+// before iOS 27.1: nothing to keep. The store neither keeps nor sends an empty first result.
 - (void)updateRegions {
     UIView<ANNComponentProtocol> *content = _reactView;
     NSString *componentId = self.layoutInfo.componentId;
@@ -483,12 +480,7 @@
     if (!regions) {
         return;
     }
-    const auto &keys = ANNEventContract.ScreenRegionsChanged;
-    BOOL empty = [regions[keys.division] count] == 0 && [regions[keys.occlusion] count] == 0;
-    if (empty && ![ANNScreenRegions regionsForScreenId:componentId]) {
-        return;
-    }
-    [ANNScreenRegions setRegions:regions forScreenId:componentId eventEmitter:eventEmitter];
+    [ANNScreenEnvironment setRegions:regions forScreenId:componentId eventEmitter:eventEmitter];
 }
 
 - (void)hingeDidChange:(NSNotification *)notification {
@@ -690,9 +682,7 @@
     // its destroy, as at a reload) keeps it.
     NSString *componentId = self.layoutInfo.componentId;
     if (componentId && ![ANNNodeRegistry nodeForComponentId:componentId]) {
-        [ANNScreenInsets removeScreenId:componentId];
-        [ANNScreenRegions removeScreenId:componentId];
-        [ANNArrangementState removeScreenId:componentId];
+        [ANNScreenEnvironment removeScreenId:componentId];
         [ANNScreenReadiness removeScreenId:componentId];
     }
 }

package/ios/Layouts/Screen/ANNPreviewInteraction.h

@@ -9,15 +9,18 @@
 
 /**
  * Previews `preview` from `view`, the component view with the tag `reactTag`, and replaces an earlier
- * preview of the view. `commit` runs on a tap on the preview and returns whether it showed the
- * screen; the preview goes then, as the push it stands for is done. `dismissed` runs once when the
- * preview goes without being shown as a screen: replaced by another preview of the view, after
- * Fabric gave the view to another component, or when `source`, the screen of the view, goes.
+ * preview of the view. `prepare` runs as each press starts, before the menu shows the preview: it
+ * renders the screen if it hasn't yet, and returns NO when the preview went instead (no menu shows
+ * then). `commit` runs on a tap on the preview and returns whether it showed the screen; the
+ * preview goes then, as the push it stands for is done. `dismissed` runs once when the preview
+ * goes without being shown as a screen: replaced by another preview of the view, after Fabric gave
+ * the view to another component, or when `source`, the screen of the view, goes.
  */
 + (void)attachPreview:(UIViewController *)preview
                toView:(UIView *)view
              reactTag:(NSInteger)reactTag
                source:(UIViewController *)source
+              prepare:(BOOL (^)(void))prepare
                commit:(BOOL (^)(void))commit
             dismissed:(void (^)(void))dismissed;