react-native-screen-transitions 3.13.0-beta.0 → 3.13.0-beta.1

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

@@ -4,6 +4,7 @@ import { useSharedValue } from "react-native-reanimated";
 import { ScrollStore } from "../../../stores/scroll.store";
 import createProvider from "../../../utils/create-provider";
 import { useDescriptorsStore } from "../descriptors";
+import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useScreenGestureConfig } from "./hooks/use-screen-gesture-config";
 import { GestureOwnershipBridge } from "./ownership/gesture-ownership-bridge";
 import { useBuildPanGesture } from "./pan/use-build-pan-gesture";
@@ -13,100 +14,110 @@ import {
 	type GestureCompositionOwner,
 	type GestureContextType,
 	NO_DIRECTION_CLAIMS,
+	type ScreenGestureSource,
 } from "./types";
 
 interface ScreenGestureProviderProps {
 	children: React.ReactNode;
 }
 
-export const { ScreenGestureProvider, useScreenGestureStore: useGestureStore } =
-	createProvider("ScreenGesture", { guarded: false })<
-		ScreenGestureProviderProps,
-		GestureContextType
-	>(
-		(
-			{ children },
-			{ useParentStore },
-		): { value: GestureContextType; children: React.ReactNode } => {
-			const currentScreenKey = useDescriptorsStore(
-				(store) => store.derivations.currentScreenKey,
-			);
-			const isTopMostScreen = useDescriptorsStore(
-				(store) => store.derivations.isTopMostScreen,
-			);
-			const gestureContext = useParentStore((parentContext) =>
-				isTopMostScreen ? parentContext : null,
-			);
-			const gestureConfig = useScreenGestureConfig(gestureContext);
+type ScreenGestureStoreValue = GestureContextType & {
+	relationshipGestureSources: readonly ScreenGestureSource[];
+};
 
-			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);
+const EMPTY_GESTURE_SOURCES: readonly ScreenGestureSource[] = [];
 
-			// 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 createScreenGestureProvider = createProvider("ScreenGesture", {
+	global: true,
+})<ScreenGestureProviderProps, ScreenGestureStoreValue>;
 
-			const panGesture = useBuildPanGesture({
+export const {
+	ScreenGestureProvider,
+	useOptionalScreenGestureStore,
+	useScreenGestureStore,
+}: ReturnType<typeof createScreenGestureProvider> = createScreenGestureProvider(
+	({ children }) => {
+		const currentScreenKey = useDescriptorsStore(
+			(store) => store.derivations.currentScreenKey,
+		);
+		const isTopMostScreen = useDescriptorsStore(
+			(store) => store.derivations.isTopMostScreen,
+		);
+		const relationships = useCurrentScreenRelationships();
+		const relationshipAncestorGestures =
+			useOptionalScreenGestureStore(
+				relationships.parentScreenKey,
+				(store) => store.relationshipGestureSources,
+			) ?? EMPTY_GESTURE_SOURCES;
+		const ancestorGestures = isTopMostScreen
+			? relationshipAncestorGestures
+			: EMPTY_GESTURE_SOURCES;
+		const gestureConfig = useScreenGestureConfig(ancestorGestures);
+		const scrollState = ScrollStore.getValue(currentScreenKey, "coordination");
+		const childDirectionClaims =
+			useSharedValue<DirectionClaimMap>(NO_DIRECTION_CLAIMS);
+		const gestureCompositionOwner =
+			useSharedValue<GestureCompositionOwner>(null);
+		const panGesture = useBuildPanGesture({
+			scrollState,
+			gestureConfig,
+			childDirectionClaims,
+			gestureCompositionOwner,
+		});
+		const pinchGesture = useBuildPinchGesture({
+			gestureConfig,
+			gestureCompositionOwner,
+		});
+		const detectorGesture = useMemo(
+			() => Gesture.Simultaneous(panGesture, pinchGesture),
+			[panGesture, pinchGesture],
+		);
+		const source = useMemo<ScreenGestureSource>(
+			() => ({
+				routeKey: currentScreenKey,
+				detectorGesture,
+				panGesture,
+				pinchGesture,
 				scrollState,
-				gestureConfig,
+				claimedDirections: gestureConfig.participation.claimedDirections,
 				childDirectionClaims,
-				gestureCompositionOwner,
-			});
-
-			const pinchGesture = useBuildPinchGesture({
-				gestureConfig,
-				gestureCompositionOwner,
-			});
-
-			const detectorGesture = useMemo(
-				() => Gesture.Simultaneous(panGesture, pinchGesture),
-				[panGesture, pinchGesture],
-			);
-
-			const value = useMemo<GestureContextType>(
-				() => ({
-					routeKey: currentScreenKey,
-					detectorGesture,
-					panGesture,
-					pinchGesture,
-					scrollState,
-					gestureContext,
-					claimedDirections: gestureConfig.participation.claimedDirections,
-					childDirectionClaims,
-				}),
-				[
-					currentScreenKey,
-					detectorGesture,
-					panGesture,
-					pinchGesture,
-					scrollState,
-					gestureContext,
-					gestureConfig.participation.claimedDirections,
-					childDirectionClaims,
-				],
-			);
-
-			const content = useMemo(
-				() => (
-					<Fragment>
-						<GestureOwnershipBridge />
-						{children}
-					</Fragment>
-				),
-				[children],
-			);
+			}),
+			[
+				currentScreenKey,
+				detectorGesture,
+				panGesture,
+				pinchGesture,
+				scrollState,
+				gestureConfig.participation.claimedDirections,
+				childDirectionClaims,
+			],
+		);
+		const relationshipGestureSources = useMemo(
+			() => [source, ...ancestorGestures],
+			[source, ancestorGestures],
+		);
+		const value = useMemo<ScreenGestureStoreValue>(
+			() => ({
+				...source,
+				ancestorGestures,
+				relationshipGestureSources,
+			}),
+			[source, ancestorGestures, relationshipGestureSources],
+		);
+		const content = useMemo(
+			() => (
+				<Fragment>
+					<GestureOwnershipBridge />
+					{children}
+				</Fragment>
+			),
+			[children],
+		);
 
-			return {
-				value,
-				children: content,
-			};
-		},
-	);
+		return {
+			key: currentScreenKey,
+			value,
+			children: content,
+		};
+	},
+);

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

@@ -2,10 +2,10 @@ import { usePreventRemoveContext } from "@react-navigation/native";
 import { useMemo } from "react";
 import { useDescriptorsStore } from "../../descriptors";
 import { resolveScreenGestureConfig } from "../shared/policy";
-import type { GestureContextType, ScreenGestureConfig } from "../types";
+import type { ScreenGestureConfig, ScreenGestureSource } from "../types";
 
 export function useScreenGestureConfig(
-	gestureContext: GestureContextType | null,
+	ancestorGestures: readonly ScreenGestureSource[],
 ): ScreenGestureConfig {
 	const options = useDescriptorsStore((store) => store.options);
 	const isFirstKey = useDescriptorsStore(
@@ -23,9 +23,9 @@ export function useScreenGestureConfig(
 			resolveScreenGestureConfig({
 				options,
 				isFirstKey,
-				gestureContext,
+				ancestorGestures,
 				isRemovePrevented,
 			}),
-		[isFirstKey, options, gestureContext, isRemovePrevented],
+		[isFirstKey, options, ancestorGestures, isRemovePrevented],
 	);
 }

package/src/shared/providers/screen/gestures/hooks/use-screen-gesture.ts

@@ -2,8 +2,7 @@ import {
 	type ChainTarget,
 	resolveChainTarget,
 } from "../../../../utils/resolve-chain-target";
-import { useGestureStore } from "../gestures.provider";
-import { walkGestureAncestors } from "../shared/ancestors";
+import { useOptionalScreenGestureStore } from "../gestures.provider";
 
 export type ScreenGestureTarget = ChainTarget;
 
@@ -21,13 +20,13 @@ export type ScreenGestureTarget = ChainTarget;
  * ```
  */
 export const useScreenGesture = (target?: ScreenGestureTarget) => {
-	const ctx = useGestureStore();
+	const ctx = useOptionalScreenGestureStore();
 
 	return (
 		resolveChainTarget({
 			target,
 			self: ctx,
-			ancestors: walkGestureAncestors(ctx?.gestureContext),
+			ancestors: ctx?.ancestorGestures ?? [],
 		})?.panGesture ?? null
 	);
 };

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

@@ -1,6 +1,7 @@
 export {
 	ScreenGestureProvider,
-	useGestureStore,
+	useOptionalScreenGestureStore,
+	useScreenGestureStore,
 } from "./gestures.provider";
 export type {
 	DirectionClaim,

package/src/shared/providers/screen/gestures/ownership/gesture-ownership-bridge.tsx

@@ -10,15 +10,14 @@ import {
 	type BaseDescriptor,
 	useDescriptorsStore,
 } from "../../../screen/descriptors";
-import { useBlankStackStore } from "../../../stack/blank-stack.provider";
-import { useGestureStore } from "../gestures.provider";
-import { walkGestureAncestors } from "../shared/ancestors";
+import { useOptionalBlankStackStore } from "../../../stack/blank-stack.provider";
+import { useScreenGestureStore } from "../gestures.provider";
 import { resolveScreenGestureConfig } from "../shared/policy";
-import type { GestureContextType } from "../types";
+import type { ScreenGestureSource } from "../types";
 import { resolveShadowingClaimDirections } from "./shadowing-claims";
 
 type ShadowedAncestor = {
-	ancestor: GestureContextType;
+	ancestor: ScreenGestureSource;
 	directions: Direction[];
 };
 
@@ -40,15 +39,15 @@ const findShadowedDirections = (
 };
 
 const findShadowedAncestors = (
-	parentContext: GestureContextType | null,
+	ancestorGestures: readonly ScreenGestureSource[],
 	claimedDirections: ClaimedDirections,
 ) => {
-	if (!parentContext) {
+	if (ancestorGestures.length === 0) {
 		return NO_SHADOWED_ANCESTORS;
 	}
 
 	const ancestors: ShadowedAncestor[] = [];
-	for (const ancestor of walkGestureAncestors(parentContext)) {
+	for (const ancestor of ancestorGestures) {
 		const directions = findShadowedDirections(
 			claimedDirections,
 			ancestor.claimedDirections,
@@ -107,7 +106,7 @@ const getDescriptorIsFirstKey = (descriptor: BaseDescriptor): boolean => {
 
 const getDescriptorClaimedDirections = (
 	descriptor: BaseDescriptor | undefined,
-	gestureContext: GestureContextType | null,
+	ancestorGestures: readonly ScreenGestureSource[],
 ): ClaimedDirections => {
 	if (!descriptor) {
 		return NO_CLAIMS;
@@ -116,32 +115,20 @@ const getDescriptorClaimedDirections = (
 	return resolveScreenGestureConfig({
 		options: descriptor.options,
 		isFirstKey: getDescriptorIsFirstKey(descriptor),
-		gestureContext,
+		ancestorGestures,
 	}).participation.claimedDirections;
 };
 
-const requireGestureContext = (
-	gestureContext: GestureContextType | null,
-): GestureContextType => {
-	if (!gestureContext) {
-		throw new Error(
-			"GestureOwnershipBridge must be rendered within a ScreenGestureProvider",
-		);
-	}
-
-	return gestureContext;
-};
-
 function ActiveGestureOwnershipBridge() {
-	const gestureContext = requireGestureContext(useGestureStore());
+	const gestureContext = useScreenGestureStore();
 	const previous = useDescriptorsStore((store) => store.previous);
-	const isCurrentScreenClosing = useBlankStackStore(
+	const isCurrentScreenClosing = useOptionalBlankStackStore(
 		(store) =>
 			store?.scenesByKey[gestureContext.routeKey]?.activity === "closing",
 	);
 	const {
 		claimedDirections,
-		gestureContext: parentContext,
+		ancestorGestures,
 		routeKey: currentScreenKey,
 	} = gestureContext;
 	// A retained closing screen cannot receive touches, so its ownership must
@@ -153,14 +140,14 @@ function ActiveGestureOwnershipBridge() {
 				currentClaimedDirections: claimedDirections,
 				previousClaimedDirections: getDescriptorClaimedDirections(
 					previous,
-					parentContext,
+					ancestorGestures,
 				),
 			}),
-		[isCurrentScreenClosing, claimedDirections, previous, parentContext],
+		[isCurrentScreenClosing, claimedDirections, previous, ancestorGestures],
 	);
 	const shadowedAncestors = useMemo(
-		() => findShadowedAncestors(parentContext, effectiveClaimedDirections),
-		[parentContext, effectiveClaimedDirections],
+		() => findShadowedAncestors(ancestorGestures, effectiveClaimedDirections),
+		[ancestorGestures, effectiveClaimedDirections],
 	);
 
 	useLayoutEffect(() => {

package/src/shared/providers/screen/gestures/ownership/resolve-ownership.ts

@@ -16,7 +16,6 @@ import type { DirectionClaim } from "../types";
  */
 interface AncestorClaimsContext {
 	claimedDirections: ClaimedDirections;
-	gestureContext: AncestorClaimsContext | null;
 }
 
 /**
@@ -31,12 +30,12 @@ interface AncestorClaimsContext {
  * used in worklets since it's a plain object.
  *
  * @param selfClaims - The directions claimed by the current screen
- * @param gestureContext - The gesture context chain (can be null if no ancestors)
+ * @param ancestors - Nearest-first ancestor gesture values from screen topology.
  * @returns Ownership status for all four directions
  */
 export function resolveOwnership(
 	selfClaims: ClaimedDirections,
-	gestureContext: AncestorClaimsContext | null,
+	ancestors: readonly AncestorClaimsContext[],
 ): DirectionOwnership {
 	const result: DirectionOwnership = { ...NO_OWNERSHIP };
 
@@ -44,7 +43,7 @@ export function resolveOwnership(
 		result[direction] = resolveDirectionOwnership(
 			direction,
 			selfClaims,
-			gestureContext,
+			ancestors,
 		);
 	}
 
@@ -57,7 +56,7 @@ export function resolveOwnership(
 function resolveDirectionOwnership(
 	direction: Direction,
 	selfClaims: ClaimedDirections,
-	gestureContext: AncestorClaimsContext | null,
+	ancestors: readonly AncestorClaimsContext[],
 ): OwnershipStatus {
 	// Check self first
 	if (selfClaims[direction]) {
@@ -65,12 +64,10 @@ function resolveDirectionOwnership(
 	}
 
 	// Walk ancestors looking for a claim
-	let ancestor = gestureContext;
-	while (ancestor) {
+	for (const ancestor of ancestors) {
 		if (ancestor.claimedDirections?.[direction]) {
 			return "ancestor";
 		}
-		ancestor = ancestor.gestureContext;
 	}
 
 	// No one claims this direction

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

@@ -9,6 +9,7 @@ import { GestureActivationState } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
 import { useDescriptorsStore } from "../../../descriptors";
 import type { ScreenOptionsContextValue } from "../../../options";
+import { useCurrentScreenRelationships } from "../../../use-current-screen-relationships";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
 	DirectionClaimMap,
@@ -39,9 +40,7 @@ export const usePanActivation = ({
 	const currentScreenKey = useDescriptorsStore(
 		(store) => store.derivations.currentScreenKey,
 	);
-	const parentScreenKey = useDescriptorsStore(
-		(store) => store.derivations.parentScreenKey,
-	);
+	const { parentScreenKey } = useCurrentScreenRelationships();
 
 	const ancestorDismissing = useMemo(() => {
 		if (!parentScreenKey) return null;

package/src/shared/providers/screen/gestures/scroll-coordination/scroll-metadata-owner.tsx

@@ -14,21 +14,20 @@ const DEFAULT_SCROLL_METADATA_OWNER_CONTEXT: ScrollMetadataOwnerContextValue = {
 	horizontal: false,
 };
 
-const {
+export const {
 	ScrollMetadataOwnerProvider,
-	useScrollMetadataOwnerStore: useMaybeScrollMetadataOwnerStore,
-} = createProvider("ScrollMetadataOwner", { guarded: false })<
+	useOptionalScrollMetadataOwnerStore,
+} = createProvider("ScrollMetadataOwner")<
 	ScrollMetadataOwnerProviderProps,
 	ScrollMetadataOwnerContextValue
 >(({ children, value }) => ({ children, value }));
 
-export const useScrollMetadataOwnerStore = () =>
-	useMaybeScrollMetadataOwnerStore() ?? DEFAULT_SCROLL_METADATA_OWNER_CONTEXT;
-
 export const useScrollMetadataOwnerProviderValue = (
 	axis: ScrollGestureAxis,
 ) => {
-	const parent = useScrollMetadataOwnerStore();
+	const parent =
+		useOptionalScrollMetadataOwnerStore() ??
+		DEFAULT_SCROLL_METADATA_OWNER_CONTEXT;
 
 	return useMemo(() => {
 		if (parent[axis]) return parent;
@@ -39,5 +38,3 @@ export const useScrollMetadataOwnerProviderValue = (
 		};
 	}, [axis, parent]);
 };
-
-export { ScrollMetadataOwnerProvider };

package/src/shared/providers/screen/gestures/scroll-coordination/use-scroll-gesture-coordination.ts

@@ -10,7 +10,7 @@ import { useSharedValueState } from "../../../../hooks/reanimated/use-shared-val
 import useStableCallback from "../../../../hooks/use-stable-callback";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { ScrollStore } from "../../../../stores/scroll.store";
-import { useGestureStore } from "../gestures.provider";
+import { useOptionalScreenGestureStore } from "../gestures.provider";
 import type {
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
@@ -18,8 +18,8 @@ import type {
 	ScrollMetadataState,
 } from "../types";
 import {
+	useOptionalScrollMetadataOwnerStore,
 	useScrollMetadataOwnerProviderValue,
-	useScrollMetadataOwnerStore,
 } from "./scroll-metadata-owner";
 import {
 	clearScrollMetadataAxisState,
@@ -88,21 +88,25 @@ const clearScrollMetadataAxis = (
 export const useScrollGestureCoordination = (
 	props: ScrollGestureCoordinationProps,
 ) => {
-	const context = useGestureStore();
+	const context = useOptionalScreenGestureStore();
 	const scrollDirection = props.direction ?? "vertical";
+	const gesturePath = useMemo(
+		() => (context ? [context, ...context.ancestorGestures] : []),
+		[context],
+	);
 
-	const metadataOwnerContext = useScrollMetadataOwnerStore();
+	const metadataOwnerContext = useOptionalScrollMetadataOwnerStore();
 	const metadataOwnerProviderValue =
 		useScrollMetadataOwnerProviderValue(scrollDirection);
-	const isFirstMetadataWriterInTree = !metadataOwnerContext[scrollDirection];
+	const isFirstMetadataWriterInTree = !metadataOwnerContext?.[scrollDirection];
 	const [metadataWriterId] = useState(() =>
 		ScrollStore.createMetadataWriterId(),
 	);
 	const [writesMetadata, setWritesMetadata] = useState(false);
 
 	const { scrollStates, panGestures, pinchGestures, ownerRouteKeys } = useMemo(
-		() => walkUpScrollGestureCoordination(context, scrollDirection),
-		[context, scrollDirection],
+		() => walkUpScrollGestureCoordination(gesturePath, scrollDirection),
+		[gesturePath, scrollDirection],
 	);
 
 	const routeKey = context?.routeKey;

package/src/shared/providers/screen/gestures/scroll-coordination/walk-up-scroll-gesture-coordination.ts

@@ -1,19 +1,18 @@
 import type { SharedValue } from "react-native-reanimated";
 import type { Direction } from "../../../../types/ownership.types";
-import { walkGestureAncestors } from "../shared/ancestors";
 import type {
-	GestureContextType,
 	PanGesture,
 	PinchGesture,
+	ScreenGestureSource,
 	ScrollGestureAxis,
 	ScrollGestureState,
 } from "../types";
 
 /** Walks up the gesture tree until it finds the owner for a specific direction. */
 function findGestureOwnerForDirection(
-	ancestors: GestureContextType[],
+	ancestors: readonly ScreenGestureSource[],
 	direction: Direction,
-): GestureContextType | null {
+): ScreenGestureSource | null {
 	for (const ancestor of ancestors) {
 		if (ancestor.claimedDirections?.[direction]) return ancestor;
 	}
@@ -28,8 +27,10 @@ const getDirectionsForAxis = (
 		? ["vertical", "vertical-inverted"]
 		: ["horizontal", "horizontal-inverted"];
 
-const collectAncestorPinchGestures = (ancestors: GestureContextType[]) => {
-	const pinchGestures: GestureContextType["pinchGesture"][] = [];
+const collectAncestorPinchGestures = (
+	ancestors: readonly ScreenGestureSource[],
+) => {
+	const pinchGestures: ScreenGestureSource["pinchGesture"][] = [];
 
 	for (const ancestor of ancestors) {
 		if (!pinchGestures.includes(ancestor.pinchGesture)) {
@@ -41,12 +42,12 @@ const collectAncestorPinchGestures = (ancestors: GestureContextType[]) => {
 };
 
 const collectAxisOwners = (
-	ancestors: GestureContextType[],
+	ancestors: readonly ScreenGestureSource[],
 	directions: readonly [Direction, Direction],
 ) => {
-	const seenOwners: GestureContextType[] = [];
-	const panGestures: GestureContextType["panGesture"][] = [];
-	const scrollStates: GestureContextType["scrollState"][] = [];
+	const seenOwners: ScreenGestureSource[] = [];
+	const panGestures: ScreenGestureSource["panGesture"][] = [];
+	const scrollStates: ScreenGestureSource["scrollState"][] = [];
 	const ownerRouteKeys: string[] = [];
 
 	for (const direction of directions) {
@@ -73,10 +74,9 @@ interface WalkUpScrollGestureCoordinationResult {
 }
 
 export function walkUpScrollGestureCoordination(
-	context: GestureContextType | null,
+	ancestors: readonly ScreenGestureSource[],
 	axis: ScrollGestureAxis,
 ): WalkUpScrollGestureCoordinationResult {
-	const ancestors = walkGestureAncestors(context);
 	const axisOwners = collectAxisOwners(ancestors, getDirectionsForAxis(axis));
 
 	return {

package/src/shared/providers/screen/gestures/shared/policy.ts

@@ -25,11 +25,11 @@ import type {
 import { computeClaimedDirections } from "../ownership/compute-claimed-directions";
 import { resolveOwnership } from "../ownership/resolve-ownership";
 import type {
-	GestureContextType,
 	PanGesturePolicy,
 	PinchGesturePolicy,
 	ScreenGestureConfig,
 	ScreenGestureParticipation,
+	ScreenGestureSource,
 } from "../types";
 import {
 	getGestureDirectionEntries,
@@ -305,12 +305,12 @@ export const resolvePinchPolicy = (
 const resolveGestureParticipation = ({
 	options,
 	isFirstKey,
-	gestureContext,
+	ancestorGestures,
 	isRemovePrevented,
 }: {
 	options: GesturePolicyOptions;
 	isFirstKey: boolean;
-	gestureContext: GestureContextType | null;
+	ancestorGestures: readonly ScreenGestureSource[];
 	isRemovePrevented: boolean;
 }): ScreenGestureParticipation => {
 	const canDismiss =
@@ -342,25 +342,25 @@ const resolveGestureParticipation = ({
 		canTrackGesture,
 		effectiveSnapPoints,
 		claimedDirections,
-		ownershipStatus: resolveOwnership(claimedDirections, gestureContext),
+		ownershipStatus: resolveOwnership(claimedDirections, ancestorGestures),
 	};
 };
 
 export const resolveScreenGestureConfig = ({
 	options,
 	isFirstKey,
-	gestureContext,
+	ancestorGestures,
 	isRemovePrevented = false,
 }: {
 	options: ScreenTransitionConfig;
 	isFirstKey: boolean;
-	gestureContext: GestureContextType | null;
+	ancestorGestures: readonly ScreenGestureSource[];
 	isRemovePrevented?: boolean;
 }): ScreenGestureConfig => {
 	const participation = resolveGestureParticipation({
 		options,
 		isFirstKey,
-		gestureContext,
+		ancestorGestures,
 		isRemovePrevented,
 	});
 	const hasSnapPoints = participation.effectiveSnapPoints.hasSnapPoints;

package/src/shared/providers/screen/gestures/types.ts

@@ -71,17 +71,20 @@ export const NO_DIRECTION_CLAIMS: DirectionClaimMap = {
 	"horizontal-inverted": null,
 };
 
-export interface GestureContextType {
+export interface ScreenGestureSource {
 	routeKey: string;
 	detectorGesture: ComposedGesture;
 	panGesture: PanGesture;
 	pinchGesture: PinchGesture;
 	scrollState: SharedValue<ScrollGestureState | null>;
-	gestureContext: GestureContextType | null;
 	claimedDirections: ClaimedDirections;
 	childDirectionClaims: SharedValue<DirectionClaimMap>;
 }
 
+export interface GestureContextType extends ScreenGestureSource {
+	ancestorGestures: readonly ScreenGestureSource[];
+}
+
 export interface ScreenGestureParticipation {
 	/** Whether this route is the first route in its stack. First routes never track gestures. */
 	isFirstKey: boolean;