react-native-screen-transitions 3.8.0-alpha.0 → 3.8.0-beta.1

package/src/shared/providers/screen/animation/helpers/build-screen-transition-options.ts

@@ -2,10 +2,6 @@ import type {
 	ScreenTransitionConfig,
 	ScreenTransitionOptions,
 } from "../../../../types";
-import {
-	gestureProgressModeDrivesProgress,
-	resolveGestureProgressMode,
-} from "../../../../utils/gesture-progress-mode";
 import { resolveSheetScrollGestureBehavior } from "../../../../utils/resolve-screen-transition-options";
 
 export const buildScreenTransitionOptions = (
@@ -14,15 +10,6 @@ export const buildScreenTransitionOptions = (
 	const hasSheetScrollGestureBehavior =
 		options.sheetScrollGestureBehavior !== undefined ||
 		options.expandViaScrollView !== undefined;
-	const hasGestureProgressMode =
-		options.gestureProgressMode !== undefined ||
-		options.gestureDrivesProgress !== undefined;
-	const gestureProgressMode = hasGestureProgressMode
-		? resolveGestureProgressMode({
-				gestureProgressMode: options.gestureProgressMode,
-				gestureDrivesProgress: options.gestureDrivesProgress,
-			})
-		: undefined;
 
 	return {
 		navigationMaskEnabled: options.navigationMaskEnabled,
@@ -34,10 +21,8 @@ export const buildScreenTransitionOptions = (
 		gestureSnapVelocityImpact: options.gestureSnapVelocityImpact,
 		gestureReleaseVelocityScale: options.gestureReleaseVelocityScale,
 		gestureResponseDistance: options.gestureResponseDistance,
-		gestureProgressMode,
-		gestureDrivesProgress: gestureProgressMode
-			? gestureProgressModeDrivesProgress(gestureProgressMode)
-			: undefined,
+		gestureProgressMode: options.gestureProgressMode,
+		gestureDrivesProgress: options.gestureDrivesProgress,
 		gestureActivationArea: options.gestureActivationArea,
 		gestureSnapLocked: options.gestureSnapLocked,
 		sheetScrollGestureBehavior: hasSheetScrollGestureBehavior

package/src/shared/providers/screen/animation/helpers/hydrate-transition-state/gesture-progress.ts

@@ -1,15 +1,9 @@
 import { clamp } from "react-native-reanimated";
-import {
-	DEFAULT_GESTURE_DIRECTION,
-	DEFAULT_GESTURE_PROGRESS_MODE,
-	EPSILON,
-} from "../../../../../constants";
-import type { ScreenTransitionOptions } from "../../../../../types/animation.types";
+import { DEFAULT_GESTURE_DIRECTION, EPSILON } from "../../../../../constants";
 import type {
 	GestureDirectionOption,
 	GestureValues,
 } from "../../../../../types/gesture.types";
-import { resolveGestureProgressModeFromOptions } from "../../../../../utils/gesture-progress-mode";
 import {
 	getPanActivationDirections,
 	getPanSnapAxisConfigForDirection,
@@ -20,9 +14,15 @@ import {
 } from "../../../gestures/shared/directions";
 import type { SnapBounds } from "./types";
 
-const resolvePanGestureDrivenProgress = (
-	baseProgress: number,
+type PanProgressDelta = {
+	x: number;
+	y: number;
+};
+
+const resolvePanGestureAffectedProgress = (
+	transitionProgress: number,
 	gesture: GestureValues,
+	progressDelta: PanProgressDelta,
 	gestureDirection: GestureDirectionOption,
 	hasSnapPoints: boolean,
 	snapBounds: SnapBounds | null,
@@ -39,14 +39,18 @@ const resolvePanGestureDrivenProgress = (
 			: null;
 
 		if (!activeAxis || !snapBounds) {
-			return baseProgress;
+			return transitionProgress;
 		}
 
 		const axisValue =
-			activeAxis.axis === "horizontal" ? gesture.normX : gesture.normY;
-		const progressDelta = activeAxis.config.progressSign * axisValue;
+			activeAxis.axis === "horizontal" ? progressDelta.x : progressDelta.y;
+		const signedProgressDelta = activeAxis.config.progressSign * axisValue;
 
-		return clamp(baseProgress + progressDelta, snapBounds.min, snapBounds.max);
+		return clamp(
+			transitionProgress + signedProgressDelta,
+			snapBounds.min,
+			snapBounds.max,
+		);
 	}
 
 	const directions = getPanActivationDirections({
@@ -55,27 +59,27 @@ const resolvePanGestureDrivenProgress = (
 	});
 	let progressOffset = 0;
 
-	if (directions.horizontal && gesture.normX > 0) {
-		progressOffset = Math.max(progressOffset, gesture.normX);
+	if (directions.horizontal && progressDelta.x > 0) {
+		progressOffset = Math.max(progressOffset, progressDelta.x);
 	}
 
-	if (directions.horizontalInverted && gesture.normX < 0) {
-		progressOffset = Math.max(progressOffset, -gesture.normX);
+	if (directions.horizontalInverted && progressDelta.x < 0) {
+		progressOffset = Math.max(progressOffset, -progressDelta.x);
 	}
 
-	if (directions.vertical && gesture.normY > 0) {
-		progressOffset = Math.max(progressOffset, gesture.normY);
+	if (directions.vertical && progressDelta.y > 0) {
+		progressOffset = Math.max(progressOffset, progressDelta.y);
 	}
 
-	if (directions.verticalInverted && gesture.normY < 0) {
-		progressOffset = Math.max(progressOffset, -gesture.normY);
+	if (directions.verticalInverted && progressDelta.y < 0) {
+		progressOffset = Math.max(progressOffset, -progressDelta.y);
 	}
 
-	return clamp(baseProgress - progressOffset, 0, baseProgress);
+	return clamp(transitionProgress - progressOffset, 0, transitionProgress);
 };
 
-const resolvePinchGestureDrivenProgress = (
-	baseProgress: number,
+const resolvePinchGestureAffectedProgress = (
+	transitionProgress: number,
 	gesture: GestureValues,
 	gestureDirection: GestureDirectionOption,
 	hasSnapPoints: boolean,
@@ -90,13 +94,13 @@ const resolvePinchGestureDrivenProgress = (
 				: null;
 
 	if (!pinchDirection) {
-		return baseProgress;
+		return transitionProgress;
 	}
 
 	if (hasSnapPoints) {
 		const snapDirections = getSnapPinchDirectionConfig(gestureDirection);
 		if (!snapDirections || !snapBounds) {
-			return baseProgress;
+			return transitionProgress;
 		}
 
 		const progressDelta =
@@ -104,39 +108,35 @@ const resolvePinchGestureDrivenProgress = (
 				? -Math.abs(gesture.normScale)
 				: Math.abs(gesture.normScale);
 
-		return clamp(baseProgress + progressDelta, snapBounds.min, snapBounds.max);
+		return clamp(
+			transitionProgress + progressDelta,
+			snapBounds.min,
+			snapBounds.max,
+		);
 	}
 
 	const pinchDirections = getPinchGestureDirections(gestureDirection);
 	if (!pinchDirections.includes(pinchDirection)) {
-		return baseProgress;
+		return transitionProgress;
 	}
 
-	return clamp(baseProgress - Math.abs(gesture.normScale), 0, baseProgress);
+	return clamp(
+		transitionProgress - Math.abs(gesture.normScale),
+		0,
+		transitionProgress,
+	);
 };
 
-export const resolveGestureDrivenProgress = (
-	baseProgress: number,
+export const resolveGestureAffectedProgress = (
+	transitionProgress: number,
 	gesture: GestureValues,
-	options: ScreenTransitionOptions,
-	effectiveOptions: ScreenTransitionOptions | undefined,
+	panProgressDelta: PanProgressDelta,
+	gestureDirection: GestureDirectionOption | undefined,
 	snapBounds: SnapBounds | null,
 ) => {
 	"worklet";
-	const gestureProgressMode = resolveGestureProgressModeFromOptions(
-		effectiveOptions,
-		options,
-		DEFAULT_GESTURE_PROGRESS_MODE,
-	);
-
-	if (gestureProgressMode === "freeform") {
-		return baseProgress;
-	}
-
-	const gestureDirection =
-		effectiveOptions?.gestureDirection ??
-		options.gestureDirection ??
-		DEFAULT_GESTURE_DIRECTION;
+	const resolvedGestureDirection =
+		gestureDirection ?? DEFAULT_GESTURE_DIRECTION;
 
 	const hasSnapPoints = snapBounds !== null;
 
@@ -145,19 +145,20 @@ export const resolveGestureDrivenProgress = (
 		gesture.active === "pinch-out" ||
 		Math.abs(gesture.normScale) > EPSILON
 	) {
-		return resolvePinchGestureDrivenProgress(
-			baseProgress,
+		return resolvePinchGestureAffectedProgress(
+			transitionProgress,
 			gesture,
-			gestureDirection,
+			resolvedGestureDirection,
 			hasSnapPoints,
 			snapBounds,
 		);
 	}
 
-	return resolvePanGestureDrivenProgress(
-		baseProgress,
+	return resolvePanGestureAffectedProgress(
+		transitionProgress,
 		gesture,
-		gestureDirection,
+		panProgressDelta,
+		resolvedGestureDirection,
 		hasSnapPoints,
 		snapBounds,
 	);

package/src/shared/providers/screen/animation/helpers/hydrate-transition-state/index.ts

@@ -4,7 +4,7 @@ import type {
 	TransitionInterpolatorOptions,
 } from "../../../../../types/animation.types";
 import type { Layout } from "../../../../../types/screen.types";
-import { resolveGestureDrivenProgress } from "./gesture-progress";
+import { resolveGestureAffectedProgress } from "./gesture-progress";
 import {
 	computeAnimatedSnapIndex,
 	computeTargetSnapIndex,
@@ -58,13 +58,14 @@ export const hydrateTransitionState = (
 ) => {
 	"worklet";
 	const out = s.unwrapped;
-	const baseProgress = s.progress.get();
+	const transitionProgress = s.transitionProgress.get();
 	const options = mergeTransitionOptions(
 		s.options,
 		effectiveOptions,
 		s.optionsSlot,
 	);
 	const canDismiss = options.gestureEnabled !== false;
+	out.transitionProgress = transitionProgress;
 	out.willAnimate = s.willAnimate.get();
 	out.closing = s.closing.get();
 	out.entering = s.entering.get();
@@ -90,11 +91,74 @@ export const hydrateTransitionState = (
 	out.gesture.settling = s.gesture.settling.get();
 	out.gesture.active = s.gesture.active.get();
 	out.gesture.direction = s.gesture.direction.get();
-	out.progress = resolveGestureDrivenProgress(
-		baseProgress,
+	const handoff = out.gesture.handoff;
+	const useHandoffSnapshot = out.gesture.dismissing;
+
+	handoff.x = useHandoffSnapshot
+		? s.gesture.internal.snapshot.x.get()
+		: out.gesture.x;
+	handoff.y = useHandoffSnapshot
+		? s.gesture.internal.snapshot.y.get()
+		: out.gesture.y;
+	handoff.normX = useHandoffSnapshot
+		? s.gesture.internal.snapshot.normX.get()
+		: out.gesture.normX;
+	handoff.normY = useHandoffSnapshot
+		? s.gesture.internal.snapshot.normY.get()
+		: out.gesture.normY;
+	handoff.velocity = useHandoffSnapshot
+		? s.gesture.internal.snapshot.velocity.get()
+		: out.gesture.velocity;
+	handoff.scale = useHandoffSnapshot
+		? s.gesture.internal.snapshot.scale.get()
+		: out.gesture.scale;
+	handoff.normScale = useHandoffSnapshot
+		? s.gesture.internal.snapshot.normScale.get()
+		: out.gesture.normScale;
+	handoff.focalX = useHandoffSnapshot
+		? s.gesture.internal.snapshot.focalX.get()
+		: out.gesture.focalX;
+	handoff.focalY = useHandoffSnapshot
+		? s.gesture.internal.snapshot.focalY.get()
+		: out.gesture.focalY;
+	handoff.rotation = useHandoffSnapshot
+		? s.gesture.internal.snapshot.rotation.get()
+		: out.gesture.rotation;
+	handoff.raw.x = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.x.get()
+		: out.gesture.raw.x;
+	handoff.raw.y = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.y.get()
+		: out.gesture.raw.y;
+	handoff.raw.normX = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.normX.get()
+		: out.gesture.raw.normX;
+	handoff.raw.normY = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.normY.get()
+		: out.gesture.raw.normY;
+	handoff.raw.scale = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.scale.get()
+		: out.gesture.raw.scale;
+	handoff.raw.normScale = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.normScale.get()
+		: out.gesture.raw.normScale;
+	handoff.raw.rotation = useHandoffSnapshot
+		? s.gesture.internal.snapshot.raw.rotation.get()
+		: out.gesture.raw.rotation;
+	handoff.active = useHandoffSnapshot
+		? s.gesture.internal.snapshot.active.get()
+		: out.gesture.active;
+	handoff.direction = useHandoffSnapshot
+		? s.gesture.internal.snapshot.direction.get()
+		: out.gesture.direction;
+	out.progress = resolveGestureAffectedProgress(
+		transitionProgress,
 		out.gesture,
-		s.options,
-		effectiveOptions,
+		{
+			x: s.gesture.internal.progressDeltaX.get(),
+			y: s.gesture.internal.progressDeltaY.get(),
+		},
+		effectiveOptions?.gestureDirection ?? s.options.gestureDirection,
 		getResolvedSnapBounds(
 			s.sortedNumericSnapPoints,
 			s.hasAutoSnapPoint ? s.resolvedAutoSnapPoint.get() : null,
@@ -104,8 +168,8 @@ export const hydrateTransitionState = (
 
 	// Unsure where else to place this if im being honest.
 	// I think for here is fine
-	if (s.effectiveProgress.get() !== out.progress) {
-		s.effectiveProgress.set(out.progress);
+	if (s.visualProgress.get() !== out.progress) {
+		s.visualProgress.set(out.progress);
 	}
 
 	const hasResidualGestureValues =
@@ -149,6 +213,8 @@ export const hydrateTransitionState = (
 		out.layouts.content = undefined;
 	}
 
+	out.layouts.scroll = s.scrollMetadata.get() ?? undefined;
+
 	const autoSnapPoint = s.resolvedAutoSnapPoint.get();
 	const resolvedAutoSnap =
 		s.hasAutoSnapPoint && autoSnapPoint > 0 ? autoSnapPoint : null;

package/src/shared/providers/screen/animation/helpers/hydrate-transition-state/types.ts

@@ -4,12 +4,13 @@ import type {
 	ScreenTransitionOptions,
 	ScreenTransitionState,
 } from "../../../../../types/animation.types";
+import type { ScrollMetadataState } from "../../../../../types/gesture.types";
 import type { Layout } from "../../../../../types/screen.types";
 import type { BaseStackRoute } from "../../../../../types/stack.types";
 
 export type BuiltState = {
-	progress: SharedValue<number>;
-	effectiveProgress: SharedValue<number>;
+	transitionProgress: SharedValue<number>;
+	visualProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	closing: SharedValue<number>;
 	progressAnimating: SharedValue<number>;
@@ -23,6 +24,7 @@ export type BuiltState = {
 	targetProgress: SharedValue<number>;
 	resolvedAutoSnapPoint: SharedValue<number>;
 	measuredContentLayout: SharedValue<Layout | null>;
+	scrollMetadata: SharedValue<ScrollMetadataState | null>;
 	contentLayoutSlot: Layout;
 	hasAutoSnapPoint: boolean;
 	sortedNumericSnapPoints: number[];

package/src/shared/providers/screen/animation/helpers/pipeline.ts

@@ -78,9 +78,9 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 
 	const currentRouteKey = currDescriptor?.route?.key;
 	const currentIndex = routeKeys.indexOf(currentRouteKey);
-	const effectiveProgressValues = useMemo(() => {
+	const visualProgressValues = useMemo(() => {
 		return routeKeys.map((routeKey) =>
-			AnimationStore.getValue(routeKey, "effectiveProgress"),
+			AnimationStore.getValue(routeKey, "visualProgress"),
 		);
 	}, [routeKeys]);
 
@@ -143,7 +143,7 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 
 			frame.stackProgress = deriveStackProgress(
 				routeKeys,
-				effectiveProgressValues,
+				visualProgressValues,
 				currentIndex,
 				frame.progress,
 				currentRouteKey,

package/src/shared/providers/screen/animation/helpers/stack-progress.ts

@@ -2,7 +2,7 @@ import type { SharedValue } from "react-native-reanimated";
 
 export const deriveStackProgress = (
 	routeKeys: string[],
-	effectiveProgressValues: SharedValue<number>[],
+	visualProgressValues: SharedValue<number>[],
 	currentIndex: number,
 	fallbackProgress: number,
 	currentRouteKey: string | undefined,
@@ -14,14 +14,14 @@ export const deriveStackProgress = (
 	if (currentIndex < 0) return fallbackProgress;
 
 	let total = 0;
-	for (let i = currentIndex; i < effectiveProgressValues.length; i++) {
+	for (let i = currentIndex; i < visualProgressValues.length; i++) {
 		const routeKey = routeKeys[i];
 		if (routeKey === currentRouteKey) {
 			total += currentProgress;
 		} else if (routeKey === nextRouteKey && nextProgress !== undefined) {
 			total += nextProgress;
 		} else {
-			total += effectiveProgressValues[i].get();
+			total += visualProgressValues[i].get();
 		}
 	}
 

package/src/shared/providers/screen/animation/helpers/use-build-transition-state.ts

@@ -6,11 +6,13 @@ import {
 	GestureStore,
 	type GestureStoreMap,
 } from "../../../../stores/gesture.store";
+import { ScrollStore } from "../../../../stores/scroll.store";
 import { SystemStore } from "../../../../stores/system.store";
 import type {
 	BaseStackRoute,
 	Layout,
 	ScreenTransitionState,
+	ScrollMetadataState,
 } from "../../../../types";
 import type { ScreenTransitionOptions } from "../../../../types/animation.types";
 import type { BaseDescriptor } from "../../descriptors";
@@ -18,8 +20,8 @@ import { buildScreenTransitionOptions } from "./build-screen-transition-options"
 import { toPlainRoute, toPlainValue } from "./worklet";
 
 type BuiltState = {
-	progress: SharedValue<number>;
-	effectiveProgress: SharedValue<number>;
+	transitionProgress: SharedValue<number>;
+	visualProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	closing: SharedValue<number>;
 	progressAnimating: SharedValue<number>;
@@ -33,6 +35,7 @@ type BuiltState = {
 	targetProgress: SharedValue<number>;
 	resolvedAutoSnapPoint: SharedValue<number>;
 	measuredContentLayout: SharedValue<Layout | null>;
+	scrollMetadata: SharedValue<ScrollMetadataState | null>;
 	contentLayoutSlot: Layout;
 	hasAutoSnapPoint: boolean;
 	sortedNumericSnapPoints: number[];
@@ -62,8 +65,8 @@ export const useBuildTransitionState = (
 		const transitionOptions = buildScreenTransitionOptions(descriptor.options);
 
 		return {
-			progress: AnimationStore.getValue(key, "progress"),
-			effectiveProgress: AnimationStore.getValue(key, "effectiveProgress"),
+			transitionProgress: AnimationStore.getValue(key, "transitionProgress"),
+			visualProgress: AnimationStore.getValue(key, "visualProgress"),
 			willAnimate: AnimationStore.getValue(key, "willAnimate"),
 			closing: AnimationStore.getValue(key, "closing"),
 			entering: AnimationStore.getValue(key, "entering"),
@@ -72,6 +75,7 @@ export const useBuildTransitionState = (
 			targetProgress: SystemStore.getValue(key, "targetProgress"),
 			resolvedAutoSnapPoint: SystemStore.getValue(key, "resolvedAutoSnapPoint"),
 			measuredContentLayout: SystemStore.getValue(key, "measuredContentLayout"),
+			scrollMetadata: ScrollStore.getValue(key, "metadata"),
 			contentLayoutSlot: { width: 0, height: 0 },
 			hasAutoSnapPoint: snapPoints?.includes("auto") ?? false,
 			sortedNumericSnapPoints,

package/src/shared/providers/screen/gestures/gestures.provider.tsx

@@ -11,7 +11,7 @@ import { useBuildPinchGesture } from "./pinch/use-build-pinch-gesture";
 import { useBuildRotationGesture } from "./rotation/use-build-rotation-gesture";
 import {
 	type DirectionClaimMap,
-	type GestureCompositionActivation,
+	type GestureCompositionOwner,
 	type GestureContextType,
 	NO_DIRECTION_CLAIMS,
 } from "./types";
@@ -31,34 +31,32 @@ export const {
 	const gestureConfig = useScreenGestureConfig();
 	const { currentScreenKey } = useDescriptorDerivations();
 
-	const scrollState = ScrollStore.getValue(currentScreenKey, "state");
+	const scrollState = ScrollStore.getValue(currentScreenKey, "coordination");
 
 	// Ancestors read this before activating. If a nested screen claims the same
 	// direction, it writes here so the ancestor can fail and let it take priority.
 	const childDirectionClaims =
 		useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
 
-	// Pinch gestures should be simultaneous with pan gestures, but pan gestures should not be simultaneous with pinch gestures.
-	// Since we're using manual gestures, if pinch tries to become activated while pan is already active,
-	// the pinch gesture will be cancelled and the pan gesture will continue to be active.
-	const gestureCompositionActivation =
-		useSharedValue<GestureCompositionActivation>(null);
+	// The first gesture to activate owns navigation release. Other gestures may
+	// still join as companion trackers during the same simultaneous composition.
+	const gestureCompositionOwner = useSharedValue<GestureCompositionOwner>(null);
 
 	const panGesture = useBuildPanGesture({
 		scrollState,
 		gestureConfig,
 		childDirectionClaims,
-		gestureCompositionActivation,
+		gestureCompositionOwner,
 	});
 
 	const pinchGesture = useBuildPinchGesture({
 		gestureConfig,
-		gestureCompositionActivation,
+		gestureCompositionOwner,
 	});
 
 	const rotationGesture = useBuildRotationGesture({
 		gestureConfig,
-		gestureCompositionActivation,
+		gestureCompositionOwner,
 	});
 
 	const detectorGesture = useMemo(

package/src/shared/providers/screen/gestures/hooks/use-stable-runtime-config.ts

@@ -15,8 +15,7 @@ export function useStableRuntimeConfig<TPolicy extends GesturePolicy>(
 	runtimeConfigInput: RuntimeConfigInput<TPolicy>,
 ): SharedValue<GestureRuntime<TPolicy>> {
 	const { currentScreenKey } = useDescriptorDerivations();
-	const { participation, policy, gestureProgressBaseline, lockedSnapPoint } =
-		runtimeConfigInput;
+	const { participation, policy } = runtimeConfigInput;
 
 	const stores = useMemo(() => {
 		return {
@@ -31,10 +30,8 @@ export function useStableRuntimeConfig<TPolicy extends GesturePolicy>(
 			participation,
 			policy,
 			stores,
-			gestureProgressBaseline,
-			lockedSnapPoint,
 		};
-	}, [participation, policy, stores, gestureProgressBaseline, lockedSnapPoint]);
+	}, [participation, policy, stores]);
 	const stableRuntimeConfig = useSharedValue(runtimeConfig);
 
 	useLayoutEffect(() => {

package/src/shared/providers/screen/gestures/pan/activation/pan-activation-decision.ts

@@ -246,7 +246,7 @@ const resolveSnapScrollExpansionDecision = (
 	});
 
 	const canExpandMore =
-		animations.progress.get() < resolvedMaxSnapPoint - EPSILON &&
+		animations.transitionProgress.get() < resolvedMaxSnapPoint - EPSILON &&
 		system.targetProgress.get() < resolvedMaxSnapPoint - EPSILON;
 
 	if (canExpandMore) {
@@ -280,13 +280,22 @@ const resolveDismissingDecision = (
 	);
 };
 
+const isVerticalDirection = (direction: Direction) => {
+	"worklet";
+	return direction === "vertical" || direction === "vertical-inverted";
+};
+
 const resolveUntouchedScrollDecision = (
 	scrollState: ScrollGestureState | null,
 	swipeDirection: Direction,
 	nextActivationState: GestureActivationState,
 ): PanActivationDecision | null => {
 	"worklet";
-	if (scrollState?.isTouched ?? false) {
+	const axisState = isVerticalDirection(swipeDirection)
+		? scrollState?.vertical
+		: scrollState?.horizontal;
+
+	if (axisState?.isTouched ?? false) {
 		return null;
 	}
 

package/src/shared/providers/screen/gestures/pan/activation/use-pan-activation.ts

@@ -11,7 +11,7 @@ import type { ScreenOptionsContextValue } from "../../../options";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
 	DirectionClaimMap,
-	GestureCompositionActivation,
+	GestureCompositionOwner,
 	GestureDimensions,
 	PanGestureRuntime,
 	ScrollGestureState,
@@ -24,7 +24,7 @@ interface UsePanActivationProps {
 	runtime: SharedValue<PanGestureRuntime>;
 	screenOptions: ScreenOptionsContextValue;
 	dimensions: GestureDimensions;
-	gestureCompositionActivation: SharedValue<GestureCompositionActivation>;
+	gestureCompositionOwner: SharedValue<GestureCompositionOwner>;
 }
 
 export const usePanActivation = ({
@@ -33,7 +33,7 @@ export const usePanActivation = ({
 	runtime,
 	screenOptions,
 	dimensions,
-	gestureCompositionActivation,
+	gestureCompositionOwner,
 }: UsePanActivationProps) => {
 	const { currentScreenKey, parentScreenKey } = useDescriptorDerivations();
 
@@ -82,10 +82,12 @@ export const usePanActivation = ({
 				screenOptions.get(),
 			);
 
+			// If another gesture owns this composition, let pan join as a
+			// companion tracker instead of running normal pan activation gates.
 			if (
-				gestureCompositionActivation.get() === "pinch" &&
+				gestureCompositionOwner.get() !== null &&
 				resolvedRuntime.participation.canTrackGesture &&
-				event.numberOfTouches === 2
+				resolvedRuntime.policy.enabled
 			) {
 				stateManager.activate();
 				return;
@@ -122,7 +124,7 @@ export const usePanActivation = ({
 				gestures.direction.set(decision.direction);
 			}
 
-			gestureCompositionActivation.set("pan");
+			gestureCompositionOwner.set("pan");
 			stateManager.activate();
 		},
 		[
@@ -135,7 +137,7 @@ export const usePanActivation = ({
 			runtime,
 			screenOptions,
 			scrollState,
-			gestureCompositionActivation,
+			gestureCompositionOwner,
 		],
 	);