@onekeyfe/react-native-pager-view 6.7.0-alpha.430 → 6.7.0-alpha.435

package/ios/tests/RNCCollapsiblePagerHitTestTests.mm

@@ -12,6 +12,19 @@ using namespace facebook::react;
 - (void)updateTopScrollEdgeForScrollView:(UIScrollView *)scrollView;
 - (void)updateScrollEdgeContentMasks;
 - (void)layoutSharedHeaders;
+- (void)adoptCurrentScrollEdgeForProgrammaticTransition:(BOOL)allowExternalOverlay;
+- (BOOL)resolveExternalTopOverlay;
+- (void)beginProgrammaticScrollEdgesToIndex:(NSInteger)index allowExternalOverlay:(BOOL)allowExternalOverlay;
+- (void)outerPagerDidUpdateOverlayOwner:(BOOL)active transitioning:(BOOL)transitioning;
+- (void)restorePinnedStickyHeader;
+- (void)finishProgrammaticScrollEdges;
+- (void)clearProgrammaticScrollEdges;
+- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView;
+- (void)scrollViewDidEndDragging:(UIScrollView *)scrollView willDecelerate:(BOOL)decelerate;
+- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView;
+- (void)goTo:(NSInteger)index animated:(BOOL)animated;
+- (void)scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView;
+- (void)emitPageSelected:(NSInteger)position;
 @end
 
 @interface UIView (NativeTabReservationTesting)
@@ -33,6 +46,19 @@ using namespace facebook::react;
 - (void)setLeftToRight:(BOOL)leftToRight;
 @end
 
+@interface RNCCollapsiblePagerResizeSelectionSpy : RNCCollapsiblePagerViewComponentView
+@property (nonatomic, strong) NSMutableArray<NSNumber *> *selectedIndexes;
+@end
+
+@implementation RNCCollapsiblePagerResizeSelectionSpy
+- (void)emitPageSelected:(NSInteger)position
+{
+  if (_selectedIndexes == nil) _selectedIndexes = [NSMutableArray new];
+  [_selectedIndexes addObject:@(position)];
+  [super emitPageSelected:position];
+}
+@end
+
 @interface RNCCollapsiblePagerHitTestTests : XCTestCase
 @property (nonatomic, strong) UIView *root;
 @property (nonatomic, strong) UIButton *toolbar;
@@ -390,6 +416,736 @@ using namespace facebook::react;
   }
 }
 
+- (UIScrollView *)preparePinnedLocalHardSource
+{
+  UIWindow *window = [[UIWindow alloc] initWithFrame:self.root.bounds];
+  [window addSubview:self.root];
+  window.hidden = NO;
+  [self addTeardownBlock:^{
+    [self.pager prepareForRecycle];
+    window.hidden = YES;
+  }];
+  UIView *container = [self.pager valueForKey:@"containerView"];
+  container.frame = self.pager.bounds;
+  UIViewController *page = [UIViewController new];
+  page.view = [[UIView alloc] initWithFrame:container.bounds];
+  UIScrollView *source = [[UIScrollView alloc] initWithFrame:page.view.bounds];
+  source.contentSize = CGSizeMake(320, 1200);
+  source.topEdgeEffect.style = UIScrollEdgeEffectStyle.softStyle;
+  [page.view addSubview:source];
+  [container insertSubview:page.view atIndex:0];
+  [[self.pager valueForKey:@"pageControllers"] addObject:page];
+  [self.pager setValue:source forKey:@"observedScrollView"];
+  [self.pager setValue:source forKey:@"sharedHeaderScrollView"];
+  [self.pager setValue:@YES forKey:@"directNativePagerEnabled"];
+  [self.pager setValue:@YES forKey:@"topScrollEdgeEnabled"];
+  [self.pager setValue:@(static_cast<NSInteger>(RNCCollapsiblePagerViewTopScrollEdgeEffect::Hard))
+               forKey:@"topScrollEdgeEffect"];
+  UIView *overlayHost = [self.pager valueForKey:@"topOverlayHostView"];
+  overlayHost.frame = CGRectMake(0, 0, 320, 50);
+  overlayHost.hidden = NO;
+  UIView *overlay = [[UIView alloc] initWithFrame:overlayHost.bounds];
+  [overlayHost addSubview:overlay];
+  [self.pager setValue:overlay forKey:@"topOverlayView"];
+  [self.pager setValue:@50 forKey:@"topOverlayHeight"];
+  [self.pager setValue:@100 forKey:@"headerHeight"];
+  [self.pager setValue:@44 forKey:@"stickyHeaderHeight"];
+  [self.pager setValue:@100 forKey:@"headerOffset"];
+  UIView *pinnedHost = [self.pager valueForKey:@"pinnedStickyHostView"];
+  pinnedHost.frame = CGRectMake(0, 50, 320, 44);
+  pinnedHost.hidden = NO;
+  [source addSubview:pinnedHost];
+  [pinnedHost addSubview:self.sticky];
+  [self.pager setValue:self.sticky forKey:@"stickyHeaderView"];
+  [self.pager setValue:@YES forKey:@"stickyHeaderIsPinned"];
+  [self.pager updateTopScrollEdgeForScrollView:source];
+  return source;
+}
+
+- (UIScrollView *)prepareDirectDragWithSource:(UIScrollView **)sourceOut
+{
+  UIScrollView *source = [self preparePinnedLocalHardSource];
+  UIView *container = [self.pager valueForKey:@"containerView"];
+  UIScrollView *horizontal = [[UIScrollView alloc] initWithFrame:container.bounds];
+  horizontal.contentSize = CGSizeMake(960, CGRectGetHeight(container.bounds));
+  horizontal.pagingEnabled = YES;
+  horizontal.delegate = (id<UIScrollViewDelegate>)self.pager;
+  [container insertSubview:horizontal atIndex:0];
+  NSMutableArray<UIViewController *> *pages = [self.pager valueForKey:@"pageControllers"];
+  UIViewController *sourcePage = pages.firstObject;
+  for (NSInteger index = 0; index < 3; index++) {
+    UIViewController *page = index == 1 ? sourcePage : [UIViewController new];
+    if (index != 1) {
+      page.view = [[UIView alloc] initWithFrame:container.bounds];
+      UIScrollView *list = [[UIScrollView alloc] initWithFrame:page.view.bounds];
+      list.contentSize = CGSizeMake(320, 1200);
+      list.topEdgeEffect.style = UIScrollEdgeEffectStyle.softStyle;
+      [page.view addSubview:list];
+    }
+    page.view.frame = CGRectMake(index * 320, 0, 320, CGRectGetHeight(container.bounds));
+    [horizontal addSubview:page.view];
+    if (index == 0) [pages insertObject:page atIndex:0];
+    if (index == 2) [pages addObject:page];
+  }
+  horizontal.contentOffset = CGPointMake(320, 0);
+  [self.pager setValue:horizontal forKey:@"pagerScrollView"];
+  [self.pager setValue:@1 forKey:@"currentIndex"];
+  [self.pager setValue:@1 forKey:@"destinationIndex"];
+  [self.pager setValue:@"ltr" forKey:@"layoutDirection"];
+  [self.pager setValue:@YES forKey:@"hasAppliedInitialPage"];
+  if (sourceOut != nil) *sourceOut = source;
+  return horizontal;
+}
+
+- (UIScrollView *)prepareExternalDirectDragWithSource:(UIScrollView **)sourceOut
+                                           overlay:(UIView **)overlayOut
+{
+  UIScrollView *source = nil;
+  UIScrollView *horizontal = [self prepareDirectDragWithSource:&source];
+  [self.pager updateTopScrollEdgeForScrollView:nil];
+  UIView *local = [self.pager valueForKey:@"topOverlayView"];
+  [local removeFromSuperview];
+  [self.pager setValue:nil forKey:@"topOverlayView"];
+  [self.pager setValue:@0 forKey:@"topOverlayHeight"];
+  UIView *overlay = [[UIView alloc] initWithFrame:CGRectMake(0, 100, 320, 50)];
+  overlay.tag = 8675309;
+  [self.root addSubview:overlay];
+  auto props = std::make_shared<RNCCollapsiblePagerViewProps>();
+  props->nativeSmoothHeaderScrollEnabled = true;
+  props->topScrollEdgeEffect = RNCCollapsiblePagerViewTopScrollEdgeEffect::Hard;
+  props->externalTopOverlayTag = overlay.tag;
+  [self.pager updateProps:props oldProps:nullptr];
+  [self.pager resolveExternalTopOverlay];
+  XCTAssertEqual([self.pager valueForKey:@"externalTopOverlayView"], overlay);
+  XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"externalTopOverlayHeight"] doubleValue], 50, 0.001);
+  XCTAssertEqual(overlay.window, self.pager.window);
+  XCTAssertFalse([overlay isDescendantOfView:self.pager]);
+  UIView *proxy = [self.pager valueForKey:@"topOverlayHostView"];
+  XCTAssertEqual(proxy.window, self.pager.window);
+  XCTAssertFalse(proxy.hidden);
+  XCTAssertFalse(proxy.userInteractionEnabled);
+  [self.pager updateTopScrollEdgeForScrollView:source];
+  XCTAssertEqual([[self.pager valueForKey:@"pageControllers"] count], 3);
+  XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 1);
+  XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 320, 0.001);
+  XCTAssertTrue([[self.pager valueForKey:@"hasAppliedInitialPage"] boolValue]);
+  XCTAssertTrue([[self.pager valueForKey:@"directNativePagerEnabled"] boolValue]);
+  XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"headerOffset"] doubleValue], 100, 0.001);
+  XCTAssertTrue([[self.pager valueForKey:@"stickyHeaderIsPinned"] boolValue]);
+  XCTAssertNotNil([self.pager valueForKey:@"stickyEdgeInteraction"]);
+  if (sourceOut != nil) *sourceOut = source;
+  if (overlayOut != nil) *overlayOut = overlay;
+  return horizontal;
+}
+
+- (UIScrollView *)prepareNativeResizeCommandPager
+{
+  [self.pager removeFromSuperview];
+  self.pager = [RNCCollapsiblePagerResizeSelectionSpy new];
+  [self setPointerEvents:PointerEventsMode::Auto];
+  self.pager.frame = CGRectMake(0, 100, 320, 500);
+  [self.root addSubview:self.pager];
+  UIScrollView *horizontal = [self prepareDirectDragWithSource:NULL];
+  XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 1);
+  XCTAssertEqualWithAccuracy(CGRectGetWidth(horizontal.bounds), 320, 0.001);
+  XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 320, 0.001);
+  XCTAssertTrue(horizontal.scrollEnabled);
+  return horizontal;
+}
+
+- (void)waitForNativeResizeCommandsToSettle
+{
+  NSPredicate *settled = [NSPredicate predicateWithBlock:^BOOL(id object, NSDictionary *bindings) {
+    return ![[self.pager valueForKey:@"transitioning"] boolValue] &&
+      [self.pager valueForKey:@"pendingNativePagerScrollCompletion"] == nil &&
+      [[self.pager valueForKey:@"pendingGoToIndex"] integerValue] == -1;
+  }];
+  XCTNSPredicateExpectation *expectation = [[XCTNSPredicateExpectation alloc]
+    initWithPredicate:settled object:self.pager];
+  [self waitForExpectations:@[expectation] timeout:3];
+}
+
+- (void)testNativeAnimatedCommandResizeRebasesAndDrainsQueueIgnoringLateEnd
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *horizontal = [self prepareNativeResizeCommandPager];
+    RNCCollapsiblePagerResizeSelectionSpy *spy = (id)self.pager;
+    [self.pager goTo:2 animated:YES];
+    id originalPending = [self.pager valueForKey:@"pendingNativePagerScrollCompletion"];
+    XCTAssertNotNil(originalPending);
+    XCTAssertFalse(horizontal.scrollEnabled);
+    XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"pendingNativePagerScrollTarget"] doubleValue], 640, 0.001);
+    self.pager.frame = CGRectMake(0, 100, 320, 480);
+    [self.pager layoutSubviews];
+    XCTAssertEqual([self.pager valueForKey:@"pendingNativePagerScrollCompletion"], originalPending);
+    XCTAssertEqual(spy.selectedIndexes.count, 0);
+    [self.pager goTo:0 animated:YES];
+    XCTAssertEqual([[self.pager valueForKey:@"pendingGoToIndex"] integerValue], 0);
+    self.pager.frame = CGRectMake(0, 100, 320.4, 480);
+    [self.pager layoutSubviews];
+    XCTAssertNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 640.8, 1.0 / horizontal.window.screen.scale);
+    XCTAssertGreaterThan(horizontal.contentOffset.x, 640.5);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 2);
+    XCTAssertTrue(horizontal.scrollEnabled);
+    XCTAssertEqualObjects(spy.selectedIndexes, (@[@2]));
+    [self.pager scrollViewDidEndScrollingAnimation:horizontal];
+    XCTAssertEqualObjects(spy.selectedIndexes, (@[@2]));
+    XCTestExpectation *queued = [self expectationWithDescription:@"queued native command starts"];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      id pending = [self.pager valueForKey:@"pendingNativePagerScrollCompletion"];
+      XCTAssertNotNil(pending);
+      XCTAssertNotEqual(pending, originalPending);
+      XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"pendingNativePagerScrollTarget"] doubleValue], 0, 0.001);
+      XCTAssertGreaterThan(fabs(horizontal.contentOffset.x), 0.5);
+      [self.pager scrollViewDidEndScrollingAnimation:horizontal];
+      XCTAssertEqual([self.pager valueForKey:@"pendingNativePagerScrollCompletion"], pending);
+      XCTAssertEqualObjects(spy.selectedIndexes, (@[@2]));
+      [queued fulfill];
+    });
+    [self waitForExpectations:@[queued] timeout:2];
+    // This hostless fixture does not drive the natural scroll animation.
+    // Exercise the controlled UIKit end boundary after checking stale-end rejection.
+    XCTAssertNotNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    [horizontal setContentOffset:CGPointZero animated:NO];
+    [self.pager scrollViewDidEndScrollingAnimation:horizontal];
+    [self waitForNativeResizeCommandsToSettle];
+    XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 0, 0.001);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 0);
+    XCTAssertTrue(horizontal.scrollEnabled);
+    XCTAssertEqualObjects(spy.selectedIndexes, (@[@2, @0]));
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+  } else {
+    XCTSkip(@"Native local Hard animation requires iOS 27 or newer");
+  }
+}
+
+- (void)testNativeAnimatedCommandResizeRebasesNonzeroRTLTarget
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *horizontal = [self prepareNativeResizeCommandPager];
+    RNCCollapsiblePagerResizeSelectionSpy *spy = (id)self.pager;
+    [self.pager setValue:@"rtl" forKey:@"layoutDirection"];
+    [self.pager goTo:0 animated:YES];
+    XCTAssertNotNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"pendingNativePagerScrollTarget"] doubleValue], 640, 0.001);
+    self.pager.frame = CGRectMake(0, 100, 400, 500);
+    [self.pager layoutSubviews];
+    XCTAssertNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 800, 0.001);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 0);
+    [self.pager scrollViewDidEndScrollingAnimation:horizontal];
+    [self waitForNativeResizeCommandsToSettle];
+    XCTAssertEqualObjects(spy.selectedIndexes, (@[@0]));
+    XCTAssertTrue(horizontal.scrollEnabled);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+  } else {
+    XCTSkip(@"Native local Hard animation requires iOS 27 or newer");
+  }
+}
+
+- (void)testNativeAnimatedCommandZeroWidthCompletesQueueAndRealignsOnRestore
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *horizontal = [self prepareNativeResizeCommandPager];
+    RNCCollapsiblePagerResizeSelectionSpy *spy = (id)self.pager;
+    [self.pager goTo:0 animated:YES];
+    XCTAssertNotNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    [self.pager goTo:2 animated:YES];
+    self.pager.frame = CGRectMake(0, 100, 0, 500);
+    [self.pager layoutSubviews];
+    XCTAssertNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 0);
+    XCTAssertTrue(horizontal.scrollEnabled);
+    [self.pager scrollViewDidEndScrollingAnimation:horizontal];
+    [self waitForNativeResizeCommandsToSettle];
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 2);
+    XCTAssertTrue(horizontal.scrollEnabled);
+    XCTAssertEqualObjects(spy.selectedIndexes, (@[@0, @2]));
+    self.pager.frame = CGRectMake(0, 100, 400, 500);
+    [self.pager layoutSubviews];
+    XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 800, 0.001);
+    [self.pager scrollViewDidEndScrollingAnimation:horizontal];
+    XCTAssertEqualObjects(spy.selectedIndexes, (@[@0, @2]));
+    XCTAssertNil([self.pager valueForKey:@"pendingNativePagerScrollCompletion"]);
+    XCTAssertFalse([[self.pager valueForKey:@"transitioning"] boolValue]);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+  } else {
+    XCTSkip(@"Native local Hard animation requires iOS 27 or newer");
+  }
+}
+
+- (void)testExternalDirectDragPreservesProxyIdentityAndSettles
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIView *overlay = nil;
+    UIScrollView *horizontal = [self prepareExternalDirectDragWithSource:&source overlay:&overlay];
+    UIView *proxy = [self.pager valueForKey:@"topOverlayHostView"];
+    UIView *pinned = [self.pager valueForKey:@"pinnedStickyHostView"];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    UIScrollEdgeElementContainerInteraction *sticky = [self.pager valueForKey:@"stickyEdgeInteraction"];
+    UIView *marker = [self.pager valueForKey:@"topEdgeMarker"];
+    UIView *stickyMarker = [self.pager valueForKey:@"stickyEdgeMarker"];
+    NSArray<UIViewController *> *pages = [self.pager valueForKey:@"pageControllers"];
+    UIScrollView *target = (UIScrollView *)pages[2].view.subviews.firstObject;
+    XCTAssertNotNil(top);
+    XCTAssertNotNil(sticky);
+    XCTAssertTrue([proxy.interactions containsObject:top]);
+    XCTAssertEqual(overlay.interactions.count, 0);
+    [self.pager adoptCurrentScrollEdgeForProgrammaticTransition:NO];
+    [self.pager beginProgrammaticScrollEdgesToIndex:2 allowExternalOverlay:NO];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertEqual([self.pager valueForKey:@"topEdgeInteraction"], top);
+
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    NSArray *owners = [self.pager valueForKey:@"programmaticScrollEdgeOwners"];
+    XCTAssertEqual(owners.count, 3);
+    id sourceOwner = owners.firstObject;
+    XCTAssertEqual([sourceOwner valueForKey:@"topInteraction"], top);
+    XCTAssertEqual([sourceOwner valueForKey:@"stickyInteraction"], sticky);
+    XCTAssertEqual([sourceOwner valueForKey:@"topMarker"], marker);
+    XCTAssertEqual([sourceOwner valueForKey:@"topHost"], proxy);
+    XCTAssertEqual([sourceOwner valueForKey:@"originalStyle"], UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertTrue([[sourceOwner valueForKey:@"borrowsPinnedStickyHost"] boolValue]);
+    XCTAssertFalse([[sourceOwner valueForKey:@"ownsTransitionHosts"] boolValue]);
+    XCTAssertEqual(top.scrollView, source);
+    XCTAssertEqual(sticky.scrollView, source);
+    XCTAssertEqual(marker.superview, proxy);
+    XCTAssertEqual(pinned.superview, source);
+    XCTAssertFalse([self.pager resolveExternalTopOverlay]);
+    [self.pager updateTopScrollEdgeForScrollView:source];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    XCTAssertEqual(overlay.superview, self.root);
+    XCTAssertEqual(overlay.interactions.count, 0);
+
+    NSMutableArray *incomingOwners = [NSMutableArray new];
+    NSMutableArray<UIView *> *ownedHosts = [NSMutableArray new];
+    NSMutableArray<UIView *> *ownedMarkers = [NSMutableArray new];
+    NSMutableArray<UIScrollEdgeElementContainerInteraction *> *ownedEdges = [NSMutableArray new];
+    for (id owner in owners) {
+      if (owner == sourceOwner) continue;
+      [incomingOwners addObject:owner];
+      XCTAssertTrue([[owner valueForKey:@"ownsTransitionHosts"] boolValue]);
+      UIView *page = [owner valueForKey:@"page"];
+      UIScrollView *list = [owner valueForKey:@"scrollView"];
+      UIView *ownedTop = [owner valueForKey:@"ownedTopHost"];
+      UIView *ownedSticky = [owner valueForKey:@"ownedStickyHost"];
+      XCTAssertNotNil(ownedTop);
+      XCTAssertNotNil(ownedSticky);
+      XCTAssertEqual([owner valueForKey:@"topHost"], ownedTop);
+      XCTAssertEqual([owner valueForKey:@"stickyHost"], ownedSticky);
+      XCTAssertNotEqual(ownedTop, ownedSticky);
+      for (NSString *edgeName in @[@"top", @"sticky"]) {
+        UIView *host = [owner valueForKey:[edgeName stringByAppendingString:@"Host"]];
+        UIView *edgeMarker = [owner valueForKey:[edgeName stringByAppendingString:@"Marker"]];
+        UIScrollEdgeElementContainerInteraction *edge =
+          [owner valueForKey:[edgeName stringByAppendingString:@"Interaction"]];
+        XCTAssertFalse([ownedHosts containsObject:host]);
+        [ownedHosts addObject:host];
+        [ownedMarkers addObject:edgeMarker];
+        [ownedEdges addObject:edge];
+        XCTAssertEqual(host.superview, page);
+        XCTAssertNotEqual(host, proxy);
+        XCTAssertNotEqual(host, self.sticky);
+        XCTAssertNotEqual(host, overlay);
+        XCTAssertFalse(host.userInteractionEnabled);
+        XCTAssertTrue(host.accessibilityElementsHidden);
+        if (host.backgroundColor != nil) {
+          XCTAssertEqualWithAccuracy(CGColorGetAlpha(host.backgroundColor.CGColor), 0, 0.001);
+        }
+        XCTAssertEqual(edge.view, host);
+        XCTAssertEqual(edge.scrollView, list);
+        XCTAssertEqual(edgeMarker.superview, host);
+        XCTAssertEqualWithAccuracy(host.frame.origin.x,
+          CGRectGetMinX([list convertRect:list.bounds toView:page]), 0.001);
+      }
+      CGRect pageFrame = page.frame;
+      CGRect listFrame = list.frame;
+      CGRect topFrame = ownedTop.frame;
+      CGRect stickyFrame = ownedSticky.frame;
+      page.frame = CGRectMake(pageFrame.origin.x, pageFrame.origin.y, 400, pageFrame.size.height);
+      list.frame = CGRectMake(listFrame.origin.x, listFrame.origin.y, 400, listFrame.size.height);
+      XCTAssertEqualWithAccuracy(ownedTop.frame.size.width, 400, 0.001);
+      XCTAssertEqualWithAccuracy(ownedSticky.frame.size.width, 400, 0.001);
+      XCTAssertEqualWithAccuracy(((UIView *)[owner valueForKey:@"topMarker"]).frame.size.width, 400, 0.001);
+      XCTAssertEqualWithAccuracy(((UIView *)[owner valueForKey:@"stickyMarker"]).frame.size.width, 400, 0.001);
+      XCTAssertEqualWithAccuracy(ownedTop.frame.origin.y, topFrame.origin.y, 0.001);
+      XCTAssertEqualWithAccuracy(ownedSticky.frame.origin.y, stickyFrame.origin.y, 0.001);
+      XCTAssertEqualWithAccuracy(ownedTop.frame.size.height, topFrame.size.height, 0.001);
+      XCTAssertEqualWithAccuracy(ownedSticky.frame.size.height, stickyFrame.size.height, 0.001);
+      page.frame = pageFrame;
+      list.frame = listFrame;
+    }
+    XCTAssertEqual(incomingOwners.count, 2);
+    XCTAssertEqual(ownedHosts.count, 4);
+    horizontal.contentOffset = CGPointMake(480, 0);
+    for (id owner in incomingOwners) {
+      UIScrollView *list = [owner valueForKey:@"scrollView"];
+      CGRect viewport = [list convertRect:list.bounds toView:nil];
+      UIView *ownedTop = [owner valueForKey:@"ownedTopHost"];
+      UIView *ownedSticky = [owner valueForKey:@"ownedStickyHost"];
+      CGRect topWindow = [ownedTop convertRect:ownedTop.bounds toView:nil];
+      CGRect stickyWindow = [ownedSticky convertRect:ownedSticky.bounds toView:nil];
+      XCTAssertNotEqualWithAccuracy(viewport.origin.x, 0, 0.001);
+      XCTAssertEqualWithAccuracy(topWindow.origin.x, viewport.origin.x, 0.001);
+      XCTAssertEqualWithAccuracy(stickyWindow.origin.x, viewport.origin.x, 0.001);
+      XCTAssertEqualWithAccuracy(topWindow.origin.y, viewport.origin.y, 0.001);
+      XCTAssertEqualWithAccuracy(stickyWindow.origin.y, viewport.origin.y + 50, 0.001);
+    }
+
+    horizontal.contentOffset = CGPointMake(640, 0);
+    [self.pager scrollViewDidEndDragging:horizontal willDecelerate:NO];
+    XCTestExpectation *settled = [self expectationWithDescription:@"external drag settles"];
+    dispatch_async(dispatch_get_main_queue(), ^{ [settled fulfill]; });
+    [self waitForExpectations:@[settled] timeout:2];
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 2);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    for (id owner in incomingOwners) {
+      XCTAssertNil([owner valueForKey:@"ownedTopHost"]);
+      XCTAssertNil([owner valueForKey:@"ownedStickyHost"]);
+    }
+    for (UIView *host in ownedHosts) {
+      XCTAssertNil(host.superview);
+      XCTAssertEqual(host.interactions.count, 0);
+    }
+    for (UIView *edgeMarker in ownedMarkers) XCTAssertNil(edgeMarker.superview);
+    for (UIScrollEdgeElementContainerInteraction *edge in ownedEdges) XCTAssertNil(edge.scrollView);
+    XCTAssertEqual(proxy.superview, [self.pager valueForKey:@"containerView"]);
+    XCTAssertNotNil(self.sticky.superview);
+    XCTAssertNil(top.scrollView);
+    XCTAssertNil(sticky.scrollView);
+    XCTAssertNil(marker.superview);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    UIScrollEdgeElementContainerInteraction *normal = [self.pager valueForKey:@"topEdgeInteraction"];
+    XCTAssertNotNil(normal);
+    XCTAssertEqual(normal.scrollView, target);
+    XCTAssertEqual([self.pager valueForKey:@"topEdgeScrollView"], target);
+    XCTAssertEqual([self.pager valueForKey:@"originalTopEdgeStyle"], UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertEqual(target.topEdgeEffect.style, UIScrollEdgeEffectStyle.hardStyle);
+    UIScrollView *otherNeighbor = (UIScrollView *)pages[0].view.subviews.firstObject;
+    XCTAssertEqual(otherNeighbor.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertNil(stickyMarker.superview);
+    XCTAssertEqual([self.pager valueForKey:@"topEdgeInteractionHost"], proxy);
+    XCTAssertEqual(overlay.superview, self.root);
+    XCTAssertEqual(overlay.interactions.count, 0);
+  } else {
+    XCTSkip(@"External direct Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testExternalOverlayGeometryChangeReleasesBorrowedEdges
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIView *overlay = nil;
+    UIScrollView *horizontal = [self prepareExternalDirectDragWithSource:&source overlay:&overlay];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    UIView *pinned = [self.pager valueForKey:@"pinnedStickyHostView"];
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    id incoming = [[self.pager valueForKey:@"programmaticScrollEdgeOwners"] lastObject];
+    UIView *ownedTop = [incoming valueForKey:@"ownedTopHost"];
+    UIView *ownedSticky = [incoming valueForKey:@"ownedStickyHost"];
+    UIView *ownedMarker = [incoming valueForKey:@"topMarker"];
+    UIScrollEdgeElementContainerInteraction *ownedEdge = [incoming valueForKey:@"topInteraction"];
+    UIView *proxy = [self.pager valueForKey:@"topOverlayHostView"];
+    UIView *stickyParent = self.sticky.superview;
+    XCTAssertNotNil(ownedTop);
+    XCTAssertNotNil(ownedSticky);
+    overlay.frame = CGRectMake(0, 100, 320, 60);
+    XCTAssertTrue([self.pager resolveExternalTopOverlay]);
+    XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"externalTopOverlayHeight"] doubleValue], 60, 0.001);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertNil(top.scrollView);
+    XCTAssertNil(ownedTop.superview);
+    XCTAssertNil(ownedSticky.superview);
+    XCTAssertEqual(ownedTop.interactions.count, 0);
+    XCTAssertEqual(ownedSticky.interactions.count, 0);
+    XCTAssertNil(ownedMarker.superview);
+    XCTAssertNil(ownedEdge.scrollView);
+    XCTAssertNil([incoming valueForKey:@"ownedTopHost"]);
+    XCTAssertNil([incoming valueForKey:@"ownedStickyHost"]);
+    XCTAssertEqual(proxy.superview, [self.pager valueForKey:@"containerView"]);
+    XCTAssertEqual(self.sticky.superview, stickyParent);
+    XCTAssertEqual(overlay.superview, self.root);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertEqual(pinned.superview, [self.pager valueForKey:@"containerView"]);
+    XCTAssertTrue(pinned.hidden);
+  } else {
+    XCTSkip(@"External direct Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testExternalOverlayReplacementReleasesBorrowedEdges
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIView *overlay = nil;
+    UIScrollView *horizontal = [self prepareExternalDirectDragWithSource:&source overlay:&overlay];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    XCTAssertNotNil(top);
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    UIView *replacement = [[UIView alloc] initWithFrame:overlay.frame];
+    replacement.tag = overlay.tag;
+    [overlay removeFromSuperview];
+    [self.root addSubview:replacement];
+    XCTAssertTrue([self.pager resolveExternalTopOverlay]);
+    XCTAssertEqual([self.pager valueForKey:@"externalTopOverlayView"], replacement);
+    XCTAssertEqualWithAccuracy([[self.pager valueForKey:@"externalTopOverlayHeight"] doubleValue], 50, 0.001);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertNil(top.scrollView);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertEqual(replacement.interactions.count, 0);
+    XCTAssertEqual(replacement.superview, self.root);
+  } else {
+    XCTSkip(@"External direct Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testExternalOverlayTagChangeReleasesBorrowedEdges
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIScrollView *horizontal = [self prepareExternalDirectDragWithSource:&source overlay:nil];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    XCTAssertNotNil(top);
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    auto props = std::make_shared<RNCCollapsiblePagerViewProps>();
+    props->nativeSmoothHeaderScrollEnabled = true;
+    props->topScrollEdgeEffect = RNCCollapsiblePagerViewTopScrollEdgeEffect::Hard;
+    props->externalTopOverlayTag = 0;
+    [self.pager updateProps:props oldProps:nullptr];
+    XCTAssertEqual([[self.pager valueForKey:@"externalTopOverlayTag"] integerValue], 0);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertNil(top.scrollView);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+  } else {
+    XCTSkip(@"External direct Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testExternalOuterInactivityReleasesBorrowedEdges
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIScrollView *horizontal = [self prepareExternalDirectDragWithSource:&source overlay:nil];
+    RNCPagerViewComponentView *outer = [RNCPagerViewComponentView new];
+    [self.pager setValue:outer forKey:@"externalOuterPager"];
+    [self.pager setValue:@YES forKey:@"externalOuterPageActive"];
+    [self.pager setValue:@NO forKey:@"externalOuterTransitioning"];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    XCTAssertNotNil(top);
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    [self.pager outerPagerDidUpdateOverlayOwner:NO transitioning:NO];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertNil(top.scrollView);
+    XCTAssertNil([self.pager valueForKey:@"topEdgeInteraction"]);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    [self.pager beginProgrammaticScrollEdgesToIndex:2 allowExternalOverlay:YES];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+  } else {
+    XCTSkip(@"External direct Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testExternalOuterTransitionReleasesBorrowedEdges
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIScrollView *horizontal = [self prepareExternalDirectDragWithSource:&source overlay:nil];
+    RNCPagerViewComponentView *outer = [RNCPagerViewComponentView new];
+    [self.pager setValue:outer forKey:@"externalOuterPager"];
+    [self.pager setValue:@YES forKey:@"externalOuterPageActive"];
+    [self.pager setValue:@NO forKey:@"externalOuterTransitioning"];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    XCTAssertNotNil(top);
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    [self.pager outerPagerDidUpdateOverlayOwner:YES transitioning:YES];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertNil(top.scrollView);
+    XCTAssertNil([self.pager valueForKey:@"topEdgeInteraction"]);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    [self.pager beginProgrammaticScrollEdgesToIndex:2 allowExternalOverlay:YES];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+  } else {
+    XCTSkip(@"External direct Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testDirectDragAdoptsSourceBeforeDetachAndOwnsBothNeighbours
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIScrollView *horizontal = [self prepareDirectDragWithSource:&source];
+    UIView *topHost = [self.pager valueForKey:@"topEdgeInteractionHost"];
+    UIView *pinnedHost = [self.pager valueForKey:@"pinnedStickyHostView"];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    UIScrollEdgeElementContainerInteraction *sticky = [self.pager valueForKey:@"stickyEdgeInteraction"];
+    UIView *topMarker = [self.pager valueForKey:@"topEdgeMarker"];
+    UIView *stickyMarker = [self.pager valueForKey:@"stickyEdgeMarker"];
+    XCTAssertNotNil(top);
+    XCTAssertNotNil(sticky);
+
+    [self.pager scrollViewWillBeginDragging:horizontal];
+
+    NSArray *owners = [self.pager valueForKey:@"programmaticScrollEdgeOwners"];
+    XCTAssertEqual(owners.count, 3);
+    id sourceOwner = [owners firstObject];
+    XCTAssertEqual([sourceOwner valueForKey:@"topInteraction"], top);
+    XCTAssertEqual([sourceOwner valueForKey:@"stickyInteraction"], sticky);
+    XCTAssertEqual([sourceOwner valueForKey:@"topMarker"], topMarker);
+    XCTAssertEqual([sourceOwner valueForKey:@"stickyMarker"], stickyMarker);
+    XCTAssertEqual([sourceOwner valueForKey:@"originalStyle"], UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertTrue([[sourceOwner valueForKey:@"borrowsPinnedStickyHost"] boolValue]);
+    XCTAssertTrue([topHost.interactions containsObject:top]);
+    XCTAssertTrue([pinnedHost.interactions containsObject:sticky]);
+    XCTAssertEqual(top.scrollView, source);
+    XCTAssertEqual(sticky.scrollView, source);
+    XCTAssertEqual(topMarker.superview, topHost);
+    XCTAssertEqual(stickyMarker.superview, pinnedHost);
+    XCTAssertEqual(pinnedHost.superview, source);
+    XCTAssertFalse(pinnedHost.hidden);
+    for (id owner in owners) {
+      XCTAssertNotNil([owner valueForKey:@"topInteraction"]);
+      XCTAssertNotNil([[owner valueForKey:@"topInteraction"] scrollView]);
+    }
+  } else {
+    XCTSkip(@"Direct local Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testDirectDragTakeoverIgnoresOldSettlementAndReleasesOnReturn
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = nil;
+    UIScrollView *horizontal = [self prepareDirectDragWithSource:&source];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    UIView *topHost = [self.pager valueForKey:@"topEdgeInteractionHost"];
+    NSUInteger originalTransition = [[self.pager valueForKey:@"transitionId"] unsignedIntegerValue];
+    XCTAssertEqual([[self.pager valueForKey:@"pageControllers"] count], 3);
+    XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 320, 0.001);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 1);
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    [self.pager scrollViewDidEndDragging:horizontal willDecelerate:NO];
+    [self.pager scrollViewWillBeginDragging:horizontal];
+    XCTAssertGreaterThan([[self.pager valueForKey:@"transitionId"] unsignedIntegerValue], originalTransition + 1);
+    XCTAssertTrue([topHost.interactions containsObject:top]);
+    XCTAssertEqual(top.scrollView, source);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+
+    XCTestExpectation *oldSettlement = [self expectationWithDescription:@"old settlement skipped"];
+    dispatch_async(dispatch_get_main_queue(), ^{ [oldSettlement fulfill]; });
+    [self waitForExpectations:@[oldSettlement] timeout:2];
+    XCTAssertEqualWithAccuracy(horizontal.contentOffset.x, 320, 0.001);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 1);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    [self.pager scrollViewDidEndDragging:horizontal willDecelerate:YES];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 3);
+    [self.pager scrollViewDidEndDecelerating:horizontal];
+    XCTestExpectation *settled = [self expectationWithDescription:@"drag settled"];
+    dispatch_async(dispatch_get_main_queue(), ^{ [settled fulfill]; });
+    [self waitForExpectations:@[settled] timeout:2];
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+    XCTAssertFalse([topHost.interactions containsObject:top]);
+    XCTAssertNil(top.scrollView);
+    XCTAssertEqual([[self.pager valueForKey:@"currentIndex"] integerValue], 1);
+    XCTAssertEqual([self.pager valueForKey:@"topEdgeScrollView"], source);
+    XCTAssertEqual([self.pager valueForKey:@"originalTopEdgeStyle"], UIScrollEdgeEffectStyle.softStyle);
+    UIScrollEdgeElementContainerInteraction *normal = [self.pager valueForKey:@"topEdgeInteraction"];
+    XCTAssertNotNil(normal);
+    XCTAssertEqual(normal.scrollView, source);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.hardStyle);
+    NSArray<UIViewController *> *pages = [self.pager valueForKey:@"pageControllers"];
+    for (NSNumber *index in @[@0, @2]) {
+      UIScrollView *neighbor = (UIScrollView *)pages[index.integerValue].view.subviews.firstObject;
+      XCTAssertEqual(neighbor.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    }
+  } else {
+    XCTSkip(@"Direct local Hard drag handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testAnimatedDirectPageCommandBorrowsRealSourceEdgeUntilCompletion
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = [self preparePinnedLocalHardSource];
+    UIView *topHost = [self.pager valueForKey:@"topEdgeInteractionHost"];
+    UIView *pinnedHost = [self.pager valueForKey:@"pinnedStickyHostView"];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    UIScrollEdgeElementContainerInteraction *sticky = [self.pager valueForKey:@"stickyEdgeInteraction"];
+    UIView *topMarker = [self.pager valueForKey:@"topEdgeMarker"];
+    UIView *stickyMarker = [self.pager valueForKey:@"stickyEdgeMarker"];
+    XCTAssertNotNil(top);
+    XCTAssertNotNil(sticky);
+    XCTAssertEqual([self.pager valueForKey:@"originalTopEdgeStyle"], UIScrollEdgeEffectStyle.softStyle);
+
+    [self.pager adoptCurrentScrollEdgeForProgrammaticTransition:NO];
+    id owner = [[self.pager valueForKey:@"programmaticScrollEdgeOwners"] firstObject];
+    XCTAssertNotNil(owner);
+    XCTAssertEqual([owner valueForKey:@"topInteraction"], top);
+    XCTAssertEqual([owner valueForKey:@"stickyInteraction"], sticky);
+    XCTAssertEqual([owner valueForKey:@"topMarker"], topMarker);
+    XCTAssertEqual([owner valueForKey:@"stickyMarker"], stickyMarker);
+    XCTAssertEqual([owner valueForKey:@"originalStyle"], UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertTrue([[owner valueForKey:@"borrowsPinnedStickyHost"] boolValue]);
+    XCTAssertTrue([topHost.interactions containsObject:top]);
+    XCTAssertTrue([pinnedHost.interactions containsObject:sticky]);
+    XCTAssertEqual(top.scrollView, source);
+    XCTAssertEqual(sticky.scrollView, source);
+    XCTAssertEqual(topMarker.superview, topHost);
+    XCTAssertEqual(stickyMarker.superview, pinnedHost);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.hardStyle);
+
+    [self.pager restorePinnedStickyHeader];
+    XCTAssertEqual(pinnedHost.superview, source);
+    XCTAssertFalse(pinnedHost.hidden);
+    [self.pager setValue:nil forKey:@"observedScrollView"];
+    [self.pager finishProgrammaticScrollEdges];
+    XCTAssertFalse([topHost.interactions containsObject:top]);
+    XCTAssertFalse([pinnedHost.interactions containsObject:sticky]);
+    XCTAssertNil(top.scrollView);
+    XCTAssertNil(sticky.scrollView);
+    XCTAssertNil(topMarker.superview);
+    XCTAssertNil(stickyMarker.superview);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertEqual(pinnedHost.superview, [self.pager valueForKey:@"containerView"]);
+    XCTAssertTrue(pinnedHost.hidden);
+    XCTAssertEqual([[self.pager valueForKey:@"programmaticScrollEdgeOwners"] count], 0);
+  } else {
+    XCTSkip(@"Animated local Hard edge handoff requires iOS 27 or newer");
+  }
+}
+
+- (void)testCancelledDirectPageCommandReleasesBorrowedSourceEdge
+{
+  if (@available(iOS 27.0, *)) {
+    UIScrollView *source = [self preparePinnedLocalHardSource];
+    UIView *topHost = [self.pager valueForKey:@"topEdgeInteractionHost"];
+    UIView *pinnedHost = [self.pager valueForKey:@"pinnedStickyHostView"];
+    UIScrollEdgeElementContainerInteraction *top = [self.pager valueForKey:@"topEdgeInteraction"];
+    UIScrollEdgeElementContainerInteraction *sticky = [self.pager valueForKey:@"stickyEdgeInteraction"];
+    UIView *topMarker = [self.pager valueForKey:@"topEdgeMarker"];
+    UIView *stickyMarker = [self.pager valueForKey:@"stickyEdgeMarker"];
+    [self.pager adoptCurrentScrollEdgeForProgrammaticTransition:NO];
+    [self.pager restorePinnedStickyHeader];
+    [self.pager clearProgrammaticScrollEdges];
+    XCTAssertFalse([topHost.interactions containsObject:top]);
+    XCTAssertFalse([pinnedHost.interactions containsObject:sticky]);
+    XCTAssertNil(topMarker.superview);
+    XCTAssertNil(stickyMarker.superview);
+    XCTAssertEqual(source.topEdgeEffect.style, UIScrollEdgeEffectStyle.softStyle);
+    XCTAssertEqual(pinnedHost.superview, [self.pager valueForKey:@"containerView"]);
+    XCTAssertTrue(pinnedHost.hidden);
+  } else {
+    XCTSkip(@"Animated local Hard edge handoff requires iOS 27 or newer");
+  }
+}
+
 - (void)testIOS27LocalHardThemeBackgroundTracksMaskedHeaderGeometry
 {
   if (@available(iOS 27.0, *)) {