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

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/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/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/ANNSplashViewController.h

@@ -7,9 +7,11 @@ NS_ASSUME_NONNULL_BEGIN
 /// either at once. The status bar follows the Info.plist keys `UIStatusBarStyle` and `UIStatusBarHidden`. Main queue.
 @interface ANNSplashViewController : UIViewController
 
-/// The copy of the launch screen: the initial view controller of `UILaunchStoryboardName` as a child (a storyboard
-/// that doesn't load: the first view of the nib of that name), else the legacy launch images, full screen. Nil when the
-/// app has none of these: the window then has no root view controller until the first root.
+/// The copy of the launch screen. When iOS builds it from the Info.plist (`UILaunchScreen`, or the default of
+/// `UILaunchScreens`), the same color, image and bars as plain views; else the initial view controller of
+/// `UILaunchStoryboardName` as a child (a storyboard that doesn't load: the first view of the nib of that name), else
+/// the legacy launch images, full screen. Nil when the app has none of these: the window then has no root view
+/// controller until the first root.
 + (nullable instancetype)launchScreenCopyWithBounds:(CGRect)bounds;
 
 /// The blank screen after a reload: clear when the default options give the window a color (`window.backgroundColor`),

package/ios/Layouts/Root/ANNSplashViewController.mm

@@ -34,9 +34,63 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     return names;
 }
 
+static NSDictionary *ANNDictionaryOrNil(id value) {
+    return [value isKindOfClass:NSDictionary.class] ? value : nil;
+}
+
+static NSString *ANNStringOrNil(id value) {
+    return [value isKindOfClass:NSString.class] && [value length] > 0 ? value : nil;
+}
+
+// The definition that a plural key (`UILaunchScreens`, `UILaunchStoryboards`) marks as its default.
+static NSDictionary *ANNDefaultDefinition(id plural, NSString *definitionsKey,
+                                          NSString *identifierKey, NSString *defaultKey) {
+    NSDictionary *dictionary = ANNDictionaryOrNil(plural);
+    NSArray *definitions = dictionary[definitionsKey];
+    NSString *defaultIdentifier = ANNStringOrNil(dictionary[defaultKey]);
+    if (![definitions isKindOfClass:NSArray.class] || !defaultIdentifier) {
+        return nil;
+    }
+    for (id definition in definitions) {
+        NSDictionary *entry = ANNDictionaryOrNil(definition);
+        if ([entry[identifierKey] isEqual:defaultIdentifier]) {
+            return entry;
+        }
+    }
+    return nil;
+}
+
+// The launch screen that iOS builds from the Info.plist without a storyboard, or nil when it shows a storyboard. Of
+// `UILaunchStoryboardName`, `UILaunchScreen`, the default of `UILaunchStoryboards` and the default of
+// `UILaunchScreens`, the last one present wins (SplashBoard's `XBApplicationLaunchCompatibilityInfo`). A launch by a
+// link that `UILaunchScreens` maps to a screen of its own still gets the default here.
+static NSDictionary *ANNLaunchScreenConfiguration(NSBundle *bundle) {
+    NSDictionary *screen =
+        ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchScreens"],
+                             @"UILaunchScreenDefinitions", @"UILaunchScreenIdentifier",
+                             @"UIDefaultLaunchScreen");
+    if (screen) {
+        return screen;
+    }
+    if (ANNDefaultDefinition([bundle objectForInfoDictionaryKey:@"UILaunchStoryboards"],
+                             @"UILaunchStoryboardDefinitions", @"UILaunchStoryboardIdentifier",
+                             @"UIDefaultLaunchStoryboard")) {
+        return nil;
+    }
+    return ANNDictionaryOrNil([bundle objectForInfoDictionaryKey:@"UILaunchScreen"]);
+}
+
 @implementation ANNSplashViewController {
     UIViewController *_content;
     UIView *_contentView;
+    NSDictionary *_launchScreen;
+    // The parts of a launch screen built from `UILaunchScreen`, laid out once the safe area is known.
+    UIImageView *_imageView;
+    BOOL _imageRespectsSafeArea;
+    UINavigationBar *_navigationBar;
+    UIImageView *_navigationBarImageView;
+    UIView *_bottomBar;
+    UIImageView *_bottomBarImageView;
 }
 
 - (instancetype)initWithContent:(UIViewController *)content
@@ -52,6 +106,12 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
 
 + (instancetype)launchScreenCopyWithBounds:(CGRect)bounds {
     NSBundle *bundle = NSBundle.mainBundle;
+    NSDictionary *launchScreen = ANNLaunchScreenConfiguration(bundle);
+    if (launchScreen) {
+        ANNSplashViewController *copy = [[self alloc] initWithContent:nil contentView:nil blank:NO];
+        copy->_launchScreen = launchScreen;
+        return copy;
+    }
     NSString *storyboardName = [bundle objectForInfoDictionaryKey:@"UILaunchStoryboardName"];
     if ([storyboardName isKindOfClass:NSString.class] && storyboardName.length > 0) {
         UIViewController *initial = nil;
@@ -97,6 +157,10 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
         view.backgroundColor = windowHasColor ? UIColor.clearColor : UIColor.systemBackgroundColor;
         return;
     }
+    if (_launchScreen) {
+        [self buildLaunchScreen];
+        return;
+    }
     UIView *contentView = _contentView;
     if (_content) {
         [self addChildViewController:_content];
@@ -109,6 +173,89 @@ static NSArray<NSString *> *ANNLegacyLaunchImageNames(CGFloat height) {
     [_content didMoveToParentViewController:self];
 }
 
+#pragma mark - The launch screen of `UILaunchScreen`
+
+// Built as SplashBoard builds it: the named color over the whole screen, else the system background; the named image
+// at its own size in the middle of the screen or of its safe area, stretched instead when the asset has slicing; a tab
+// bar or a toolbar at the bottom and a navigation bar at the top, the system's own bars, or the bar's named image
+// stretched over the bar's place. A name the asset catalog doesn't have leaves its part out, as iOS does.
+- (void)buildLaunchScreen {
+    UIView *view = self.view;
+    NSString *colorName = ANNStringOrNil(_launchScreen[@"UIColorName"]);
+    UIColor *color = colorName ? [UIColor colorNamed:colorName] : nil;
+    view.backgroundColor = color ?: UIColor.systemBackgroundColor;
+
+    NSString *imageName = ANNStringOrNil(_launchScreen[@"UIImageName"]);
+    UIImage *image = imageName ? [UIImage imageNamed:imageName] : nil;
+    if (image) {
+        _imageView = [[UIImageView alloc] initWithImage:image];
+        _imageView.contentMode = UIEdgeInsetsEqualToEdgeInsets(image.capInsets, UIEdgeInsetsZero)
+                                     ? UIViewContentModeCenter
+                                     : UIViewContentModeScaleToFill;
+        id respects = _launchScreen[@"UIImageRespectsSafeAreaInsets"];
+        _imageRespectsSafeArea = [respects respondsToSelector:@selector(boolValue)] &&
+                                 [respects boolValue];
+        [view addSubview:_imageView];
+    }
+
+    // A toolbar takes the bottom before a tab bar; a navigation bar comes on top of either.
+    id toolbar = _launchScreen[@"UIToolbar"];
+    id tabBar = _launchScreen[@"UITabBar"];
+    if (toolbar || tabBar) {
+        _bottomBar = toolbar ? [UIToolbar new] : [UITabBar new];
+        _bottomBarImageView = [self addBar:_bottomBar configuration:toolbar ?: tabBar];
+    }
+    id navigationBar = _launchScreen[@"UINavigationBar"];
+    if (navigationBar) {
+        _navigationBar = [UINavigationBar new];
+        _navigationBarImageView = [self addBar:_navigationBar configuration:navigationBar];
+    }
+}
+
+// Adds the bar, or its image in its place when its configuration names one that loads.
+- (UIImageView *)addBar:(UIView *)bar configuration:(id)configuration {
+    NSString *name = ANNStringOrNil(ANNDictionaryOrNil(configuration)[@"UIImageName"]);
+    UIImage *image = name ? [UIImage imageNamed:name] : nil;
+    UIImageView *imageView = image ? [[UIImageView alloc] initWithImage:image] : nil;
+    bar.hidden = imageView != nil;
+    [self.view addSubview:bar];
+    if (imageView) {
+        [self.view addSubview:imageView];
+    }
+    return imageView;
+}
+
+// The safe area is known only in the window, so the parts are laid out here, after every change of it.
+- (void)viewDidLayoutSubviews {
+    [super viewDidLayoutSubviews];
+    if (!_launchScreen) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    _imageView.frame =
+        _imageRespectsSafeArea ? UIEdgeInsetsInsetRect(bounds, safeArea) : bounds;
+    [self layOutBar:_bottomBar imageView:_bottomBarImageView atBottom:YES];
+    [self layOutBar:_navigationBar imageView:_navigationBarImageView atBottom:NO];
+}
+
+// A bar is as tall as UIKit makes it, plus the safe area on its edge of the screen, and as wide as the screen.
+- (void)layOutBar:(UIView *)bar
+        imageView:(UIImageView *)imageView
+         atBottom:(BOOL)atBottom {
+    if (!bar) {
+        return;
+    }
+    CGRect bounds = self.view.bounds;
+    UIEdgeInsets safeArea = self.view.safeAreaInsets;
+    CGFloat height = [bar sizeThatFits:bounds.size].height +
+                     (atBottom ? safeArea.bottom : safeArea.top);
+    CGFloat y = atBottom ? CGRectGetMaxY(bounds) - height : CGRectGetMinY(bounds);
+    CGRect frame = CGRectMake(CGRectGetMinX(bounds), y, CGRectGetWidth(bounds), height);
+    bar.frame = frame;
+    imageView.frame = frame;
+}
+
 #pragma mark - The status bar, as the launch screen had it
 
 - (UIStatusBarStyle)preferredStatusBarStyle {

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,7 +9,7 @@
 #import "ANNPendingLayers.h"
 #import "ANNPreviewPush.h"
 #import "ANNScreenBars.h"
-#import "ANNScreenInsets.h"
+#import "ANNScreenEnvironment.h"
 #import "ANNScreenReadiness.h"
 #import "ANNScreenRegions.h"
 #import "ANNScreenSafeArea.h"
@@ -432,7 +430,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 +451,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 +477,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 +679,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;
 

package/ios/Layouts/Screen/ANNPreviewInteraction.mm

@@ -24,15 +24,23 @@ static NSMutableSet *ANNPreviews(void) {
 @implementation ANNPreviewInteraction {
     UIViewController *_preview;
     NSInteger _reactTag;
+    __weak UIViewController *_source;
+    BOOL (^_prepare)(void);
     BOOL (^_commit)(void);
     void (^_dismissed)(void);
     UIContextMenuInteraction *_interaction;
+    // The snapshots of the view that the menu of this press lifts and puts back, over the view until
+    // the menu is gone. Each press has its own list: a new press may start while the last menu goes.
+    NSMutableArray<UIView *> *_snapshots;
+    // The list of the menu that goes now: its end removes them.
+    __weak NSMutableArray<UIView *> *_endingSnapshots;
 }
 
 + (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 {
     if (!view || !preview) {
@@ -45,6 +53,8 @@ static NSMutableSet *ANNPreviews(void) {
     ANNPreviewInteraction *previewInteraction = [ANNPreviewInteraction new];
     previewInteraction->_preview = preview;
     previewInteraction->_reactTag = reactTag;
+    previewInteraction->_source = source;
+    previewInteraction->_prepare = [prepare copy];
     previewInteraction->_commit = [commit copy];
     previewInteraction->_dismissed = [dismissed copy];
     previewInteraction->_interaction =
@@ -91,7 +101,9 @@ static NSMutableSet *ANNPreviews(void) {
     [view removeInteraction:_interaction];
     // A tap's commit animation may still run: a preview that went, its screen destroyed and its push failed, is not
     // pushed when the animation ends.
+    _prepare = nil;
     _commit = nil;
+    [ANNPreviewInteraction removeSnapshots:_snapshots];
     void (^dismissed)(void) = _dismissed;
     _dismissed = nil;
     if (dismissed) {
@@ -116,6 +128,18 @@ static NSMutableSet *ANNPreviews(void) {
         [self detach];
         return nil;
     }
+    // UIKit ends a lift that never became a menu too (the touch ended before the long press); should
+    // it not, the snapshot of that press goes now.
+    if (_snapshots != _endingSnapshots) {
+        [ANNPreviewInteraction removeSnapshots:_snapshots];
+    }
+    _snapshots = [NSMutableArray new];
+    // UIKit asks for the configuration as the press starts, about half a second before it shows the preview: the
+    // screen renders now, so that its content is there by then.
+    if (_prepare && !_prepare()) {
+        [self detach];
+        return nil;
+    }
     UIViewController *preview = _preview;
     NSArray *actions = preview.resolveOptions.preview.actions;
     return [UIContextMenuConfiguration
@@ -129,6 +153,23 @@ static NSMutableSet *ANNPreviews(void) {
                      }];
 }
 
+// The menu goes: the snapshots of its press go once it is gone. UIKit asks for the one
+// it goes back to after this call, so the list is read at the end, not now.
+- (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
+       willEndForConfiguration:(UIContextMenuConfiguration *)configuration
+                      animator:(id<UIContextMenuInteractionAnimating>)animator {
+    NSMutableArray<UIView *> *snapshots = _snapshots;
+    _endingSnapshots = snapshots;
+    void (^remove)(void) = ^{
+      [ANNPreviewInteraction removeSnapshots:snapshots];
+    };
+    if (animator) {
+        [animator addCompletion:remove];
+    } else {
+        dispatch_async(dispatch_get_main_queue(), remove);
+    }
+}
+
 - (void)contextMenuInteraction:(UIContextMenuInteraction *)interaction
     willPerformPreviewActionForMenuWithConfiguration:(UIContextMenuConfiguration *)configuration
                                             animator:(id<UIContextMenuInteractionCommitAnimating>)
@@ -148,24 +189,45 @@ static NSMutableSet *ANNPreviews(void) {
 
 #pragma mark - Targeted previews
 
-// The view the menu lifts from and goes back to: a snapshot of the source view in its window. With
-// the source view itself UIKit adds its views next to it, among the React views of its parent, and
-// Fabric then mounts and unmounts at the wrong places.
+// The view the menu lifts from and goes back to: a snapshot of the source view, laid over it in the
+// view of its screen, the core's own (in its window when the view is elsewhere), so that it goes with
+// the screen (a pop right after the menu). With the source view itself UIKit adds its views next to
+// it, among the React views of its parent, and Fabric then mounts and unmounts at the wrong places.
+// A snapshot out of the window, with only a target there, iOS 27 doesn't lift: it dims it in place.
 - (UITargetedPreview *)snapshotPreviewOf:(UIView *)view {
-    UIWindow *window = view.window;
+    UIView *container = _source.viewIfLoaded;
+    if (!container || ![view isDescendantOfView:container]) {
+        container = view.window;
+    }
+    // A screen out of its window (a command took it away while the menu showed) has no place for it:
+    // UIKit needs the view in a window.
+    if (!container.window) {
+        return nil;
+    }
     UIView *snapshot = [view snapshotViewAfterScreenUpdates:NO];
-    if (!window || !snapshot) {
+    if (!snapshot) {
         return nil;
     }
+    snapshot.frame = [view convertRect:view.bounds toView:container];
+    snapshot.userInteractionEnabled = NO;
+    snapshot.accessibilityElementsHidden = YES;
+    [container addSubview:snapshot];
+    if (!_snapshots) {
+        _snapshots = [NSMutableArray new];
+    }
+    [_snapshots addObject:snapshot];
     UIPreviewParameters *parameters = [UIPreviewParameters new];
     parameters.backgroundColor = UIColor.clearColor;
     parameters.visiblePath = [UIBezierPath bezierPathWithRoundedRect:view.bounds
                                                         cornerRadius:view.layer.cornerRadius];
-    CGPoint center = [view convertPoint:CGPointMake(CGRectGetMidX(view.bounds),
-                                                    CGRectGetMidY(view.bounds))
-                                 toView:window];
-    UIPreviewTarget *target = [[UIPreviewTarget alloc] initWithContainer:window center:center];
-    return [[UITargetedPreview alloc] initWithView:snapshot parameters:parameters target:target];
+    return [[UITargetedPreview alloc] initWithView:snapshot parameters:parameters];
+}
+
++ (void)removeSnapshots:(NSMutableArray<UIView *> *)snapshots {
+    for (UIView *snapshot in snapshots) {
+        [snapshot removeFromSuperview];
+    }
+    [snapshots removeAllObjects];
 }
 
 - (UITargetedPreview *)contextMenuInteraction:(UIContextMenuInteraction *)interaction