@onekeyfe/react-native-pager-view 3.0.165 → 3.0.167

package/android/src/main/java/com/reactnativepagerview/CollapsiblePagerHost.kt

@@ -1301,9 +1301,15 @@ class CollapsiblePagerHost(context: Context) : NestedScrollableHost(context), Ne
 
       MotionEvent.ACTION_MOVE -> {
         if (!headerTouchActive) return super.dispatchTouchEvent(event)
+        val dx = event.x - headerDownX
+        val dy = event.y - headerDownY
+        // A horizontal header guard must not consume a later vertical drag.
+        if (headerGestureOwner != HeaderGestureOwner.LIST &&
+          kotlin.math.abs(dy) > touchSlopPx && kotlin.math.abs(dy) > kotlin.math.abs(dx)) {
+          headerGestureOwner = HeaderGestureOwner.LIST
+          log("direction-recover owner=list region=$headerTouchRegion dx=${dx.roundToInt()} dy=${dy.roundToInt()}")
+        }
         if (headerGestureOwner == HeaderGestureOwner.NONE) {
-          val dx = event.x - headerDownX
-          val dy = event.y - headerDownY
           if (kotlin.math.abs(dx) <= touchSlopPx && kotlin.math.abs(dy) <= touchSlopPx) {
             return super.dispatchTouchEvent(event)
           }

package/android/src/main/java/com/reactnativepagerview/NativeScrollerView.kt

@@ -1,5 +1,7 @@
 package com.reactnativepagerview
 
+import com.margelo.nitro.nativelogger.OneKeyLog
+
 import android.content.Context
 import android.graphics.Color
 import android.os.SystemClock
@@ -380,6 +382,11 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
   private var stopping = false
   private var startingProgrammaticScroll = false
   private var downY = 0f
+  private var directionDownX = 0f
+  private var directionDownY = 0f
+  private var directionPointerId = MotionEvent.INVALID_POINTER_ID
+  private var smoothPagerTouch = false
+  private var touchAxis = 0
   private var velocityTracker: VelocityTracker? = null
   private var activePointerId = MotionEvent.INVALID_POINTER_ID
   private val maximumVelocity = ViewConfiguration.get(context).scaledMaximumFlingVelocity
@@ -391,16 +398,110 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
     overScrollMode = OVER_SCROLL_NEVER
   }
 
+  private fun updateTouchDirection(event: MotionEvent) {
+    if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+      directionPointerId = event.getPointerId(0)
+      directionDownX = event.x
+      directionDownY = event.y
+      downY = event.y
+      touchAxis = 0
+      smoothPagerTouch = false
+      var ancestor = host.parent as? View
+      while (ancestor != null) {
+        if (ancestor is CollapsiblePagerHost && ancestor.nativeSmoothHeaderScrollEnabled) {
+          smoothPagerTouch = true
+          break
+        }
+        ancestor = ancestor.parent as? View
+      }
+      OneKeyLog.debug("NativeScroller", "viewport-down slop=$touchSlop density=${resources.displayMetrics.density} scrollY=$scrollY smooth=$smoothPagerTouch")
+    } else if (event.actionMasked == MotionEvent.ACTION_POINTER_UP &&
+      event.getPointerId(event.actionIndex) == directionPointerId) {
+      val replacement = if (event.actionIndex == 0) 1 else 0
+      directionPointerId = if (replacement < event.pointerCount) event.getPointerId(replacement)
+        else MotionEvent.INVALID_POINTER_ID
+      if (replacement < event.pointerCount) {
+        directionDownX = event.getX(replacement)
+        directionDownY = event.getY(replacement)
+      }
+    } else if (smoothPagerTouch && touchAxis == 0 && event.actionMasked == MotionEvent.ACTION_MOVE) {
+      val pointerIndex = event.findPointerIndex(directionPointerId)
+      if (pointerIndex < 0) return
+      val dx = abs(event.getX(pointerIndex) - directionDownX)
+      val dy = abs(event.getY(pointerIndex) - directionDownY)
+      if (dy > touchSlop && dy > dx) touchAxis = 1
+      else if (dx >= 32f * resources.displayMetrics.density && dx > dy) touchAxis = 2
+      if (touchAxis != 0) {
+        OneKeyLog.debug("NativeScroller", "viewport-direction axis=$touchAxis dx=$dx dy=$dy scrollY=$scrollY")
+      }
+    }
+  }
+
+  private var childDisallowsIntercept = false
+  private var loggedBlockedVertical = false
+
+  override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+    if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+      childDisallowsIntercept = false
+      loggedBlockedVertical = false
+    }
+    if (scrollEnabled) updateTouchDirection(event)
+    if (smoothPagerTouch && touchAxis == 1 && childDisallowsIntercept &&
+      event.actionMasked == MotionEvent.ACTION_MOVE) {
+      childDisallowsIntercept = false
+      OneKeyLog.debug("NativeScroller", "viewport-recover-vertical scrollY=$scrollY")
+      super.requestDisallowInterceptTouchEvent(false)
+    }
+    if (smoothPagerTouch && event.actionMasked == MotionEvent.ACTION_MOVE && !loggedBlockedVertical) {
+      val pointerIndex = event.findPointerIndex(directionPointerId)
+      if (pointerIndex >= 0) {
+        val dx = abs(event.getX(pointerIndex) - directionDownX)
+        val dy = abs(event.getY(pointerIndex) - directionDownY)
+        if (dy > touchSlop && dy > dx) {
+          loggedBlockedVertical = true
+          OneKeyLog.debug("NativeScroller", "viewport-dispatch-vertical dx=$dx dy=$dy axis=$touchAxis disallow=$childDisallowsIntercept scrollY=$scrollY")
+        }
+      }
+    }
+    try { return super.dispatchTouchEvent(event) } finally {
+      if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL) {
+        releaseTouchDirection()
+      }
+    }
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    childDisallowsIntercept = disallowIntercept
+    if (smoothPagerTouch) OneKeyLog.debug("NativeScroller", "viewport-child-disallow value=$disallowIntercept axis=$touchAxis scrollY=$scrollY")
+    super.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
     if (!scrollEnabled) return false
-    if (event.actionMasked == MotionEvent.ACTION_DOWN) downY = event.y
+    updateTouchDirection(event)
+    if (smoothPagerTouch && event.actionMasked == MotionEvent.ACTION_MOVE && touchAxis != 1) return false
     val intercepted = super.onInterceptTouchEvent(event)
-    if (intercepted && event.actionMasked == MotionEvent.ACTION_MOVE) beginDrag(event)
+    if (intercepted && event.actionMasked == MotionEvent.ACTION_MOVE) {
+      OneKeyLog.debug("NativeScroller", "viewport-intercept dy=${event.y - downY} slop=$touchSlop scrollY=$scrollY")
+      beginDrag(event)
+    }
     return intercepted
   }
 
   override fun onTouchEvent(event: MotionEvent): Boolean {
     if (!scrollEnabled) return false
+    updateTouchDirection(event)
+    if (smoothPagerTouch && touchAxis != 1) {
+      if (event.actionMasked == MotionEvent.ACTION_MOVE) return true
+      if (event.actionMasked == MotionEvent.ACTION_UP) {
+        val cancel = MotionEvent.obtain(event)
+        cancel.action = MotionEvent.ACTION_CANCEL
+        try { return super.onTouchEvent(cancel) } finally {
+          cancel.recycle()
+          releaseTouchDirection()
+        }
+      }
+    }
     when (event.actionMasked) {
       MotionEvent.ACTION_DOWN -> downY = event.y
       MotionEvent.ACTION_MOVE -> {
@@ -409,7 +510,19 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
       }
       MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> endDrag(event)
     }
-    return super.onTouchEvent(event)
+    try { return super.onTouchEvent(event) } finally {
+      if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL) {
+        releaseTouchDirection()
+      }
+    }
+  }
+
+  private fun releaseTouchDirection() {
+    childDisallowsIntercept = false
+    loggedBlockedVertical = false
+    directionPointerId = MotionEvent.INVALID_POINTER_ID
+    smoothPagerTouch = false
+    touchAxis = 0
   }
 
   // Record at the refresh boundary so interception does not truncate the pointer history.
@@ -435,6 +548,7 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
   }
 
   internal fun releaseTouchTracking() {
+    releaseTouchDirection()
     velocityTracker?.recycle()
     velocityTracker = null
     activePointerId = MotionEvent.INVALID_POINTER_ID
@@ -443,6 +557,7 @@ internal class NativeScrollerViewport(context: Context, internal val host: Nativ
   internal fun beginDrag(event: MotionEvent) {
     if (dragging) return
     dragging = true
+    OneKeyLog.debug("NativeScroller", "viewport-begin-drag dy=${event.y - downY} slop=$touchSlop scrollY=$scrollY")
     // Header-forwarded touches bypass the refresh boundary's touch stream.
     host.cancelPendingScrollRestore()
     if (host.keyboardDismissMode != "none") host.dismissKeyboard()
@@ -543,6 +658,8 @@ private class NativeScrollerRefreshLayout(context: Context) : SwipeRefreshLayout
   private var downX = 0f
   private var downY = 0f
   private var horizontal = false
+  private var vertical = false
+  private var smoothPagerGesture = false
   private var intercepted = false
   private val slop = ViewConfiguration.get(context).scaledTouchSlop
 
@@ -567,10 +684,26 @@ private class NativeScrollerRefreshLayout(context: Context) : SwipeRefreshLayout
       downX = event.x
       downY = event.y
       horizontal = false
+      vertical = false
+      smoothPagerGesture = false
+      var ancestor = parent as? View
+      while (ancestor != null) {
+        if (ancestor is CollapsiblePagerHost && ancestor.nativeSmoothHeaderScrollEnabled) {
+          smoothPagerGesture = true
+          break
+        }
+        ancestor = ancestor.parent as? View
+      }
       intercepted = false
-    } else if (event.actionMasked == MotionEvent.ACTION_MOVE && abs(event.x - downX) > slop &&
-      abs(event.x - downX) > abs(event.y - downY)) {
-      horizontal = true
+    } else if (event.actionMasked == MotionEvent.ACTION_MOVE && (!smoothPagerGesture || !vertical)) {
+      val dx = abs(event.x - downX)
+      val dy = abs(event.y - downY)
+      if (smoothPagerGesture && dy > slop && dy > dx) {
+        vertical = true
+        horizontal = false
+      } else if (dx > (if (smoothPagerGesture) 32f * resources.displayMetrics.density else slop.toFloat()) && dx > dy) {
+        horizontal = true
+      }
     }
     if (horizontal) return false
     val result = super.onInterceptTouchEvent(event)

package/android/src/main/java/com/reactnativepagerview/NestedScrollableHost.kt

@@ -5,11 +5,15 @@ import android.util.AttributeSet
 import android.view.Choreographer
 import android.view.MotionEvent
 import android.view.View
+import android.view.ViewGroup
 import android.view.ViewConfiguration
+import android.widget.HorizontalScrollView
 import android.widget.FrameLayout
+import androidx.recyclerview.widget.RecyclerView
 import androidx.viewpager2.widget.ViewPager2
 import androidx.viewpager2.widget.ViewPager2.ORIENTATION_HORIZONTAL
 import com.facebook.react.uimanager.events.NativeGestureUtil
+import com.margelo.nitro.nativelogger.OneKeyLog
 import kotlin.math.absoluteValue
 import kotlin.math.sign
 
@@ -32,6 +36,11 @@ open class NestedScrollableHost : FrameLayout {
   private var touchSlop = 0
   private var initialX = 0f
   private var initialY = 0f
+  private var smoothTouchActive = false
+  private var smoothTouchAxis = 0
+  private var smoothDownX = 0f
+  private var smoothDownY = 0f
+  private var nestedHorizontalOwner: View? = null
   protected var nestedNativeGestureStarted: Boolean = false
   private val parentViewPager: ViewPager2?
     get() {
@@ -57,8 +66,74 @@ open class NestedScrollableHost : FrameLayout {
     }
   }
 
+  private fun hasSmoothHeaderOwner(): Boolean {
+    var ancestor: View? = this
+    while (ancestor != null) {
+      if (ancestor is CollapsiblePagerHost && ancestor.nativeSmoothHeaderScrollEnabled) return true
+      ancestor = ancestor.parent as? View
+    }
+    return false
+  }
+
+  private fun horizontalOwnerAt(view: View, x: Float, y: Float): View? {
+    if (view is ViewGroup) {
+      for (index in view.childCount - 1 downTo 0) {
+        val nested = view.getChildAt(index)
+        if (nested.visibility != View.VISIBLE || nested.alpha <= 0f) continue
+        val localX = x + view.scrollX - nested.left - nested.translationX
+        val localY = y + view.scrollY - nested.top - nested.translationY
+        if (localX < 0 || localY < 0 || localX >= nested.width || localY >= nested.height) continue
+        horizontalOwnerAt(nested, localX, localY)?.let { return it }
+        break
+      }
+    }
+    // Exclude this host's own pager; only an inner horizontal viewport has priority.
+    if (view.parent !== child && (view is HorizontalScrollView || view is RecyclerView) &&
+      (view.canScrollHorizontally(-1) || view.canScrollHorizontally(1))) return view
+    return null
+  }
+
+  private fun coordinateSmoothTouch(e: MotionEvent) {
+    val pager = child as? ViewPager2 ?: return
+    if (e.actionMasked == MotionEvent.ACTION_DOWN) {
+      smoothTouchActive = hasSmoothHeaderOwner()
+      smoothTouchAxis = 0
+      smoothDownX = e.x
+      smoothDownY = e.y
+      nestedHorizontalOwner = if (smoothTouchActive) horizontalOwnerAt(this, e.x, e.y) else null
+    }
+    if (!smoothTouchActive) return
+    val dx = e.x - smoothDownX
+    val dy = e.y - smoothDownY
+    if (e.actionMasked == MotionEvent.ACTION_MOVE && smoothTouchAxis == 0) {
+      smoothTouchAxis = when {
+        dy.absoluteValue > touchSlop && dy.absoluteValue > dx.absoluteValue -> 1
+        dx.absoluteValue >= 32f * resources.displayMetrics.density && dx.absoluteValue > dy.absoluteValue -> 2
+        else -> 0
+      }
+      if (smoothTouchAxis != 0) {
+        OneKeyLog.debug("CollapsiblePager", "content-direction owner=${if (smoothTouchAxis == 1) "list" else "horizontal"} dx=$dx dy=$dy nested=${nestedHorizontalOwner != null}")
+      }
+    }
+    val innerCanScroll = nestedHorizontalOwner?.canScrollHorizontally(-dx.sign.toInt()) == true
+    // Preserve DOWN in the real pager, but defer horizontal interception while
+    // intent is pending. Ancestor vertical lists must still be able to intercept.
+    (pager.getChildAt(0) as? RecyclerView)?.requestDisallowInterceptTouchEvent(smoothTouchAxis != 2 || innerCanScroll)
+    parent?.requestDisallowInterceptTouchEvent(false)
+  }
+
   override fun dispatchTouchEvent(e: MotionEvent): Boolean {
+    coordinateSmoothTouch(e)
     val handled = super.dispatchTouchEvent(e)
+    if (smoothTouchActive && (e.actionMasked == MotionEvent.ACTION_UP || e.actionMasked == MotionEvent.ACTION_CANCEL)) {
+      if (nestedNativeGestureStarted) {
+        NativeGestureUtil.notifyNativeGestureEnded(this, e)
+        nestedNativeGestureStarted = false
+      }
+      smoothTouchActive = false
+      smoothTouchAxis = 0
+      nestedHorizontalOwner = null
+    }
 
     // After the full child dispatch cycle, a deeply-nested NestedScrollableHost may
     // have called requestDisallowInterceptTouchEvent(false) which propagates all the

package/docs/SPEC.md

@@ -187,6 +187,72 @@ unchanged. Acceptance requires a real iOS button-origin drag that does not fire
 the button, a button-origin fling that scrolls, an ordinary tap that fires, and
 focused native touch-delivery coverage.
 
+## Smooth-header touch direction and press retention
+
+
+Status: implemented in module source. Equivalent native gesture behavior was
+independently verified in the Home consumer's recorded round3 simulator cases.
+The module transplant preserves those decisions and excludes application-specific
+acceptance probes. Package compilation and packaging are checked separately;
+consumer evidence does not establish acceptance of a subsequently installed
+release. Physical-device feel and semantic accessibility activation remain
+unverified. No public API is added.
+
+Existing smooth-header callers MUST receive this behavior automatically, with no
+additional caller options.
+
+On iOS and Android, smooth-header mode MUST distinguish pending intent from a
+confirmed vertical or horizontal drag. A small horizontal start followed by
+vertical movement MUST be allowed to become a vertical scroll while intent is
+pending. A confirmed vertical drag MUST retain vertical ownership until end or
+cancellation, even if later movement becomes horizontal. This applies to page
+content, the shared header, and touches beginning on an inner horizontal banner.
+Normal taps MUST remain functional. Press-retention behavior in application
+controls belongs to the consuming responder implementation; the Pager package
+does not contain or publish Tamagui helpers. The native application tab bar has
+a separate contract in react-native-tab-view/docs/SPEC.md.
+
+The current native implementation confirms horizontal intent after at least
+32 points on iOS or 32 dp on Android, with horizontal displacement exceeding
+vertical displacement. Vertical intent uses the native vertical scroll threshold
+(Android touch slop; iOS guard 10 points) and vertical-dominant displacement.
+There is no timed wait and no percentage-of-page-width threshold. After horizontal
+intent is confirmed, page content may retain horizontal ownership: the contract
+does not require transferring an already established page swipe to a vertical
+scroller. Header forwarding can recover to the vertical list when vertical
+movement becomes dominant. An inner horizontal viewport that can consume a
+confirmed horizontal drag MUST have priority over the Home page pager.
+
+This intent confirmation MUST NOT add a second lazy-mount progress threshold.
+Once native horizontal dragging begins, the first nonzero page progress MUST
+prepare the target page on both platforms, as specified below.
+
+Acceptance MUST cover an initial small horizontal movement followed by vertical
+scrolling from ordinary content, header buttons, Prime/support controls and inner
+banners; vertical-first gestures that later turn horizontal; stationary taps;
+normal page swipes; inner banner swipes; and iOS fixed-control drag cancellation.
+Native logger traces and before/after frames MUST distinguish scrolling, unintended
+page changes and unintended control activation. Simulator acceptance establishes only the recorded touch sequences; it does not
+establish physical-device feel or untested multi-touch combinations.
+
+On Smooth Home, Android NativeScrollerViewport MUST use the same pending /
+vertical / horizontal direction decision on interception and on its own touch
+path. It MUST deliver the original DOWN to NestedScrollView, defer pending and
+horizontal MOVE scrolling, and retain confirmed vertical ownership until the
+sequence ends. Header-forwarded DOWN MUST initialize this decision independently
+of the refresh boundary. Dispatch MUST still observe child-owned movement; only
+a confirmed vertical Smooth Home gesture may release the viewport's child
+interception prohibition. Pending and horizontal movement MUST preserve it.
+
+iOS nested horizontal ownership MUST include enabled nonpaging horizontal-only
+ScrollViews, with content wider than bounds and no vertical content overflow.
+Both pan holding and failure dependencies MUST use the same eligibility. A
+failure dependency on the Pager guard MUST apply only to the horizontal pan;
+independent non-pan recognizers, including stationary native long presses, MUST
+remain able to recognize before finger-up while Pager intent is pending. A
+second touch in the pending Pager guard fails recognition; an already active
+Pager guard cancels and restores each held pan's original minimum touch count.
+
 ## Native tab-press animation default
 
 Behavior change: previously an omitted `nativeTabPressAnimationEnabled` animated
@@ -523,3 +589,55 @@ introduced. This change makes no frame-rate claim.
 The newly merged NativeScroller viewport tracking uses the same weak-key
 snapshot rule. Its cleanup has source and focused regression coverage; the
 pre-migration runtime checks above do not establish its device acceptance.
+
+## iOS lazy-page first-frame preparation
+
+Status: implemented and runtime verified in the consuming app's local native
+build on iOS 26.5 (2026-10-10). This package change preserves the same functional
+source; app-specific diagnostic logs remain in that local build.
+
+In smooth-header mode, a newly mounted, owned NativeScroller or live NativeList
+on the current page, either adjacent page, or a programmatic destination MUST
+receive its pager insets and restored offset in Fabric's did-mount callback,
+before the next frame. This also applies during a horizontal drag or animation.
+Preparation MUST NOT change the selected page, move the shared header out of its
+transition owner, attach an offscreen page's observer, or repeatedly restore an
+already managed scroll view.
+
+A scroll view removed in a Fabric transaction MUST be excluded from discovery
+until that transaction finishes. The exclusion uses weak native identities,
+is cleared after did-mount and on recycle, and allows a moved view to be found
+again in its next owner. A NativeList collection is usable only while its nearest
+Fabric component owns it through contentView, has a registered tag, and retains
+that content view as collection delegate. A disposed or unregistered NativeList
+MUST NOT become a generic collection fallback.
+
+Verified NativeList collections bypass the existing 0.5-second generic collection
+fallback debounce, including replacement-state restoration. Other collection
+fallbacks keep that safety delay. Caller insets and retained logical offsets
+remain governed by the existing restoration policy.
+
+This is a UI-thread, main-runtime native coordination change with no new props,
+events, background-runtime work, persistence or retained strong view cache.
+Android already prepares discovered scroll children before draw and is unchanged;
+Web is unchanged. Consumers own the decision to lazily mount or prepare a target
+page; this package does not import scene code or start business requests.
+
+The Home consumer uses the same lazy-mount trigger on iOS and Android: after
+entering the horizontal dragging state, the first received page-scroll progress
+with nonzero displacement relative to the starting page MUST trigger early
+mounting of the adjacent target page in that direction. There is no fixed
+distance or percentage threshold. Measured trigger percentages, such as 0.65%,
+are event samples rather than configured thresholds. Early mounting MUST NOT
+change the selected page; selection follows the existing native selection event.
+
+Conformance: RNCCollapsiblePagerViewComponentView.mm and the focused ownership /
+first-frame XCTest cases. Consumer acceptance confirmed a cold Spot-to-Perps
+swipe: the native skeleton received inset 340 and offset -340 at t=1791603349124
+while transition=1, 427 ms before native drag settlement. Its window y=514 was
+below the header bottom y=502. These values are measured evidence, not package
+constants. Native view geometry is confirmed. Later finite consumer round3 simulator
+cases additionally verified recorded refresh, header, restoration and gesture
+paths; they do not establish every possible sequence or runtime acceptance of a
+newly installed module release. Physical-device feel and semantic accessibility
+activation remain unverified.

package/ios/RNCCollapsiblePagerViewComponentView.mm

@@ -158,6 +158,28 @@ static UIView *RNCScrollComponentView(UIScrollView *scrollView)
   return nil;
 }
 
+// NativeList owns its collection through a Fabric contentView and its delegate.
+// A dropped Nitro view can remain in the hierarchy after its delegate is cleared.
+static RCTViewComponentView *RNCNativeListComponentForScrollView(UIScrollView *scrollView)
+{
+  Class nativeListClass = NSClassFromString(@"HybridNativeListComponent");
+  for (UIView *component = scrollView; component != nil; component = component.superview) {
+    if (![component isKindOfClass:RCTViewComponentView.class]) continue;
+    return nativeListClass != Nil && [component isKindOfClass:nativeListClass]
+      ? (RCTViewComponentView *)component : nil;
+  }
+  return nil;
+}
+
+static BOOL RNCIsMountedNativeListScrollView(UIScrollView *scrollView)
+{
+  if (![scrollView isKindOfClass:UICollectionView.class]) return NO;
+  RCTViewComponentView *component = RNCNativeListComponentForScrollView(scrollView);
+  UIView *content = component.contentView;
+  return component.tag > 0 && content != nil && [scrollView isDescendantOfView:content] &&
+    ((UICollectionView *)scrollView).delegate == (id)content;
+}
+
 typedef void (^RNCCollapsiblePagerNativeTabPressHandler)(NSInteger index, NSString *key);
 
 static CGFloat RNCClamp(CGFloat value, CGFloat minimum, CGFloat maximum)
@@ -165,6 +187,24 @@ static CGFloat RNCClamp(CGFloat value, CGFloat minimum, CGFloat maximum)
   return MIN(MAX(value, minimum), maximum);
 }
 
+static BOOL RNCIsEnabledHorizontalScrollOwner(UIScrollView *scroll)
+{
+  return scroll.scrollEnabled && scroll.panGestureRecognizer.enabled &&
+    scroll.contentSize.width > CGRectGetWidth(scroll.bounds) && !scroll.alwaysBounceVertical &&
+    scroll.contentSize.height <= CGRectGetHeight(scroll.bounds) + 0.5;
+}
+
+static void RNCGuardNestedHorizontalPans(UIView *view, UIGestureRecognizer *guard)
+{
+  if ([view isKindOfClass:UIScrollView.class]) {
+    UIScrollView *scroll = (UIScrollView *)view;
+    if (RNCIsEnabledHorizontalScrollOwner(scroll)) {
+      [scroll.panGestureRecognizer requireGestureRecognizerToFail:guard];
+    }
+  }
+  for (UIView *child in view.subviews) RNCGuardNestedHorizontalPans(child, guard);
+}
+
 static void RNCCollapsiblePagerLog(NSString *message)
 {
   Class logClass = NSClassFromString(@"ReactNativeNativeLogger.OneKeyLog");
@@ -995,6 +1035,15 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
         intent.y]);
       return NO;
     }
+    UIView *target = [self hitTest:[pan locationInView:self] withEvent:nil];
+    for (UIView *ancestor = target; ancestor != nil && ancestor != self; ancestor = ancestor.superview) {
+      if (![ancestor isKindOfClass:UIScrollView.class]) continue;
+      UIScrollView *inner = (UIScrollView *)ancestor;
+      CGFloat maximum = MAX(0, inner.contentSize.width - CGRectGetWidth(inner.bounds));
+      BOOL canScroll = maximum > 0 && (intent.x < 0
+        ? inner.contentOffset.x < maximum - 0.5 : inner.contentOffset.x > 0.5);
+      if (canScroll) return NO;
+    }
   }
   if (gestureRecognizer == self.panGestureRecognizer && self.excludedHeaderView != nil) {
     CGPoint point = [gestureRecognizer locationInView:self.excludedHeaderView];
@@ -1187,16 +1236,134 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 @end
 
-@interface RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer : UIPanGestureRecognizer
+@interface RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer : UIGestureRecognizer
+@property (nonatomic, weak) UIPanGestureRecognizer *pagerPan;
+- (CGPoint)translationInView:(UIView *)view;
+- (CGPoint)velocityInView:(UIView *)view;
 @end
 
-@implementation RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer
+@implementation RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer {
+  __weak UITouch *_trackedTouch;
+  NSMapTable<UIPanGestureRecognizer *, NSNumber *> *_heldPans;
+  CGPoint _startPoint;
+  CGPoint _lastPoint;
+  CGPoint _velocity;
+  NSTimeInterval _lastTimestamp;
+}
 
-- (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)preventedGestureRecognizer
+- (void)holdPan:(UIPanGestureRecognizer *)pan
 {
-  return NO;
+  if (pan == nil || [_heldPans objectForKey:pan] != nil) return;
+  if (_heldPans == nil) _heldPans = [NSMapTable weakToStrongObjectsMapTable];
+  [_heldPans setObject:@(pan.minimumNumberOfTouches) forKey:pan];
+  // A failure dependency alone lets UIKit's pager pan cancel a descendant pan
+  // before intent resolves. Keep DOWN tracked while deferring one-finger begin.
+  pan.minimumNumberOfTouches = MAX(2, pan.minimumNumberOfTouches);
+}
+
+- (void)restoreHeldPans
+{
+  for (UIPanGestureRecognizer *pan in _heldPans.keyEnumerator) {
+    pan.minimumNumberOfTouches = [_heldPans objectForKey:pan].unsignedIntegerValue;
+    UIScrollView *scroll = [pan.view isKindOfClass:UIScrollView.class] ? (UIScrollView *)pan.view : nil;
+    RNCCollapsiblePagerLog([NSString stringWithFormat:
+      @"gesture-restore pan=%@ min-touches=%lu offset=%@",
+      NSStringFromClass(pan.view.class), (unsigned long)pan.minimumNumberOfTouches,
+      scroll != nil ? NSStringFromCGPoint(scroll.contentOffset) : @"none"]);
+  }
+  [_heldPans removeAllObjects];
+}
+
+- (CGPoint)translationInView:(UIView *)view
+{
+  CGPoint start = [view convertPoint:_startPoint fromView:self.view];
+  CGPoint last = [view convertPoint:_lastPoint fromView:self.view];
+  return CGPointMake(last.x - start.x, last.y - start.y);
+}
+
+- (CGPoint)velocityInView:(UIView *)view { return _velocity; }
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (_trackedTouch != nil || touches.count != 1) {
+    RNCCollapsiblePagerLog([NSString stringWithFormat:
+      @"gesture-second-touch previous-state=%ld incoming=%lu held-pans=%lu",
+      (long)self.state, (unsigned long)touches.count, (unsigned long)_heldPans.count]);
+    [self restoreHeldPans];
+    if (self.state == UIGestureRecognizerStatePossible) {
+      self.state = UIGestureRecognizerStateFailed;
+    } else if (self.state == UIGestureRecognizerStateBegan || self.state == UIGestureRecognizerStateChanged) {
+      self.state = UIGestureRecognizerStateCancelled;
+    }
+    return;
+  }
+  _trackedTouch = touches.anyObject;
+  _startPoint = _lastPoint = [touches.anyObject locationInView:self.view];
+  _lastTimestamp = event.timestamp;
+  _velocity = CGPointZero;
+  [self holdPan:self.pagerPan];
+  for (UIView *view = _trackedTouch.view; view != nil && view != self.view; view = view.superview) {
+    if (![view isKindOfClass:UIScrollView.class]) continue;
+    UIScrollView *scroll = (UIScrollView *)view;
+    if (RNCIsEnabledHorizontalScrollOwner(scroll)) {
+      RNCCollapsiblePagerLog([NSString stringWithFormat:
+        @"gesture-hold inner=%@ paging=%d offset=%@ content=%@ bounds=%@",
+        NSStringFromClass(scroll.class), scroll.pagingEnabled, NSStringFromCGPoint(scroll.contentOffset),
+        NSStringFromCGSize(scroll.contentSize), NSStringFromCGSize(scroll.bounds.size)]);
+      [self holdPan:scroll.panGestureRecognizer];
+    }
+  }
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  CGPoint point = [touches.anyObject locationInView:self.view];
+  NSTimeInterval elapsed = event.timestamp - _lastTimestamp;
+  if (elapsed > 0) {
+    _velocity = CGPointMake((point.x - _lastPoint.x) / elapsed,
+                           (point.y - _lastPoint.y) / elapsed);
+  }
+  _lastPoint = point;
+  _lastTimestamp = event.timestamp;
+  if (self.state == UIGestureRecognizerStatePossible) {
+    CGFloat dx = fabs(point.x - _startPoint.x), dy = fabs(point.y - _startPoint.y);
+    // Keep intent pending until the explicit distance decision, instead of
+    // relying on UIPanGestureRecognizer's earlier recognition.
+    if ((dy >= 10 && dy > dx) || (dx >= 32 && dx > dy)) {
+      RNCCollapsiblePagerLog([NSString stringWithFormat:
+        @"gesture-intent axis=%@ dx=%.2f dy=%.2f held-pans=%lu",
+        dy > dx ? @"vertical" : @"horizontal", dx, dy, (unsigned long)_heldPans.count]);
+      self.state = UIGestureRecognizerStateBegan;
+      if (self.state == UIGestureRecognizerStateFailed) [self restoreHeldPans];
+    }
+  } else if (self.state == UIGestureRecognizerStateBegan || self.state == UIGestureRecognizerStateChanged) {
+    self.state = UIGestureRecognizerStateChanged;
+  }
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [self restoreHeldPans];
+  self.state = self.state == UIGestureRecognizerStatePossible
+    ? UIGestureRecognizerStateFailed : UIGestureRecognizerStateEnded;
 }
 
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [self restoreHeldPans];
+  self.state = UIGestureRecognizerStateCancelled;
+}
+
+- (void)reset
+{
+  [self restoreHeldPans];
+  [super reset];
+  _trackedTouch = nil;
+  _velocity = CGPointZero;
+}
+
+- (BOOL)canBePreventedByGestureRecognizer:(UIGestureRecognizer *)other { return NO; }
+- (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)other { return YES; }
 @end
 
 @interface RNCCollapsiblePagerViewComponentView () <
@@ -1282,10 +1449,12 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   NSMapTable<UIScrollView *, NSNumber *> *_appliedTopInsets;
   NSMapTable<UIScrollView *, NSValue *> *_originalIndicatorInsets;
   NSMapTable<UIScrollView *, NSNumber *> *_originalAlwaysBounceVertical;
+  NSMapTable<UIScrollView *, NSNumber *> *_originalDirectionalLockEnabled;
   NSMapTable<UIScrollView *, NSNumber *> *_originalInsetAdjustmentBehavior;
   // OneKey patch: pair pre-mount release with recovery, including deferred mounts.
   NSMutableDictionary<NSString *, RNCCollapsiblePagerReleasedScrollState *> *_releasedPageScrollStates;
   BOOL _needsScrollObserverReattachAfterMount;
+  NSHashTable<UIScrollView *> *_mountingRemovedScrollViews;
   __weak UIScrollView *_observedScrollView;
   __weak UIScrollView *_sharedHeaderScrollView;
   __weak UIScrollView *_pendingFallbackScrollView;
@@ -1294,7 +1463,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   UIPanGestureRecognizer *_sharedHeaderPressCancellationGesture;
   RNCCollapsiblePagerContentPressCancellationGestureRecognizer *_contentPressCancellationGesture;
   RNCCollapsiblePagerOuterPagerPanGestureRecognizer *_sharedHeaderOuterPagerGesture;
-  UIPanGestureRecognizer *_verticalPagerGesture;
+  RNCCollapsiblePagerVerticalPagerGuardGestureRecognizer *_verticalPagerGesture;
   BOOL _observingContentOffset;
   BOOL _scrollResolveRetryScheduled;
   CFTimeInterval _pendingFallbackScrollViewDetectedAt;
@@ -1322,12 +1491,14 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _pageControllers = [NSMutableArray new];
     _pageOffsets = [NSMutableDictionary new];
     _releasedPageScrollStates = [NSMutableDictionary new];
+    _mountingRemovedScrollViews = [NSHashTable weakObjectsHashTable];
     _originalInsets = [NSMapTable weakToStrongObjectsMapTable];
     _managedRefreshControls = [NSMapTable weakToWeakObjectsMapTable];
     _refreshControlObservedScrollViews = [NSHashTable weakObjectsHashTable];
     _appliedTopInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalIndicatorInsets = [NSMapTable weakToStrongObjectsMapTable];
     _originalAlwaysBounceVertical = [NSMapTable weakToStrongObjectsMapTable];
+    _originalDirectionalLockEnabled = [NSMapTable weakToStrongObjectsMapTable];
     _originalInsetAdjustmentBehavior = [NSMapTable weakToStrongObjectsMapTable];
     _pageKeys = @[];
     _retainedPages = @"[]";
@@ -1365,7 +1536,6 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _verticalPagerGesture.cancelsTouchesInView = NO;
     _verticalPagerGesture.enabled = NO;
     [self addGestureRecognizer:_verticalPagerGesture];
-
     _nativeTabBarView = [RNCCollapsiblePagerNativeTabBarView new];
     _nativeTabBarView.hidden = YES;
     __weak __typeof__(self) weakSelf = self;
@@ -1758,6 +1928,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
         }
         break;
       }
+      // Quarantine only this mount transaction; moved views may be valid again.
+      [_mountingRemovedScrollViews addObject:scrollView];
       _needsScrollObserverReattachAfterMount = YES;
       [self restoreScrollViewState:scrollView resetSavedOffset:!belongsToPage];
       break;
@@ -1768,9 +1940,25 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 - (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
                withSurfaceTelemetry:(const SurfaceTelemetry &)surfaceTelemetry
 {
-  if (!_nativeSmoothHeaderScrollEnabled || _transitioning ||
-      _isPagerDragging || _isBeingRecycled || self.window == nil ||
+  [_mountingRemovedScrollViews removeAllObjects];
+  if (!_nativeSmoothHeaderScrollEnabled || _isBeingRecycled || self.window == nil ||
       _currentIndex < 0 || _currentIndex >= _pageControllers.count) return;
+  // Prepare newly mounted owned scrollers before their first frame, even while
+  // horizontal selection still owns the shared header and observer.
+  NSInteger first = MAX(0, _currentIndex - 1);
+  NSInteger last = MIN((NSInteger)_pageControllers.count - 1, _currentIndex + 1);
+  for (NSInteger index = 0; index < _pageControllers.count; index++) {
+    if ((index < first || index > last) && index != _destinationIndex) continue;
+    UIScrollView *scrollView = [self verticalScrollViewForPageAtIndex:index];
+    BOOL isOwnedScroller = [scrollView.superview isKindOfClass:RNCNativeScrollerComponentView.class] &&
+      ((RNCNativeScrollerComponentView *)scrollView.superview).scrollView == scrollView &&
+      [scrollView isDescendantOfView:_pageControllers[index].view];
+    if ((RNCIsMountedNativeListScrollView(scrollView) || isOwnedScroller) &&
+        [_originalInsets objectForKey:scrollView] == nil) {
+      [self applyInsetsToScrollView:scrollView pageIndex:index restore:YES];
+    }
+  }
+  if (_transitioning || _isPagerDragging) return;
 
   // OneKey patch: a release must recover even when the changed parent is above
   // the page subtree. Missing lists keep their identity for a later insertion.
@@ -2002,6 +2190,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 {
   _isBeingRecycled = YES;
   _generation++;
+  [_mountingRemovedScrollViews removeAllObjects];
   _needsScrollObserverReattachAfterMount = NO;
   [_releasedPageScrollStates removeAllObjects];
   [self detachSharedHeaderPressCancellationGesture];
@@ -2027,6 +2216,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     }
     NSNumber *alwaysBounce = [_originalAlwaysBounceVertical objectForKey:scrollView];
     if (alwaysBounce != nil) scrollView.alwaysBounceVertical = alwaysBounce.boolValue;
+    NSNumber *directionalLock = [_originalDirectionalLockEnabled objectForKey:scrollView];
+    if (directionalLock != nil) scrollView.directionalLockEnabled = directionalLock.boolValue;
     NSNumber *adjustment = [_originalInsetAdjustmentBehavior objectForKey:scrollView];
     if (adjustment != nil) {
       scrollView.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior)adjustment.integerValue;
@@ -2036,6 +2227,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [_appliedTopInsets removeAllObjects];
   [_originalIndicatorInsets removeAllObjects];
   [_originalAlwaysBounceVertical removeAllObjects];
+  [_originalDirectionalLockEnabled removeAllObjects];
   [_originalInsetAdjustmentBehavior removeAllObjects];
   // OneKey patch: Fabric reuses these views without resetting transforms
   // written by a native parent. Release our collapse translation with the slot.
@@ -2280,13 +2472,15 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       currentVerticalScrollViewForParentPager];
   }
   if ([view isKindOfClass:RNCNativeScrollerComponentView.class]) {
-    return ((RNCNativeScrollerComponentView *)view).scrollView;
+    UIScrollView *scrollView = ((RNCNativeScrollerComponentView *)view).scrollView;
+    return [_mountingRemovedScrollViews containsObject:scrollView] ? nil : scrollView;
   }
   if ([view isKindOfClass:RCTScrollViewComponentView.class]) {
     RCTScrollViewComponentView *componentView =
       (RCTScrollViewComponentView *)view;
     if ([componentView.nativeId hasPrefix:RNCCollapsiblePagerNativeScrollerIDPrefix]) {
-      return componentView.scrollView;
+      UIScrollView *scrollView = componentView.scrollView;
+      return [_mountingRemovedScrollViews containsObject:scrollView] ? nil : scrollView;
     }
   }
   for (UIView *subview in view.subviews) {
@@ -2307,7 +2501,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   if ([view isKindOfClass:RCTScrollViewComponentView.class]) {
     UIScrollView *scrollView =
       ((RCTScrollViewComponentView *)view).scrollView;
-    if (!scrollView.alwaysBounceHorizontal) {
+    if (!scrollView.alwaysBounceHorizontal &&
+        ![_mountingRemovedScrollViews containsObject:scrollView]) {
       return scrollView;
     }
   }
@@ -2320,7 +2515,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 
 - (UIScrollView *)findVerticalScrollViewInView:(UIView *)view
 {
-  if (view == _sharedHeaderHostView) return nil;
+  if (view == _sharedHeaderHostView ||
+      ([view isKindOfClass:UIScrollView.class] &&
+       [_mountingRemovedScrollViews containsObject:(UIScrollView *)view])) return nil;
   // A parent pager must follow the nested pager's active page instead of the
   // first retained page found by recursive subview order.
   if (view != self &&
@@ -2332,6 +2529,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   }
   if ([view isKindOfClass:UICollectionView.class]) {
     UICollectionView *collectionView = (UICollectionView *)view;
+    if (RNCNativeListComponentForScrollView(collectionView) != nil &&
+        !RNCIsMountedNativeListScrollView(collectionView)) return nil;
     UICollectionViewLayout *layout = collectionView.collectionViewLayout;
     BOOL hasUsableBounds = CGRectGetWidth(collectionView.bounds) > 0 &&
       CGRectGetHeight(collectionView.bounds) > 0;
@@ -2407,6 +2606,9 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     _pendingFallbackScrollViewDetectedAt = 0;
   }
   UIScrollView *candidate = [self verticalScrollViewForPageAtIndex:_currentIndex];
+  if (_nativeSmoothHeaderScrollEnabled && _currentIndex >= 0 && _currentIndex < _pageControllers.count) {
+    RNCGuardNestedHorizontalPans(_pageControllers[_currentIndex].view, _verticalPagerGesture);
+  }
   if (candidate == nil) {
     [self detachScrollObserver];
     [self restoreSharedHeadersToContainer];
@@ -2425,7 +2627,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     return;
   }
   if ([candidate isKindOfClass:UICollectionView.class] &&
-      candidate != _observedScrollView) {
+      candidate != _observedScrollView && !RNCIsMountedNativeListScrollView(candidate)) {
     if (_pendingFallbackScrollView != candidate) {
       _pendingFallbackScrollView = candidate;
       _pendingFallbackScrollViewDetectedAt = CACurrentMediaTime();
@@ -2531,8 +2733,10 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
 - (void)connectVerticalPagerGuard
 {
   if (_pagerScrollView != nil && _verticalPagerGesture != nil) {
-    [_pagerScrollView.panGestureRecognizer
-      requireGestureRecognizerToFail:_verticalPagerGesture];
+    _verticalPagerGesture.pagerPan = _pagerScrollView.panGestureRecognizer;
+    for (UIGestureRecognizer *gesture in _pagerScrollView.gestureRecognizers) {
+      [gesture requireGestureRecognizerToFail:_verticalPagerGesture];
+    }
   }
 }
 
@@ -2787,6 +2991,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     [_originalIndicatorInsets objectForKey:scrollView].UIEdgeInsetsValue;
   scrollView.alwaysBounceVertical =
     [_originalAlwaysBounceVertical objectForKey:scrollView].boolValue;
+  scrollView.directionalLockEnabled =
+    [_originalDirectionalLockEnabled objectForKey:scrollView].boolValue;
   scrollView.contentInsetAdjustmentBehavior = (UIScrollViewContentInsetAdjustmentBehavior)
     [_originalInsetAdjustmentBehavior objectForKey:scrollView].integerValue;
   [scrollView setContentOffset:CGPointMake(scrollView.contentOffset.x, logicalOffset - original.top)
@@ -2795,6 +3001,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
   [_appliedTopInsets removeObjectForKey:scrollView];
   [_originalIndicatorInsets removeObjectForKey:scrollView];
   [_originalAlwaysBounceVertical removeObjectForKey:scrollView];
+  [_originalDirectionalLockEnabled removeObjectForKey:scrollView];
   [_originalInsetAdjustmentBehavior removeObjectForKey:scrollView];
 }
 
@@ -2831,7 +3038,8 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
     // debounce each replacement candidate independently before rejecting the
     // released identity. A surviving native list is safe to accept immediately.
     BOOL needsFallbackDebounce = !sameList &&
-      [scrollView isKindOfClass:UICollectionView.class] && scrollView != _observedScrollView;
+      [scrollView isKindOfClass:UICollectionView.class] && scrollView != _observedScrollView &&
+      !RNCIsMountedNativeListScrollView(scrollView);
     if (needsFallbackDebounce) {
       CFTimeInterval now = CACurrentMediaTime();
       if (released.pendingFallbackScrollView != scrollView) {
@@ -2879,12 +3087,17 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       setObject:[NSValue valueWithUIEdgeInsets:scrollView.verticalScrollIndicatorInsets]
       forKey:scrollView];
     [_originalAlwaysBounceVertical setObject:@(scrollView.alwaysBounceVertical) forKey:scrollView];
+    [_originalDirectionalLockEnabled setObject:@(scrollView.directionalLockEnabled) forKey:scrollView];
     [_originalInsetAdjustmentBehavior setObject:@(scrollView.contentInsetAdjustmentBehavior) forKey:scrollView];
   }
 
   // This host already includes the fixed header and safe area in its frame.
   // UIKit automatic adjustment would add them a second time to short pages.
   scrollView.contentInsetAdjustmentBehavior = UIScrollViewContentInsetAdjustmentNever;
+  // This viewport is vertical-only; UIKit's first horizontal lock must not
+  // suppress its later vertical movement while the pager is still pending.
+  scrollView.directionalLockEnabled = _nativeSmoothHeaderScrollEnabled
+    ? NO : [_originalDirectionalLockEnabled objectForKey:scrollView].boolValue;
   [self updateNativeScrollerViewport:scrollView stickyHeight:_stickyHeaderHeight];
   [self updateRefreshControlForScrollView:scrollView];
   CGFloat previousTopInset = scrollView.contentInset.top;
@@ -3543,6 +3756,7 @@ static void RNCLogNativeTabScrollBoundary(NSString *owner,
       : velocity;
     BOOL hasMotion = MAX(fabs(intent.x), fabs(intent.y)) >= 1;
     BOOL vertical = hasMotion && fabs(intent.y) > fabs(intent.x);
+    if (gestureRecognizer == _sharedHeaderPressCancellationGesture) vertical = hasMotion;
     NSString *role = gestureRecognizer == _sharedHeaderPressCancellationGesture
       ? @"vertical-cancel"
       : @"vertical-pager-guard";

package/ios/tests/RNCCollapsiblePagerFirstFrameTests.mm

@@ -0,0 +1,150 @@
+#import <XCTest/XCTest.h>
+#import "RNCCollapsiblePagerViewComponentView.h"
+#import "RNCNativeScrollerComponentView.h"
+#import <react/renderer/mounting/MountingTransaction.h>
+
+using namespace facebook::react;
+
+@interface RNCCollapsiblePagerViewComponentView (FirstFrameTesting)
+- (void)mountingTransactionDidMount:(const MountingTransaction &)transaction
+               withSurfaceTelemetry:(const SurfaceTelemetry &)telemetry;
+- (UIScrollView *)findExplicitNativeScrollerInView:(UIView *)view;
+- (UIScrollView *)findVerticalScrollViewInView:(UIView *)view;
+- (void)attachScrollObserverForCurrentPage;
+@end
+
+@interface RNCCollapsiblePagerFirstFrameTests : XCTestCase
+@end
+
+@implementation RNCCollapsiblePagerFirstFrameTests
+
+- (RNCCollapsiblePagerViewComponentView *)pagerWithPageCount:(NSInteger)count
+{
+  RNCCollapsiblePagerViewComponentView *pager =
+    [[RNCCollapsiblePagerViewComponentView alloc] initWithFrame:CGRectMake(0, 0, 320, 844)];
+  [pager setValue:@YES forKey:@"nativeSmoothHeaderScrollEnabled"];
+  [pager setValue:@120 forKey:@"headerHeight"];
+  [pager setValue:@44 forKey:@"stickyHeaderHeight"];
+  UIWindow *window = [[UIWindow alloc] initWithFrame:pager.frame];
+  UIViewController *root = [UIViewController new];
+  window.rootViewController = root;
+  [root.view addSubview:pager];
+  window.hidden = NO;
+  [self addTeardownBlock:^{
+    [pager prepareForRecycle];
+    window.hidden = YES;
+  }];
+  NSMutableArray *pages = [pager valueForKey:@"pageControllers"];
+  NSMutableArray<NSString *> *keys = [NSMutableArray new];
+  for (NSInteger index = 0; index < count; index++) {
+    UIViewController *page = [UIViewController new];
+    page.view = [[UIView alloc] initWithFrame:CGRectMake(index * 320, 0, 320, 600)];
+    [pager addSubview:page.view];
+    [pages addObject:page];
+    [keys addObject:[NSString stringWithFormat:@"page-%ld", (long)index]];
+  }
+  [pager setValue:keys forKey:@"pageKeys"];
+  return pager;
+}
+
+- (RNCNativeScrollerComponentView *)addScrollerToPager:(RNCCollapsiblePagerViewComponentView *)pager
+                                            atIndex:(NSInteger)index
+{
+  RNCNativeScrollerComponentView *scroller = [RNCNativeScrollerComponentView new];
+  scroller.frame = CGRectMake(0, 0, 320, 600);
+  scroller.scrollView.frame = scroller.bounds;
+  scroller.scrollView.contentSize = CGSizeMake(320, 1500);
+  UIViewController *page = [pager valueForKey:@"pageControllers"][index];
+  [page.view addSubview:scroller];
+  return scroller;
+}
+
+- (void)finishMount:(RNCCollapsiblePagerViewComponentView *)pager
+{
+  MountingTransaction transaction(1, 1, {}, {});
+  SurfaceTelemetry telemetry;
+  [pager mountingTransactionDidMount:transaction withSurfaceTelemetry:telemetry];
+}
+
+- (void)testInteractiveTargetGetsInsetsBeforeSelectionWithoutTakingObserver
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:1];
+  [pager setValue:@YES forKey:@"transitioning"];
+  [pager setValue:@YES forKey:@"isPagerDragging"];
+  UIView *header = [pager valueForKey:@"sharedHeaderHostView"];
+  UIView *headerOwner = header.superview;
+  [self finishMount:pager];
+  XCTAssertEqualWithAccuracy(target.scrollView.contentInset.top, 164, 0.01);
+  XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y, -164, 0.01);
+  XCTAssertEqualObjects([pager valueForKey:@"currentIndex"], @0);
+  XCTAssertNil([pager valueForKey:@"observedScrollView"]);
+  XCTAssertEqual(header.superview, headerOwner);
+}
+
+- (void)testRepeatedMountDoesNotRestoreAnAlreadyPreparedTarget
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:1];
+  [pager setValue:@YES forKey:@"transitioning"];
+  [self finishMount:pager];
+  target.scrollView.contentOffset = CGPointMake(0, 230);
+  [self finishMount:pager];
+  XCTAssertEqualWithAccuracy(target.scrollView.contentInset.top, 164, 0.01);
+  XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y, 230, 0.01);
+}
+
+- (void)testProgrammaticDestinationOutsideAdjacentRangeIsPrepared
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:4];
+  RNCNativeScrollerComponentView *unrelated = [self addScrollerToPager:pager atIndex:2];
+  RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:3];
+  [pager setValue:@3 forKey:@"destinationIndex"];
+  [pager setValue:@YES forKey:@"transitioning"];
+  [self finishMount:pager];
+  XCTAssertEqualWithAccuracy(target.scrollView.contentInset.top, 164, 0.01);
+  XCTAssertEqualWithAccuracy(target.scrollView.contentOffset.y, -164, 0.01);
+  XCTAssertEqualWithAccuracy(unrelated.scrollView.contentInset.top, 0, 0.01);
+  XCTAssertEqualObjects([pager valueForKey:@"currentIndex"], @0);
+}
+
+- (void)testRemovedScrollerIsExcludedUntilDidMount
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:2];
+  RNCNativeScrollerComponentView *target = [self addScrollerToPager:pager atIndex:1];
+  NSHashTable *removed = [pager valueForKey:@"mountingRemovedScrollViews"];
+  [removed addObject:target.scrollView];
+  XCTAssertNil([pager findExplicitNativeScrollerInView:target]);
+  XCTAssertNil([pager findVerticalScrollViewInView:target.scrollView]);
+  [pager setValue:@YES forKey:@"transitioning"];
+  [self finishMount:pager];
+  XCTAssertEqual(removed.count, 0u);
+  XCTAssertEqual([pager findExplicitNativeScrollerInView:target], target.scrollView);
+  XCTAssertEqualWithAccuracy(target.scrollView.contentInset.top, 164, 0.01);
+}
+
+- (void)testGenericCollectionStillRequiresFallbackDebounce
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  UICollectionView *collection = [[UICollectionView alloc]
+    initWithFrame:CGRectMake(0, 0, 320, 600)
+    collectionViewLayout:[UICollectionViewFlowLayout new]];
+  UIViewController *page = [pager valueForKey:@"pageControllers"][0];
+  [page.view addSubview:collection];
+  [pager attachScrollObserverForCurrentPage];
+  XCTAssertNil([pager valueForKey:@"observedScrollView"]);
+  XCTAssertEqualObjects([pager valueForKey:@"pendingFallbackScrollView"], collection);
+  XCTAssertEqualWithAccuracy(collection.contentInset.top, 0, 0.01);
+}
+
+- (void)testRecycleClearsTransactionExclusion
+{
+  RNCCollapsiblePagerViewComponentView *pager = [self pagerWithPageCount:1];
+  RNCNativeScrollerComponentView *scroller = [self addScrollerToPager:pager atIndex:0];
+  NSHashTable *removed = [pager valueForKey:@"mountingRemovedScrollViews"];
+  [removed addObject:scroller.scrollView];
+  [pager prepareForRecycle];
+  XCTAssertEqual(removed.count, 0u);
+}
+
+@end

package/ios/tests/RNCCollapsiblePagerPressCancellationTests.mm

@@ -165,7 +165,9 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   [_window sendEvent:_event];
   if (phase == UITouchPhaseEnded || phase == UITouchPhaseCancelled) {
     [_activeTouches removeObjectIdenticalTo:changed];
-    if (_activeTouches.count == 0) [_event _clearTouches];
+    // A finished finger must not be delivered again when another finger ends.
+    [_event _clearTouches];
+    for (UITouch *touch in _activeTouches) [_event _addTouch:touch forDelayedDelivery:NO];
   }
 }
 
@@ -621,6 +623,7 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
 @property (nonatomic, strong) RNCCollapsiblePagerViewComponentView *pager;
 @property (nonatomic, strong) RNCSynthesizedTouchDriver *driver;
 @property (nonatomic, strong) UIView *firstPage;
+@property (nonatomic) NSUInteger longPressBegins;
 @end
 
 @implementation RNCCollapsiblePagerPressCancellationDeliveryTests
@@ -809,4 +812,111 @@ typedef struct __IOHIDEvent *RNCTestHIDEventRef;
   XCTAssertEqualObjects(self.handler.events, (@[@"began", @"moved", @"ended"]));
 }
 
+- (UIScrollView *)mountNestedHorizontalScrollView
+{
+  UIScrollView *vertical = [[UIScrollView alloc] initWithFrame:self.firstPage.bounds];
+  vertical.contentSize = CGSizeMake(CGRectGetWidth(vertical.bounds), 1800);
+  [self.firstPage addSubview:vertical];
+  UIScrollView *horizontal = [[UIScrollView alloc] initWithFrame:CGRectMake(40, 350, 300, 120)];
+  horizontal.contentSize = CGSizeMake(900, 120);
+  horizontal.contentOffset = CGPointMake(200, 0);
+  [vertical addSubview:horizontal];
+  UILongPressGestureRecognizer *longPress = [[UILongPressGestureRecognizer alloc]
+    initWithTarget:self action:@selector(nestedLongPress:)];
+  longPress.minimumPressDuration = 0.1;
+  [horizontal addGestureRecognizer:longPress];
+  // Re-run the production attachment path after the descendant mounts.
+  ((void (*)(id, SEL))objc_msgSend)(self.pager, NSSelectorFromString(@"attachScrollObserverForCurrentPage"));
+  [self.window layoutIfNeeded];
+  [self drainMainQueue];
+  XCTAssertEqual([self.pager valueForKey:@"observedScrollView"], vertical);
+  return horizontal;
+}
+
+- (void)nestedLongPress:(UILongPressGestureRecognizer *)recognizer
+{
+  if (recognizer.state == UIGestureRecognizerStateBegan) self.longPressBegins += 1;
+}
+
+- (CGPoint)pressPointInNestedScrollView:(UIScrollView *)scroll
+{
+  CGPoint point = [scroll convertPoint:CGPointMake(scroll.contentOffset.x + 150, 60) toView:self.window];
+  XCTAssertEqual([self.window hitTest:point withEvent:nil], scroll);
+  return point;
+}
+
+- (void)testNestedStationaryNativeLongPressRecognizesBeforeFingerUp
+{
+  UIScrollView *scroll = [self mountNestedHorizontalScrollView];
+  UITouch *touch = [self.driver beginAt:[self pressPointInNestedScrollView:scroll]];
+  UIGestureRecognizer *guard = [self.pager valueForKey:@"verticalPagerGesture"];
+  XCTAssertEqual(guard.state, UIGestureRecognizerStatePossible);
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 2);
+  XCTestExpectation *hold = [self expectationWithDescription:@"stationary finger held"];
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.25 * NSEC_PER_SEC)),
+                 dispatch_get_main_queue(), ^{ [hold fulfill]; });
+  [self waitForExpectations:@[hold] timeout:2];
+  // The real UIKit target action must arrive while the finger is still down.
+  XCTAssertEqual(self.longPressBegins, 1);
+  XCTAssertEqual(touch.phase, UITouchPhaseBegan);
+  XCTAssertEqual(guard.state, UIGestureRecognizerStatePossible);
+  [self.driver end:touch];
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 1);
+}
+
+- (void)testNestedHorizontalPanConsumesConfirmedHorizontalDrag
+{
+  UIScrollView *scroll = [self mountNestedHorizontalScrollView];
+  CGPoint point = [self pressPointInNestedScrollView:scroll];
+  CGFloat originalOffset = scroll.contentOffset.x;
+  UITouch *touch = [self.driver beginAt:point];
+  for (NSInteger step = 1; step <= 10; ++step) {
+    [self.driver move:touch to:CGPointMake(point.x - 12 * step, point.y)];
+  }
+  XCTAssertTrue(scroll.isDragging);
+  XCTAssertGreaterThan(scroll.contentOffset.x, originalOffset);
+  UIScrollView *pager = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertFalse(pager.isDragging);
+  XCTAssertEqual(self.longPressBegins, 0);
+  [self.driver end:touch];
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 1);
+}
+
+- (void)testNestedPendingHorizontalStartCanBecomeVertical
+{
+  UIScrollView *scroll = [self mountNestedHorizontalScrollView];
+  CGPoint point = [self pressPointInNestedScrollView:scroll];
+  UITouch *touch = [self.driver beginAt:point];
+  [self.driver move:touch to:CGPointMake(point.x - 8, point.y)];
+  UIGestureRecognizer *guard = [self.pager valueForKey:@"verticalPagerGesture"];
+  XCTAssertEqual(guard.state, UIGestureRecognizerStatePossible);
+  for (NSInteger step = 1; step <= 8; ++step) {
+    [self.driver move:touch to:CGPointMake(point.x - 8, point.y - 12 * step)];
+  }
+  UIScrollView *vertical = [self.pager valueForKey:@"observedScrollView"];
+  UIScrollView *pager = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertTrue(vertical.isDragging);
+  XCTAssertFalse(scroll.isDragging);
+  XCTAssertFalse(pager.isDragging);
+  XCTAssertEqual(self.longPressBegins, 0);
+  [self.driver end:touch];
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 1);
+  XCTAssertEqual(pager.panGestureRecognizer.minimumNumberOfTouches, 1);
+}
+
+- (void)testNestedHeldPanTouchCountRestoresOnSecondTouch
+{
+  UIScrollView *scroll = [self mountNestedHorizontalScrollView];
+  CGPoint point = [self pressPointInNestedScrollView:scroll];
+  UITouch *first = [self.driver beginAt:point];
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 2);
+  UITouch *second = [self.driver beginAt:CGPointMake(point.x + 20, point.y)];
+  UIScrollView *pager = [self.pager valueForKey:@"pagerScrollView"];
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 1);
+  XCTAssertEqual(pager.panGestureRecognizer.minimumNumberOfTouches, 1);
+  [self.driver end:second];
+  [self.driver end:first];
+  XCTAssertEqual(scroll.panGestureRecognizer.minimumNumberOfTouches, 1);
+}
+
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-pager-view",
-  "version": "3.0.165",
+  "version": "3.0.167",
   "description": "React Native wrapper for Android and iOS ViewPager",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",
@@ -72,7 +72,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-native-logger": "3.0.165",
+    "@onekeyfe/react-native-native-logger": "3.0.167",
     "react": "*",
     "react-native": "*"
   },