@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.11

package/ios/Layouts/Stack/ANNStackController.mm

@@ -3,6 +3,7 @@
 #import "ANNAppDirection.h"
 #import "ANNAppearanceDispatcher.h"
 #import "ANNAssert.h"
+#import "ANNBottomTabsController.h"
 #import "ANNComponentViewController.h"
 #import "ANNElementFinder.h"
 #import "ANNErrorTexts.h"
@@ -12,7 +13,9 @@
 #import "ANNSheetPresenter.h"
 #import "ANNShownScreens.h"
 #import "ANNStackAnimatingDelegate.h"
+#import "ANNStackPopAnimationOptions.h"
 #import "ANNStackPresenter.h"
+#import "ANNSwipePopInteraction.h"
 #import "ANNSystemUI.h"
 #import "ANNTopBarPresenter.h"
 #import "ANNTransitionAnimator.h"
@@ -54,6 +57,10 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     return state == UIGestureRecognizerStateBegan || state == UIGestureRecognizerStateChanged;
 }
 
+// How far from the leading edge of the stack's view the stack's own swipe back starts, in points: the strip the side
+// menu leaves to the swipe back (`ANNSideMenuEdgeWidth`).
+static const CGFloat ANNOwnSwipeEdgeWidth = 20;
+
 @interface ANNStackController () <ANNStackDisplay, ANNStackAnimating>
 @end
 
@@ -90,6 +97,12 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     ANNTransitionPlan *_pendingPlan;
     ANNStackChange _pendingChange;
     __weak ANNTransitionAnimator *_runningAnimator;
+    // The interaction of the swipe back that plays the top's own pop, until UIKit asks for it.
+    __weak ANNSwipePopInteraction *_swipeInteraction;
+    // The stack's own swipe from the leading edge, on while the top's pop follows the finger: UIKit runs its swipe
+    // without asking the delegate for a transition, so that one would only slide.
+    UIPanGestureRecognizer *_ownSwipe;
+    InteractivePopGestureDelegate *_ownSwipeDelegate;
     BOOL _gateUpdateScheduled;
     // The stack is made (its helper set up): its options can be resolved.
     BOOL _madeUp;
@@ -260,6 +273,16 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
                                                                  content:YES
                                                                 barSwipe:barSwipe];
     }
+    if (!_ownSwipe) {
+        _ownSwipe = [[UIPanGestureRecognizer alloc] initWithTarget:self
+                                                            action:@selector(ownSwipeBack:)];
+        _ownSwipe.enabled = _animatingDelegate.answersInteraction;
+        [self.view addGestureRecognizer:_ownSwipe];
+    }
+    _ownSwipeDelegate = [InteractivePopGestureDelegate installOn:_ownSwipe
+                                                           stack:self
+                                                         content:NO
+                                                        barSwipe:barSwipe];
     [self updateSwipeBack];
 }
 
@@ -520,6 +543,9 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 
 - (BOOL)isSwipingBack {
     UINavigationController *navigation = self.shownNavigationController;
+    if (navigation == self && ANNIsActive(_ownSwipe)) {
+        return YES;
+    }
     if (ANNIsActive(navigation.interactivePopGestureRecognizer)) {
         return YES;
     }
@@ -813,15 +839,20 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 #pragma mark - The custom transitions
 
 // UIKit asks while it starts the change the queue asked for: the queue's plan when the operation and the arriving
-// entry are the plan's (the back button and the commands go through the queue, so its plan covers them); nil for
-// anything else — UIKit's own pops, the interactive swipe (UIKit never asks for it), a zoom alone.
+// entry are the plan's (the back button and the commands go through the queue, so its plan covers them); the swipe
+// back gets the top's own pop only with `animations.pop.interactive` (`swipeAnimatorFrom:to:`); nil for anything
+// else — UIKit's own pops, a zoom alone.
 - (id<UIViewControllerAnimatedTransitioning>)
     animatorForOperation:(UINavigationControllerOperation)operation
                     from:(UIViewController *)from
                       to:(UIViewController *)to {
+    if ([self isSwipingBack]) {
+        return operation == UINavigationControllerOperationPop
+                   ? [self swipeAnimatorFrom:from to:to]
+                   : nil;
+    }
     ANNTransitionPlan *plan = _pendingPlan;
-    if (!plan || operation == UINavigationControllerOperationNone || to != plan.toNode ||
-        [self isSwipingBack]) {
+    if (!plan || operation == UINavigationControllerOperationNone || to != plan.toNode) {
         return nil;
     }
     BOOL matches = _pendingChange == ANNStackChangeReplace ||
@@ -838,16 +869,73 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     return animator;
 }
 
+// The stack's own swipe back of a top whose pop follows the finger (`animations.pop.interactive`, not
+// `enabled: false`): the pop plays under it. Nil otherwise, also when UIKit won't ask for the interaction (the gate
+// hasn't seen the option yet: a change of the default options) or the screen under hasn't settled
+// (`revealedEntrySettled:`): UIKit asks for the transition before the queue takes the swipe and moves those, and the
+// frames take the views as they are now.
+- (nullable ANNTransitionAnimator *)swipeAnimatorFrom:(UIViewController *)from
+                                                   to:(UIViewController *)to {
+    if (!ANNIsActive(_ownSwipe) || !_animatingDelegate.answersInteraction ||
+        ![self isOwnViewController:from] || ![self revealedEntrySettled:to]) {
+        return nil;
+    }
+    ANNStackPopAnimationOptions *pop = [from resolveOptionsWithDefault].animations.pop;
+    if (![ANNStackController popFollowsSwipe:pop]) {
+        return nil;
+    }
+    ANNTransitionPlan *plan = [ANNTransitionPlan stackPlanOfKind:ANNTransitionKindPop
+                                                       animation:pop
+                                                   waitForRender:nil
+                                                       waitLimit:0
+                                                            from:from
+                                                              to:to];
+    if (!plan) {
+        return nil;
+    }
+    ANNTransitionAnimator *animator = [[ANNTransitionAnimator alloc] initWithPlan:plan];
+    // The interaction keeps itself while it follows the gesture; UIKit keeps it once it starts it.
+    ANNSwipePopInteraction *interaction =
+        [[ANNSwipePopInteraction alloc] initWithAnimator:animator recognizer:_ownSwipe view:self.view];
+    _swipeInteraction = interaction;
+    _runningAnimator = animator;
+    return animator;
+}
+
+// The screen under is in place for the frames: its view made, not parked, not rendering as a lower screen.
+- (BOOL)revealedEntrySettled:(nullable UIViewController *)revealed {
+    return revealed.isViewLoaded && ![_lowerRendering objectForKey:revealed] &&
+           ![_lowerToRender containsObject:revealed] &&
+           ![[self parkedEntries] containsObject:revealed];
+}
+
++ (BOOL)popFollowsSwipe:(nullable ANNStackPopAnimationOptions *)pop {
+    return [ANNAnimationRules stackIsOwn:pop] && [pop.interactive withDefault:NO] &&
+           [pop.enabled withDefault:YES];
+}
+
+- (nullable id<UIViewControllerInteractiveTransitioning>)interactionForAnimator:
+    (id<UIViewControllerAnimatedTransitioning>)animator {
+    ANNSwipePopInteraction *interaction = _swipeInteraction;
+    return interaction && interaction.animator == animator ? interaction : nil;
+}
+
 // The animating delegate while a custom animation may be needed: a change with its own plan now, or a top whose
 // `animations.pop` is its own; the stack itself otherwise. UIKit reads the delegate's methods when it is set, so it is
-// set again at each change.
+// set again at each change, and again when the interaction of the swipe comes or goes with the top's
+// `animations.pop.interactive`.
 - (void)updateAnimationGateWith:(ANNTransitionPlan *)plan {
-    BOOL needed = plan != nil;
-    if (!needed) {
-        UIViewController *top = [self getCurrentChild];
-        needed = top && [ANNAnimationRules
-                            stackIsOwn:[top resolveOptionsWithDefault].animations.pop];
+    UIViewController *top = [self getCurrentChild];
+    ANNStackPopAnimationOptions *pop = top ? [top resolveOptionsWithDefault].animations.pop : nil;
+    BOOL needed = plan != nil || [ANNAnimationRules stackIsOwn:pop];
+    BOOL interactive = [ANNStackController popFollowsSwipe:pop];
+    if (_animatingDelegate.answersInteraction != interactive) {
+        _animatingDelegate.answersInteraction = interactive;
+        if (self.delegate == _animatingDelegate) {
+            self.delegate = self;
+        }
     }
+    _ownSwipe.enabled = interactive;
     id<UINavigationControllerDelegate> delegate =
         needed ? (id<UINavigationControllerDelegate>)_animatingDelegate : self;
     if (self.delegate != delegate) {
@@ -934,13 +1022,66 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     if (top != nil && top != [self getCurrentChild]) {
         return YES;
     }
-    BOOL own = recognizer == self.interactivePopGestureRecognizer;
+    BOOL own = recognizer == self.interactivePopGestureRecognizer || recognizer == _ownSwipe;
     if (@available(iOS 26.0, *)) {
         own = own || recognizer == self.interactiveContentPopGestureRecognizer;
     }
     return !own && _queue.shown.count < 2;
 }
 
+- (BOOL)swipeBackIsStacks:(UIGestureRecognizer *)recognizer {
+    return recognizer != nil && recognizer == _ownSwipe;
+}
+
+- (BOOL)swipeBackTakes:(UIGestureRecognizer *)recognizer {
+    BOOL uikits = recognizer == self.interactivePopGestureRecognizer;
+    if (@available(iOS 26.0, *)) {
+        uikits = uikits || recognizer == self.interactiveContentPopGestureRecognizer;
+    }
+    if (recognizer != _ownSwipe && !uikits) {
+        return YES;
+    }
+    NSArray<UIViewController *> *shown = _queue.shown;
+    UIViewController *revealed = shown.count >= 2 ? shown[shown.count - 2] : nil;
+    // The options as they are now, as `swipeAnimatorFrom:to:` reads them: the gate may lag a change of the defaults,
+    // and a swipe of ours without the pop would be a pop the finger can't hold.
+    UIViewController *top = self.topViewController;
+    BOOL ownPlays = _ownSwipe.enabled && _animatingDelegate.answersInteraction && top &&
+                    top == [self getCurrentChild] && [self isOwnViewController:top] &&
+                    [ANNStackController
+                        popFollowsSwipe:[top resolveOptionsWithDefault].animations.pop] &&
+                    [self revealedEntrySettled:revealed];
+    if (uikits) {
+        return !ownPlays;
+    }
+    return ownPlays && [self panStartsAtLeadingEdge:_ownSwipe];
+}
+
+// A pan that starts near the leading edge of the stack's view and moves more across than along, toward the trailing
+// side: where UIKit's edge swipe starts.
+- (BOOL)panStartsAtLeadingEdge:(UIPanGestureRecognizer *)pan {
+    UIView *view = self.view;
+    CGPoint at = [pan locationInView:view];
+    CGPoint move = [pan translationInView:view];
+    BOOL rightToLeft =
+        view.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft;
+    CGFloat start = at.x - move.x;
+    CGFloat fromEdge = rightToLeft ? view.bounds.size.width - start : start;
+    if (move.x == 0 && move.y == 0) {
+        move = [pan velocityInView:view];
+    }
+    CGFloat along = rightToLeft ? -move.x : move.x;
+    return fromEdge <= ANNOwnSwipeEdgeWidth && along > fabs(move.y);
+}
+
+// The stack's own swipe began: a pop as UIKit's swipe makes it, which the stack follows as the swipe back
+// (`followUIKitTransition`); the transition asks for the top's pop and its interaction (`swipeAnimatorFrom:to:`).
+- (void)ownSwipeBack:(UIPanGestureRecognizer *)recognizer {
+    if (recognizer.state == UIGestureRecognizerStateBegan) {
+        [self popViewControllerAnimated:YES];
+    }
+}
+
 - (BOOL)hasOneEntry {
     return _queue.entries.count < 2;
 }
@@ -983,6 +1124,7 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     BOOL edge = !(isBool && ![value boolValue]);
     BOOL content = !value || (isBool && [value boolValue]);
     _edgeSwipeDelegate.enabled = edge;
+    _ownSwipeDelegate.enabled = edge;
     _moreEdgeSwipeDelegate.enabled = edge;
     _contentSwipeDelegate.enabled = content;
     _moreContentSwipeDelegate.enabled = content;
@@ -992,6 +1134,7 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 - (void)swipeBackFollowsBar {
     BOOL hidden = [ANNSystemUI barHiddenOf:self.shownNavigationController];
     _edgeSwipeDelegate.barHidden = hidden;
+    _ownSwipeDelegate.barHidden = hidden;
     _contentSwipeDelegate.barHidden = hidden;
     _moreEdgeSwipeDelegate.barHidden = hidden;
     _moreContentSwipeDelegate.barHidden = hidden;
@@ -1033,10 +1176,12 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     return self;
 }
 
-// In More the More navigation is what shows the screens.
+// In More the More navigation is what shows the screens. A tab rendered before it shows is in a window while its
+// screens render there, and not on screen.
 - (BOOL)stackIsOnScreen {
     return self.shownNavigationController.viewIfLoaded.window != nil &&
-           ![ANNPendingLayers isWaitingToShow:self];
+           ![ANNPendingLayers isWaitingToShow:self] &&
+           ![ANNBottomTabsController isInUnseenTab:self];
 }
 
 // Only the stack's own transitions (a push, a pop, a replace of its view controllers, the interactive pop): a
@@ -1102,6 +1247,11 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
     if (change == ANNStackChangePush && animated) {
         lowerBarBottom = [self lowerBarBottomOf:navigation leaving:coveredTop];
     }
+    // The large title of a screen that comes with its content takes its place for the transition before UIKit's push.
+    if (change == ANNStackChangePush && animated) {
+        UIViewController *arriving = ANNStackOptionsScreen(entries.lastObject);
+        [[ANNTopBarPresenter presenterOfScreen:arriving] arrivesByPushOn:navigation];
+    }
     // The revealed screen's large title takes its place for the transition before UIKit lays the screen out for it.
     if (change == ANNStackChangePop && animated) {
         [self popReveals:entries.lastObject leaving:coveredTop on:navigation];
@@ -1428,10 +1578,28 @@ static BOOL ANNIsActive(UIGestureRecognizer *recognizer) {
 
 // The screen waits in the window at the stack's size, under UIKit's container view ( `ANNParking`): it isn't a child of
 // anything there, gets no touches, is hidden from accessibility, and its appearance is driven, so UIKit's callbacks
-// report nothing for it. Each path that ends the wait gives the view back as it was; UIKit's push of the entry
-// re-parents it in the same turn, so its departure is not ended here.
+// report nothing for it. UIKit gives such a view no safe area: its screens lay out with that of their place on top of
+// the stack meanwhile (`ANNScreenPlace`). Each path that ends the wait gives the view back as it was; UIKit's push of
+// the entry re-parents it in the same turn, so its departure is not ended here.
 - (void)stackPark:(UIViewController *)entry {
-    [_parking park:entry inView:self.shownNavigationController.view];
+    UINavigationController *navigation = self.shownNavigationController;
+    // Its screens lay out as on top of the stack, with the bar and the toolbar the entry shows there.
+    __weak UIViewController *weakEntry = entry;
+    __weak UINavigationController *weakNavigation = navigation;
+    ANNScreenPlace * (^place)(void) = ^ANNScreenPlace * {
+      UIViewController *parked = weakEntry;
+      UINavigationController *stack = weakNavigation;
+      if (!parked || !stack) {
+          return nil;
+      }
+      return [ANNScreenPlace placeOfEntry:parked
+                                  inStack:stack
+                                  options:[ANNStackOptionsScreen(parked) resolveOptionsWithDefault]];
+    };
+    for (ANNComponentViewController *screen in ANNStackScreensOfEntry(entry)) {
+        screen.placeWhileParked = place;
+    }
+    [_parking park:entry inView:navigation.view];
 }
 
 - (void)stackUnpark:(UIViewController *)entry {

package/ios/Layouts/Stack/ANNStackQueue.h

@@ -60,7 +60,8 @@ typedef NS_ENUM(NSInteger, ANNStackChange) {
 /// The stack's own view controller: the layout parent of the nodes it took and doesn't show yet.
 - (UIViewController *)stackViewController;
 
-/// The stack is seen: its view is in a window, and it isn't inside a layer that waits to show (`ANNPendingLayers`).
+/// The stack is seen: its view is in a window, and it isn't inside a layer that waits to show (`ANNPendingLayers`) nor
+/// in a tab that renders before it shows (`isInUnseenTab:` of the tabs).
 - (BOOL)stackIsOnScreen;
 
 /// A transition UIKit runs on the stack now (one the queue didn't start); nil when none runs.
@@ -166,9 +167,11 @@ typedef NS_ENUM(NSInteger, ANNStackChange) {
          completion:(nullable dispatch_block_t)completion
           rejection:(nullable ANNTransitionRejectionBlock)rejection;
 
-/// A command that moves nothing (`popTo` of the top) answers `value` in its turn.
+/// A command that moves nothing (`popTo` of the top) answers `value` in its turn; a failure meanwhile rejects with the
+/// command's own `what`.
 - (void)noneWithValue:(id)value
                answer:(ANNCommandAnswer *)answer
+                 what:(NSString *)what
           componentId:(NSString *)componentId
                source:(nullable UIViewController *)source;
 

package/ios/Layouts/Stack/ANNStackQueue.mm

@@ -16,7 +16,11 @@
 // How long the new top of a `setStackRoot` waits for its first content when `waitForRender` is not set.
 static const NSTimeInterval ANNStackRootRenderLimit = 0.5;
 
-// The limits of the bar components of a push: title and background 1 s, buttons 0.5 s, together from the wait's start.
+// How long a push waits for its new top's first content when `waitForRender` is not set.
+static const NSTimeInterval ANNPushRenderLimit = 0.5;
+
+// The limits of the bar components of a push: title and background 1 s, buttons 0.5 s. With `waitForRender` unset they
+// count from the wait's start, the content's time coming off them; with `true`, from the content's end.
 static const ANNBarWaitLimits ANNPushBarLimits = {1, 0.5};
 
 // The bar components of a `setStackRoot` within its 0.5 s.
@@ -53,8 +57,8 @@ typedef NS_ENUM(NSInteger, ANNStackOperationKind) {
 @property(nonatomic) BOOL animated;
 @property(nonatomic) BOOL waits;
 @property(nonatomic) BOOL atOnce;
-// When the replace's own wait for its new top started (`waitForRender` unset): the custom transition's wait takes what
-// is left of the 0.5 s. 0 when it didn't wait so.
+// When the push's or the replace's own wait for its new top started (`waitForRender` unset): the custom transition's
+// wait takes what is left of the 0.5 s. 0 when it didn't wait so.
 @property(nonatomic) CFTimeInterval waitStarted;
 @property(nonatomic, copy, nullable) dispatch_block_t completion;
 @property(nonatomic, copy, nullable) ANNTransitionRejectionBlock rejection;
@@ -371,12 +375,13 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
 
 - (void)noneWithValue:(id)value
                answer:(ANNCommandAnswer *)answer
+                 what:(NSString *)what
           componentId:(NSString *)componentId
                source:(UIViewController *)source {
     ANNAssertMainQueue();
     ANNStackOperation *operation = [self operationOfKind:ANNStackOperationNone
                                                   answer:answer
-                                                    what:@"pop"
+                                                    what:what
                                              componentId:componentId
                                                   source:source];
     operation.value = value;
@@ -559,41 +564,35 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
         [self scheduleRunNext];
         return;
     }
-    // `waitForRender: true` waits for the content as long as it takes, then for the bar components (their limits from
-    // the content's end); unset (also with `enabled: false`), only for the bar components, each kind to its own limit,
-    // without parking (bar roots render out of a window); `false`, for nothing. The content comes during the
-    // transition. A stack that isn't seen never waits.
+    // `waitForRender: true` waits for the content as long as it takes, then for the bar components, each kind to its own
+    // limit from the content's end; unset (also with `enabled: false`), for its first content at most 0.5 s, then for
+    // the bar components, each kind to its own limit from the wait's start (as when the push waited for them alone);
+    // `false`, for nothing, the content coming during the transition. Either wait's content ends after the calls
+    // JavaScript made in the commit that mounted the content (its `useScreenOptions`), content there already too, so
+    // that their options are in the bar on the transition's first frame. A native screen ends the wait at its start. A
+    // stack that isn't seen never waits.
     Bool *waitForRender = [node resolveOptionsWithDefault].animations.push.waitForRender;
     // A push whose caller waited already (a preview, `showInColumn`) waits for nothing here.
     BOOL onScreen = operation.waits && [_display stackIsOnScreen];
     __weak ANNStackQueue *weakSelf = self;
     __weak ANNStackOperation *weakOperation = operation;
-    if (onScreen && waitForRender.hasValue && waitForRender.get) {
-        [self waitFor:operation
-                    entry:node
-                  content:ANNRenderWaitContentNode
-                    limit:0
-             unknownLimit:YES
-                      bar:ANNRenderWaitBarAfterContent
-                barLimits:ANNPushBarLimits
-                     then:^{
-                       [weakSelf startPushTransition:weakOperation];
-                     }];
-        return;
-    }
-    if (onScreen && !waitForRender.hasValue) {
+    if (onScreen && (!waitForRender.hasValue || waitForRender.get)) {
+        BOOL bounded = !waitForRender.hasValue;
+        if (bounded) {
+            operation.waitStarted = CACurrentMediaTime();
+        }
         [self waitFor:operation
-                    entry:node
-                  content:ANNRenderWaitContentNone
-                    limit:0
-             unknownLimit:NO
-                      bar:ANNRenderWaitBarAfterContent
-                barLimits:ANNPushBarLimits
-                     then:^{
-                       // UIKit sizes the screen inside the push: it makes its content right before.
-                       [weakOperation.node render];
-                       [weakSelf startPushTransition:weakOperation];
-                     }];
+                       entry:node
+                     content:ANNRenderWaitContentNode
+                       limit:bounded ? ANNPushRenderLimit : 0
+                unknownLimit:!bounded
+                         bar:ANNRenderWaitBarAfterContent
+                   barLimits:ANNPushBarLimits
+             afterJavaScript:YES
+                barFromStart:bounded
+                        then:^{
+                          [weakSelf startPushTransition:weakOperation];
+                        }];
         return;
     }
     // UIKit sizes the screen inside the push: it makes its content right before.
@@ -616,10 +615,14 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
     operation.covered = covered;
     ANNTransitionPlan *plan = nil;
     if (animated) {
+        // Unset `waitForRender`: the custom transition's wait takes what is left of the push's own 0.5 s.
+        NSTimeInterval limit =
+            [ANNAnimationRules customWaitLimitAfterWaitStartedAt:operation.waitStarted
+                                                    commandLimit:ANNPushRenderLimit];
         plan = [ANNTransitionPlan stackPlanOfKind:ANNTransitionKindPush
                                         animation:push
                                     waitForRender:push.waitForRender
-                                        waitLimit:ANNCustomTransitionWaitLimit
+                                        waitLimit:limit
                                              from:covered
                                                to:node];
     }
@@ -746,6 +749,8 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
                  unknownLimit:NO
                           bar:ANNRenderWaitBarWithContent
                     barLimits:ANNStackRootBarLimits
+              afterJavaScript:NO
+                 barFromStart:NO
                          then:^{
                            [weakSelf startReplaceTransition:weakOperation];
                          }];
@@ -759,6 +764,8 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
                  unknownLimit:YES
                           bar:ANNRenderWaitBarAfterContent
                     barLimits:ANNStackRootBarLimits
+              afterJavaScript:NO
+                 barFromStart:NO
                          then:^{
                            [weakSelf startReplaceTransition:weakOperation];
                          }];
@@ -1046,16 +1053,20 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
 // for it in the stack's view, its appearance driven: the wait ends at the entry's ready handler (set first, then the
 // park and `render`, then the test of 16.1), at `limit` with `markReady`, or with `unknownLimit` for a screen whose
 // rendered state stays unknown after 1 s. Without content, only the bar components, without parking (bar roots render
-// out of a window). A wait that would end does nothing once its operation ended or belongs to an old JavaScript; its
-// end runs protected (the end steps of the operation, `then`).
+// out of a window). With `afterJavaScript` the content's end waits for the calls JavaScript made by then
+// (`settlesThroughJavaScript`); with `barFromStart` the bar phase's limits count from the wait's start
+// (`barLimitsFromStart`). A wait that would end does nothing once its operation ended or belongs to an old
+// JavaScript; its end runs protected (the end steps of the operation, `then`).
 - (void)waitFor:(ANNStackOperation *)operation
-           entry:(UIViewController *)entry
-         content:(ANNRenderWaitContent)content
-           limit:(NSTimeInterval)limit
-    unknownLimit:(BOOL)unknownLimit
-             bar:(ANNRenderWaitBar)bar
-       barLimits:(ANNBarWaitLimits)barLimits
-            then:(dispatch_block_t)then {
+              entry:(UIViewController *)entry
+            content:(ANNRenderWaitContent)content
+              limit:(NSTimeInterval)limit
+       unknownLimit:(BOOL)unknownLimit
+                bar:(ANNRenderWaitBar)bar
+          barLimits:(ANNBarWaitLimits)barLimits
+    afterJavaScript:(BOOL)afterJavaScript
+       barFromStart:(BOOL)barFromStart
+               then:(dispatch_block_t)then {
     __weak ANNStackQueue *weakSelf = self;
     __weak ANNStackOperation *weakOperation = operation;
     // The screens the wait is about are those the entry waits for (a pair: the ones it puts in the window).
@@ -1069,6 +1080,8 @@ static NSArray<UIViewController *> *ANNTopFirst(NSArray<UIViewController *> *ent
                                                              bar:bar
                                                        barLimits:barLimits];
     wait.unknownContentRule = unknownLimit;
+    wait.settlesThroughJavaScript = afterJavaScript;
+    wait.barLimitsFromStart = barFromStart;
     wait.canEnd = ^BOOL {
       ANNStackQueue *queue = weakSelf;
       ANNStackOperation *waiting = weakOperation;

package/ios/Layouts/Stack/ANNSwipePopInteraction.h

@@ -0,0 +1,26 @@
+#import <UIKit/UIKit.h>
+
+@class ANNTransitionAnimator;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The interaction of a swipe back that plays the screen's own pop (`animations.pop.interactive`). It follows the
+/// stack's own swipe from the leading edge (UIKit runs its swipe without asking the delegate for a transition), and
+/// shows the animator's frames as far as the finger went across `view`, in the direction of the swipe back. Letting go
+/// finishes the pop after a flick back or past half way, and puts the screen back otherwise; the rest plays faster
+/// after a quick flick, never slower, and UIKit ends its part at the same pace. An interaction UIKit never starts goes
+/// with the end of the gesture. Main queue.
+@interface ANNSwipePopInteraction : NSObject <UIViewControllerInteractiveTransitioning>
+
+- (instancetype)initWithAnimator:(ANNTransitionAnimator *)animator
+                      recognizer:(UIPanGestureRecognizer *)recognizer
+                            view:(UIView *)view NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@property(nonatomic, weak, readonly, nullable) ANNTransitionAnimator *animator;
+
+@end
+
+NS_ASSUME_NONNULL_END