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

package/ios/Animations/Elements/ANNSharedElementFlight.h

@@ -9,9 +9,9 @@ NS_ASSUME_NONNULL_BEGIN
 /// One shared pair in flight: a plain view of the core, the copy, flies in the transition's container from the `from`
 /// view to the `to` view with two pictures of them (`renderInContext:` at the screen's scale). The React views are
 /// neither moved nor changed: they are only `hidden` while the copy flies and get back what they had before the
-/// transition completes. All geometry is in the container's coordinates. Each frame the copy's size, center, visible
-/// part (a mask), corner radius and layer transform go from the `from` values to the `to` values on the pair's curve,
-/// delay and duration.
+/// transition completes. All geometry is in the container's coordinates. The copy's size, center, visible part (a
+/// mask), corner radius and layer transform go from the `from` values to the `to` values on the pair's curve, delay and
+/// duration, in Core Animation's animations of the copy's layers.
 ///
 /// A view (not a text): both pictures fill the copy, the copy clips to its corners, the `to` picture fades in over the
 /// flight. A text (React's paragraph): the pictures keep their aspect, as tall as the copy, at the line's start (the

package/ios/Animations/Elements/ANNSharedElementFlight.mm

@@ -29,6 +29,21 @@ typedef struct {
     BOOL clipped;
 } ANNFlightEnd;
 
+// What the copy shows at one time: its size, center, transform and corners, its two pictures' frames and alphas, and
+// its visible part (in the copy's coordinates) with its corners.
+typedef struct {
+    CGSize size;
+    CGPoint center;
+    CATransform3D transform;
+    CGFloat cornerRadius;
+    CGRect fromFrame;
+    CGRect toFrame;
+    CGFloat fromAlpha;
+    CGFloat toAlpha;
+    CGRect mask;
+    CGFloat maskRadius;
+} ANNFlightState;
+
 static BOOL ANNIsText(UIView *view) {
     static Class paragraph;
     static dispatch_once_t once;
@@ -200,6 +215,30 @@ static UIImage *ANNPictureOf(UIView *view) {
     }];
 }
 
+// A layer at `frame` in its superlayer: its bounds and its position (its anchor is its center).
+static void ANNPlaceLayer(CALayer *layer, CGRect frame) {
+    layer.bounds = CGRectMake(0, 0, frame.size.width, frame.size.height);
+    layer.position = CGPointMake(CGRectGetMidX(frame), CGRectGetMidY(frame));
+}
+
+// The core's animation of `keyPath` on `layer` (`ANNKeyframes`), under its key.
+static void ANNAddKeyframes(CALayer *layer, NSString *keyPath, NSArray *values,
+                            NSArray<NSNumber *> *times, NSTimeInterval length) {
+    CAKeyframeAnimation *animation = ANNKeyframes(keyPath, values, times, length);
+    if (animation) {
+        [layer addAnimation:animation forKey:ANNAnimationKey(keyPath)];
+    }
+}
+
+// The bounds and the position of a layer at `frame`, as values of its animations.
+static NSValue *ANNBoundsValue(CGRect frame) {
+    return [NSValue valueWithCGRect:CGRectMake(0, 0, frame.size.width, frame.size.height)];
+}
+
+static NSValue *ANNPositionValue(CGRect frame) {
+    return [NSValue valueWithCGPoint:CGPointMake(CGRectGetMidX(frame), CGRectGetMidY(frame))];
+}
+
 @implementation ANNSharedElementFlight {
     __weak UIView *_fromView;
     __weak UIView *_toView;
@@ -208,7 +247,9 @@ static UIImage *ANNPictureOf(UIView *view) {
     UIView *_copy;
     UIImageView *_fromPicture;
     UIImageView *_toPicture;
-    CAShapeLayer *_mask;
+    // The visible part of the copy: a plain layer with corners, as Core Animation can't animate a path whose corners
+    // change.
+    CALayer *_mask;
     ANNFlightEnd _from;
     ANNFlightEnd _to;
     ANNTrack *_track;
@@ -343,7 +384,8 @@ static UIImage *ANNPictureOf(UIView *view) {
     // A text's pictures are neither clipped nor masked.
     _copy.clipsToBounds = !_text;
     if (!_text && (_from.clipped || _to.clipped)) {
-        _mask = [CAShapeLayer layer];
+        _mask = [CALayer layer];
+        _mask.backgroundColor = UIColor.blackColor.CGColor;
         _copy.layer.mask = _mask;
     }
     [_copy addSubview:_fromPicture];
@@ -360,72 +402,168 @@ static UIImage *ANNPictureOf(UIView *view) {
     [container addSubview:_copy];
     from.hidden = YES;
     to.hidden = YES;
-    [self applyAtTime:0];
+    [self placeAtTime:0];
 }
 
 - (UIView *)copyView {
     return _copy;
 }
 
-#pragma mark - ANNFrameClient
-
-- (NSTimeInterval)endTime {
-    return _track.endTime;
-}
-
-- (void)applyAtTime:(NSTimeInterval)time {
-    if (_restored) {
-        return;
-    }
+// The copy's whole state at `time`: its own geometry, its pictures' and its visible part's.
+- (ANNFlightState)stateAtTime:(NSTimeInterval)time {
+    ANNFlightState state;
     double f = [_track fractionAt:time];
-    CGSize size = ANNInterpolateSize(_from.size, _to.size, f);
-    _copy.layer.transform = CATransform3DIdentity;
-    _copy.bounds = CGRectMake(0, 0, size.width, size.height);
-    _copy.center = ANNInterpolatePoint(_from.center, _to.center, f);
-    _copy.layer.transform =
-        ANNTransformOfParts(ANNInterpolateTransformParts(_from.parts, _to.parts, f));
+    state.size = ANNInterpolateSize(_from.size, _to.size, f);
+    state.center = ANNInterpolatePoint(_from.center, _to.center, f);
+    state.transform = ANNTransformOfParts(ANNInterpolateTransformParts(_from.parts, _to.parts, f));
+    state.cornerRadius = 0;
+    state.mask = CGRectZero;
+    state.maskRadius = 0;
     if (_text) {
-        [self placeTextPicturesAtTime:time size:size];
-        return;
+        [self placeTextPicturesOf:&state atTime:time];
+        return state;
     }
-    _copy.layer.cornerRadius = ANNInterpolateNumber(_from.cornerRadius, _to.cornerRadius, f);
-    _fromPicture.frame = _copy.bounds;
-    _toPicture.frame = _copy.bounds;
-    _fromPicture.alpha = 1;
-    _toPicture.alpha = (CGFloat)f;
+    state.cornerRadius = ANNInterpolateNumber(_from.cornerRadius, _to.cornerRadius, f);
+    CGRect whole = CGRectMake(0, 0, state.size.width, state.size.height);
+    state.fromFrame = whole;
+    state.toFrame = whole;
+    state.fromAlpha = 1;
+    state.toAlpha = (CGFloat)f;
     if (_mask) {
         CGRect fromWhole = CGRectMake(0, 0, _from.size.width, _from.size.height);
         CGRect toWhole = CGRectMake(0, 0, _to.size.width, _to.size.height);
         CGRect fromVisible = _from.clipped ? _from.visible : fromWhole;
         CGRect toVisible = _to.clipped ? _to.visible : toWhole;
-        CGRect visible = ANNInterpolateRect(fromVisible, toVisible, f);
+        state.mask = ANNInterpolateRect(fromVisible, toVisible, f);
+        // At most half the shorter side, as a rounded path has it.
         CGFloat radius = ANNInterpolateNumber(_from.visibleRadius, _to.visibleRadius, f);
-        _mask.frame = _copy.bounds;
-        _mask.path = [UIBezierPath bezierPathWithRoundedRect:visible cornerRadius:radius].CGPath;
+        CGFloat half = MIN(state.mask.size.width, state.mask.size.height) / 2;
+        state.maskRadius = MAX(MIN(radius, half), 0);
     }
+    return state;
 }
 
 // The text's pictures keep their aspect at the height of the copy, at the line's start; they swap by the clock,
 // linearly, in the first quarter of the flight when the text grows, in the last when it shrinks.
-- (void)placeTextPicturesAtTime:(NSTimeInterval)time size:(CGSize)size {
-    for (UIImageView *picture in @[ _fromPicture, _toPicture ]) {
-        CGSize imageSize = picture.image.size;
-        CGFloat height = size.height;
+- (void)placeTextPicturesOf:(ANNFlightState *)state atTime:(NSTimeInterval)time {
+    CGRect frames[2];
+    UIImageView *pictures[2] = {_fromPicture, _toPicture};
+    for (int index = 0; index < 2; index++) {
+        CGSize imageSize = pictures[index].image.size;
+        CGFloat height = state->size.height;
         CGFloat width = imageSize.height > 0 ? imageSize.width * height / imageSize.height : 0;
-        CGFloat x = _rightToLeft ? size.width - width : 0;
-        picture.frame = CGRectMake(x, 0, width, height);
+        CGFloat x = _rightToLeft ? state->size.width - width : 0;
+        frames[index] = CGRectMake(x, 0, width, height);
     }
+    state->fromFrame = frames[0];
+    state->toFrame = frames[1];
+    double swap = [self swapAtTime:time];
+    state->fromAlpha = (CGFloat)(1 - swap);
+    state->toAlpha = (CGFloat)swap;
+}
+
+// The quarter of the flight the text's pictures swap in.
+- (NSTimeInterval)swapStart {
     NSTimeInterval duration = _track.duration;
-    NSTimeInterval quarter = duration / 4;
-    NSTimeInterval start = _track.delay + (_grows ? 0 : duration - quarter);
-    double swap;
+    return _track.delay + (_grows ? 0 : duration - duration / 4);
+}
+
+- (double)swapAtTime:(NSTimeInterval)time {
+    NSTimeInterval quarter = _track.duration / 4;
     if (quarter <= 0) {
-        swap = time >= _track.delay ? 1 : 0;
-    } else {
-        swap = MIN(MAX((time - start) / quarter, 0.0), 1.0);
+        return time >= _track.delay ? 1 : 0;
+    }
+    return MIN(MAX((time - [self swapStart]) / quarter, 0.0), 1.0);
+}
+
+// The copy shows its state at `time` (its own values, with no animation).
+- (void)placeAtTime:(NSTimeInterval)time {
+    ANNFlightState state = [self stateAtTime:time];
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    _copy.layer.transform = CATransform3DIdentity;
+    _copy.bounds = CGRectMake(0, 0, state.size.width, state.size.height);
+    _copy.center = state.center;
+    _copy.layer.transform = state.transform;
+    if (!_text) {
+        _copy.layer.cornerRadius = state.cornerRadius;
+    }
+    ANNPlaceLayer(_fromPicture.layer, state.fromFrame);
+    ANNPlaceLayer(_toPicture.layer, state.toFrame);
+    _fromPicture.alpha = state.fromAlpha;
+    _toPicture.alpha = state.toAlpha;
+    if (_mask) {
+        ANNPlaceLayer(_mask, state.mask);
+        _mask.cornerRadius = state.maskRadius;
+    }
+    [CATransaction commit];
+}
+
+#pragma mark - ANNFrameClient
+
+- (NSTimeInterval)endTime {
+    return _track.endTime;
+}
+
+- (void)addAnimationsWithLength:(NSTimeInterval)length {
+    if (_restored) {
+        return;
+    }
+    NSMutableArray<NSNumber *> *marks =
+        [NSMutableArray arrayWithObjects:@(_track.delay), @(_track.endTime), nil];
+    if (_text) {
+        [marks addObject:@([self swapStart])];
+        [marks addObject:@([self swapStart] + _track.duration / 4)];
+    }
+    NSArray<NSNumber *> *times = ANNSampleTimes(_track.endTime, length, marks);
+    NSMutableArray *bounds = [NSMutableArray new];
+    NSMutableArray *positions = [NSMutableArray new];
+    NSMutableArray *transforms = [NSMutableArray new];
+    NSMutableArray *radii = [NSMutableArray new];
+    NSMutableArray *fromBounds = [NSMutableArray new];
+    NSMutableArray *fromPositions = [NSMutableArray new];
+    NSMutableArray *fromAlphas = [NSMutableArray new];
+    NSMutableArray *toBounds = [NSMutableArray new];
+    NSMutableArray *toPositions = [NSMutableArray new];
+    NSMutableArray *toAlphas = [NSMutableArray new];
+    NSMutableArray *maskBounds = [NSMutableArray new];
+    NSMutableArray *maskPositions = [NSMutableArray new];
+    NSMutableArray *maskRadii = [NSMutableArray new];
+    for (NSNumber *time in times) {
+        ANNFlightState state = [self stateAtTime:time.doubleValue];
+        CGRect whole = CGRectMake(0, 0, state.size.width, state.size.height);
+        [bounds addObject:ANNBoundsValue(whole)];
+        [positions addObject:[NSValue valueWithCGPoint:state.center]];
+        [transforms addObject:[NSValue valueWithCATransform3D:state.transform]];
+        [radii addObject:@(state.cornerRadius)];
+        [fromBounds addObject:ANNBoundsValue(state.fromFrame)];
+        [fromPositions addObject:ANNPositionValue(state.fromFrame)];
+        [fromAlphas addObject:@(state.fromAlpha)];
+        [toBounds addObject:ANNBoundsValue(state.toFrame)];
+        [toPositions addObject:ANNPositionValue(state.toFrame)];
+        [toAlphas addObject:@(state.toAlpha)];
+        [maskBounds addObject:ANNBoundsValue(state.mask)];
+        [maskPositions addObject:ANNPositionValue(state.mask)];
+        [maskRadii addObject:@(state.maskRadius)];
+    }
+    CALayer *copy = _copy.layer;
+    ANNAddKeyframes(copy, @"bounds", bounds, times, length);
+    ANNAddKeyframes(copy, @"position", positions, times, length);
+    ANNAddKeyframes(copy, @"transform", transforms, times, length);
+    if (!_text) {
+        ANNAddKeyframes(copy, @"cornerRadius", radii, times, length);
+    }
+    ANNAddKeyframes(_fromPicture.layer, @"bounds", fromBounds, times, length);
+    ANNAddKeyframes(_fromPicture.layer, @"position", fromPositions, times, length);
+    ANNAddKeyframes(_fromPicture.layer, @"opacity", fromAlphas, times, length);
+    ANNAddKeyframes(_toPicture.layer, @"bounds", toBounds, times, length);
+    ANNAddKeyframes(_toPicture.layer, @"position", toPositions, times, length);
+    ANNAddKeyframes(_toPicture.layer, @"opacity", toAlphas, times, length);
+    if (_mask) {
+        ANNAddKeyframes(_mask, @"bounds", maskBounds, times, length);
+        ANNAddKeyframes(_mask, @"position", maskPositions, times, length);
+        ANNAddKeyframes(_mask, @"cornerRadius", maskRadii, times, length);
     }
-    _fromPicture.alpha = (CGFloat)(1 - swap);
-    _toPicture.alpha = (CGFloat)swap;
 }
 
 - (void)restore {

package/ios/Animations/Interpolators/ANNViewTracks.h

@@ -20,13 +20,14 @@ FOUNDATION_EXPORT CGFloat ANNCameraDistance(void);
 /// position and bounds, never its frame) moved by its own translation, `alpha` its alpha before any hide, the
 /// translations, scales and rotations those of its own transform (React Native's `transform`, split into its parts as
 /// Android's views hold it: the shorter angle, −180…180). A property that doesn't play keeps the view's own value, its
-/// skew and perspective stay. Each frame writes only what plays: `alpha` only with an `alpha` track, `layer.transform`
-/// only when a property of the transform plays; with `translationX` and `x` on one side the translation wins. The frame
-/// is never changed (React keeps the layout). `restore` puts back the alpha and the transform as they were read.
+/// skew and perspective stay. Only what plays animates, in Core Animation (`ANNKeyframes`): `opacity` only with an
+/// `alpha` track, `transform` only when a property of the transform plays; with `translationX` and `x` on one side the
+/// translation wins. The view's own values (its frame, alpha and transform) are never written: the animations show
+/// over them, and `restore` removes the animations.
 @interface ANNViewTracks : NSObject <ANNFrameClient>
 
 /// The playing properties of `side` on `view`. `alphaBefore`: the view's alpha before the core hid it for the
-/// transition (the arriving screen), else its alpha now; it is also what `restore` puts back.
+/// transition (the arriving screen), else its alpha now.
 - (instancetype)initWithView:(UIView *)view
                         side:(ANNViewAnimationOptions *)side
                  alphaBefore:(CGFloat)alphaBefore;
@@ -35,7 +36,7 @@ FOUNDATION_EXPORT CGFloat ANNCameraDistance(void);
 /// disappearing from it to `to`, or both ends given.
 - (instancetype)initWithView:(UIView *)view element:(ANNElementTransitionOptions *)element;
 
-/// A linear fade of `view`'s alpha (a dismissed popover with nothing to play); `restore` puts back `alphaBefore`.
+/// A linear fade of `view`'s alpha (a dismissed popover with nothing to play, a transition under Reduce Motion).
 - (instancetype)initWithView:(UIView *)view
                     fadeFrom:(CGFloat)from
                           to:(CGFloat)to

package/ios/Animations/Interpolators/ANNViewTracks.mm

@@ -93,8 +93,8 @@ static ANNTrack *ANNTrackOf(Double *from, Double *to, Double *duration, Double *
     CGFloat _ownPerspective;
     BOOL _animatesTransform;
     BOOL _tilts;
-    BOOL _wroteAlpha;
-    BOOL _wroteTransform;
+    BOOL _addedAlpha;
+    BOOL _addedTransform;
     BOOL _restored;
     NSTimeInterval _endTime;
 }
@@ -235,17 +235,9 @@ static ANNTrack *ANNTrackOf(Double *from, Double *to, Double *duration, Double *
     return track ? [track valueAt:time] : [self viewValueOf:property];
 }
 
-- (void)applyAtTime:(NSTimeInterval)time {
-    if (_restored) {
-        return;
-    }
-    if (self.animatesAlpha) {
-        _view.alpha = (CGFloat)[_tracks[ANNViewPropertyAlpha] valueAt:time];
-        _wroteAlpha = YES;
-    }
-    if (!_animatesTransform) {
-        return;
-    }
+// The view's transform at `time`: every property of the transform at its value then, the ones that don't play at the
+// view's own.
+- (CATransform3D)transformAtTime:(NSTimeInterval)time {
     CGFloat scaleX = (CGFloat)[self valueOf:ANNViewPropertyScaleX at:time];
     CGFloat scaleY = (CGFloat)[self valueOf:ANNViewPropertyScaleY at:time];
     // The translation wins over the place when a side has both.
@@ -279,10 +271,48 @@ static ANNTrack *ANNTrackOf(Double *from, Double *to, Double *duration, Double *
         perspective.m34 = _ownPerspective != 0 ? _ownPerspective : -1.0 / ANNCameraDistance();
         transform = CATransform3DConcat(transform, perspective);
     }
-    transform = CATransform3DConcat(transform,
-                                    CATransform3DMakeTranslation(translationX, translationY, 0));
-    _view.layer.transform = transform;
-    _wroteTransform = YES;
+    return CATransform3DConcat(transform,
+                               CATransform3DMakeTranslation(translationX, translationY, 0));
+}
+
+- (void)addAnimationsWithLength:(NSTimeInterval)length {
+    if (_restored || !self.hasTracks) {
+        return;
+    }
+    // Every track's start and end is a sample, so a track that starts late or ends early does it on time.
+    NSMutableArray<NSNumber *> *marks = [NSMutableArray new];
+    for (NSInteger index = 0; index < ANNViewPropertyCount; index++) {
+        ANNTrack *track = _tracks[index];
+        if (track) {
+            [marks addObject:@(track.delay)];
+            [marks addObject:@(track.endTime)];
+        }
+    }
+    NSArray<NSNumber *> *times = ANNSampleTimes(_endTime, length, marks);
+    CALayer *layer = _view.layer;
+    if (self.animatesAlpha) {
+        NSMutableArray<NSNumber *> *values = [NSMutableArray arrayWithCapacity:times.count];
+        for (NSNumber *time in times) {
+            [values addObject:@([_tracks[ANNViewPropertyAlpha] valueAt:time.doubleValue])];
+        }
+        CAKeyframeAnimation *animation = ANNKeyframes(@"opacity", values, times, length);
+        if (animation) {
+            [layer addAnimation:animation forKey:ANNAnimationKey(@"opacity")];
+            _addedAlpha = YES;
+        }
+    }
+    if (_animatesTransform) {
+        NSMutableArray<NSValue *> *values = [NSMutableArray arrayWithCapacity:times.count];
+        for (NSNumber *time in times) {
+            CATransform3D transform = [self transformAtTime:time.doubleValue];
+            [values addObject:[NSValue valueWithCATransform3D:transform]];
+        }
+        CAKeyframeAnimation *animation = ANNKeyframes(@"transform", values, times, length);
+        if (animation) {
+            [layer addAnimation:animation forKey:ANNAnimationKey(@"transform")];
+            _addedTransform = YES;
+        }
+    }
 }
 
 - (void)restore {
@@ -290,11 +320,11 @@ static ANNTrack *ANNTrackOf(Double *from, Double *to, Double *duration, Double *
         return;
     }
     _restored = YES;
-    if (_wroteAlpha) {
-        _view.alpha = _alphaBefore;
+    if (_addedAlpha) {
+        [_view.layer removeAnimationForKey:ANNAnimationKey(@"opacity")];
     }
-    if (_wroteTransform) {
-        _view.layer.transform = _transformBefore;
+    if (_addedTransform) {
+        [_view.layer removeAnimationForKey:ANNAnimationKey(@"transform")];
     }
 }
 

package/ios/CLAUDE.md

@@ -44,7 +44,7 @@ Top-level files: `Package.swift` (SwiftPM; `headerFolders` lists every folder wh
 - Screen: React root, slot, native screen — `Layouts/Screen/`: `ANNComponentViewController`; `React/`: `ANNReactView`, `ANNReactViewCreator`, `Slots/`; `Layouts/External/`
 - Screen: insets, background, keyboard focus — `Layouts/Screen/`: `ANNScreenEnvironment`, `ANNScreenSafeArea`, `ANNScreenBars`, `ANNScreenPlace` (the safe area of a parked screen), `ANNComponentPresenter` (background, status bar blur), `ANNComponentViewController` (key commands)
 - Safe area view — `React/`: `ANNSafeAreaViewComponentView`; `Layouts/Screen/`: `ANNScreenReadiness`; `cpp/`
-- Stack: queue, commands, back, gestures — `Layouts/Stack/`: `ANNStackQueue`, `ANNStackCommands`, `ANNStackController`, `InteractivePopGestureDelegate`, `ANNStackAnimatingDelegate`
+- Stack: queue, commands, back, gestures — `Layouts/Stack/`: `ANNStackQueue`, `ANNStackCommands`, `ANNStackController`, `InteractivePopGestureDelegate`, `ANNStackAnimatingDelegate`, `ANNSwipePopInteraction`
 - Top bar: title, buttons, menus, large title — `TopBar/`: `ANNTopBarPresenter`, `ANNBarButtons`, `ANNBarAppearance`, `ANNLargeTitlePresenter`, `ANNBackButtonPresenter`, `ANNTitleView`, `ANNTitleGlassView`
 - Top bar: components, waits — `TopBar/`: `ANNBarComponentsWait`, `ANNBarBackgroundComponent`, `ANNTitleComponentView`, `ANNBarButtonComponentView`; `React/`: `ANNReactComponentRegistry`
 - Search — `TopBar/`: `ANNSearchPresenter`, `ANNSearchResultsViewController`
@@ -133,16 +133,26 @@ Top-level files: `Package.swift` (SwiftPM; `headerFolders` lists every folder wh
 - Use an `@available` check for newer OS APIs, and `#if __IPHONE_OS_VERSION_MAX_ALLOWED >= …` for names of a newer SDK.
 - React Native hears of the app's light or dark style only from its hosting views in the window. A view that stands in
   for one (`ANNSlotScreenView`, the screens of one tree) posts the trait change itself, with the window filter of
-  `ANNSurfaceHostingView`; without it `useColorScheme` keeps the old theme.
+  `ANNSurfaceHostingView`; without it `useColorScheme` keeps the old theme. `Appearance.setColorScheme` sets the style
+  only on the windows there are at that moment: every window the core makes but the main window comes from
+  `+[ANNUtils makeWindowOfClass:]`, which gives it the main window's style. A window of the system's style would draw
+  its screens in the other theme, and its hosting views would switch the app's theme in JS.
 - A step that runs later in a command (a ready handler, a timer, a transition's end) goes through the owner's guard
   (`protect:step:`), so an exception rejects the command instead of crashing the app. So does the start of a wait
   (the root, a modal, an overlay: their record is listed and parked by then), and the modal's end steps inside UIKit's
   completions and delegate calls (`protectEndOf:showing:step:`, `protectBatch:step:`); the overlay's guard is
   `protectWaitOf:step:`.
-- Each step of a transition's element (a pair's start and take-off, an element's start, every frame and restore
+- Each step of a transition's element (a pair's start and take-off, an element's start, its animations and restore
   through `ANNIsolatedElement`) runs in `ANNElementStep`: an exception skips that element only. A new step of an
-  element goes there too, or one bad element stops the transition (a frame's exception ends the app). The elements of
-  a transition are found in one walk per screen (`ANNTransitionViews`).
+  element goes there too, or one bad element stops the transition. The elements of a transition are found in one walk
+  per screen (`ANNTransitionViews`).
+- A custom transition runs in Core Animation (`ANNFrameDriver`): each client samples its values once, at the start,
+  into keyframe animations under the core's keys (`ANNAnimationKey`), and `restore` removes them. It never writes a
+  view's own alpha or transform for a frame; a value the core writes for the transition (the arriving view's hide, a
+  hidden flag, a depth) goes back as before. A pop that follows the swipe back also stops the time of the transition's
+  container (`startPausedOn:done:`), and the container gets its time back before the clients restore. UIKit runs its
+  swipe back without asking the navigation's delegate for a transition (iOS 26 checked), so that pop follows the
+  stack's own swipe from the leading edge, and UIKit's swipes stand aside meanwhile (`swipeBackTakes:`).
 - An `ANNCommandAnswer` that goes away unanswered rejects (`notAnswered:`), but only once nothing holds it: a record,
   list or queue that keeps an answer still answers it on every exit, or the promise waits as long as the record lives.
 - On iOS 26 UIKit draws a screen's large title, for a whole pop or swipe back, inside the scroll view the bar follows
@@ -152,9 +162,10 @@ Top-level files: `Package.swift` (SwiftPM; `headerFolders` lists every folder wh
 - Under a hidden bar UIKit's swipe delegate refuses the swipes in questions of its own: `InteractivePopGestureDelegate`
   stops passing those on while the bar is hidden (`barHidden`, set again on the recognizer at each change, from
   `swipeBackFollowsBar`), and the core sorts the pans itself.
-- UIKit works out the safe area of the window's root view from where it is drawn: a `transform` that moves it (a
-  root's own `enter`) leaves it with no top inset, and putting the transform back doesn't work it out again. Lay the
-  root out after a restore (`+[ANNRootCoordinator stopAnimationOf:]`).
+- UIKit works out the safe area of the window's root view from where it is: a `transform` written on it that moves it
+  leaves it with no top inset, and putting the transform back doesn't work it out again. A root's own `enter` moves
+  only what Core Animation draws; the root is still laid out after a restore (`+[ANNRootCoordinator stopAnimationOf:]`).
+  While it animates, the new root takes no touches: it is drawn elsewhere than where it is.
 - UIKit's `hidesBarsWhenKeyboardAppears`, once on, keeps hiding the bar after it is set back to `NO`: the stack hides
   the bars for `topBar.hideOnKeyboard` itself (`keyboardWillShow:` / `keyboardDidHide:` of `ANNStackController`) and
   leaves the flag off.

package/ios/CORE.md

@@ -139,7 +139,7 @@ Each of these owns one rule. Call it; do not copy it.
 - `ANNReloadCoordinator`: The generation of the JavaScript; the reset after a reload. Called by: Runner, emitter, answer.
 - Stack answer id: `ANNStackAnswerIdOf(entry, command)` in `ANNStackQueue.h`: the id a stack command answers with. `push` answers the node's own id (a pair's id); every other command, the entry's options screen (a pair's primary). Called by: The queue, `ANNStackCommands`, `ANNPreviewPush`, `ANNSplitViewCommands`.
 - Waited screens: `waitedComponentViewControllers`: the screens a wait is about (a pair: the ones it puts in the window). `ANNStackScreensOfEntry` is every screen of an entry, for what means all of them. Called by: `ANNRenderWait` owners: root, stack queue, modals, overlays, `ANNSplitViewCommands`.
-- Back: The stack: `ANNStackController` (`userGoBackTo:`, `backAction`, the hold) and `InteractivePopGestureDelegate`; UIKit's own pops are followed by `ANNStackQueue uikitShows:`. Called by: UIKit, the user.
+- Back: The stack: `ANNStackController` (`userGoBackTo:`, `backAction`, the hold) and `InteractivePopGestureDelegate`; UIKit's own pops are followed by `ANNStackQueue uikitShows:`. A top whose own pop is `interactive` gets the stack's own swipe from the leading edge instead of UIKit's (UIKit runs its swipe without asking the delegate for a transition): `swipeBackTakes:` picks the swipe, `ownSwipeBack:` pops, and `swipeAnimatorFrom:to:` and `ANNSwipePopInteraction` play the pop under the finger. Called by: UIKit, the user.
 
 ## Modules
 

package/ios/Core/ANNAppDelegate.mm

@@ -71,8 +71,6 @@ static BOOL ANNAppUsesScenes(void) {
     rootViewFactory.reactHost = host;
     [ApexNavigation bootstrapWithHost:host];
     self.window = ApexNavigation.mainWindow;
-    // The links that come before React content wait for it; the launch link waits for the scene.
-    [ANNDeepLinkQueue start];
     if (!ANNAppUsesScenes()) {
         [self.window makeKeyAndVisible];
     }

package/ios/Core/ANNDeepLinkQueue.h

@@ -14,7 +14,8 @@ typedef void (^ANNLaunchLinkCompletion)(NSURL *_Nullable url);
  */
 @interface ANNDeepLinkQueue : NSObject
 
-/// Starts the queue as the app launches (`ANNAppDelegate`). An app that never starts it has no launch link.
+/// Starts the queue as the app launches (`+[ApexNavigation bootstrapWithHost:]`, so also under an app delegate of the
+/// app's own). Once: a second call does nothing.
 + (void)start;
 
 /// Hands `url` to `Linking`, or keeps it until React content first appears and no `takeLaunchLink:` waits.
@@ -33,11 +34,11 @@ typedef void (^ANNLaunchLinkCompletion)(NSURL *_Nullable url);
                     ofScene:(UIScene *)scene
                     through:(NS_NOESCAPE dispatch_block_t)forward;
 
-/// Hands the scene's link to `Linking` at once, past the queue: for an app delegate that doesn't take links.
-+ (void)openURLContext:(UIOpenURLContext *)context ofScene:(UIScene *)scene;
+/// `dispatchURL:` for the scene's link, with its scene and context: for an app delegate that doesn't take links.
++ (void)dispatchURLContext:(UIOpenURLContext *)context ofScene:(UIScene *)scene;
 
-/// `openURLContext:ofScene:` for a web link (`webpageURL`) of the scene; an activity without one does nothing.
-+ (void)openUserActivity:(NSUserActivity *)activity ofScene:(UIScene *)scene;
+/// `dispatchURLContext:ofScene:` for a web link (`webpageURL`) of the scene; an activity without one does nothing.
++ (void)dispatchUserActivity:(NSUserActivity *)activity ofScene:(UIScene *)scene;
 
 /// The app's window scene connected (`+[ApexNavigation attachToWindowScene:]`).
 + (void)windowSceneDidConnect;

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/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/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) {