react-native-screen-transitions 4.0.0 → 4.1.0-alpha.0

package/src/providers/screen/gestures/ownership/gesture-ownership-coordinator.ts

@@ -0,0 +1,252 @@
+import type { SharedValue } from "react-native-reanimated";
+import type {
+	ClaimedDirections,
+	Direction,
+} from "../../../../types/ownership.types";
+import { DIRECTIONS } from "../../../../types/ownership.types";
+import { screenTopology } from "../../topology";
+import type { ScreenTopology } from "../../topology/types";
+import type {
+	GestureOwnerMap,
+	PanGesture,
+	PinchGesture,
+	ScreenGestureSource,
+	ScrollGestureAxis,
+	ScrollGestureState,
+} from "../types";
+
+export type GestureOwnershipRegistration = {
+	screenKey: string;
+	source: ScreenGestureSource;
+	claimedDirections: ClaimedDirections;
+	effectiveClaimedDirections: ClaimedDirections;
+	owners: SharedValue<GestureOwnerMap>;
+};
+
+export type ScrollGestureCoordination = {
+	panGestures: PanGesture[];
+	pinchGestures: PinchGesture[];
+	scrollStates: SharedValue<ScrollGestureState | null>[];
+	ownerRouteKeys: string[];
+};
+
+export type GestureOwnershipCoordinator = {
+	register(registration: GestureOwnershipRegistration): void;
+	unregister(screenKey: string): void;
+	getScrollCoordination(
+		screenKey: string,
+		axis: ScrollGestureAxis,
+	): ScrollGestureCoordination;
+	subscribe(screenKey: string, listener: () => void): () => void;
+};
+
+const EMPTY_SCROLL_COORDINATION: ScrollGestureCoordination = {
+	panGestures: [],
+	pinchGestures: [],
+	scrollStates: [],
+	ownerRouteKeys: [],
+};
+
+const createEmptyOwners = (): GestureOwnerMap => ({
+	vertical: null,
+	"vertical-inverted": null,
+	horizontal: null,
+	"horizontal-inverted": null,
+});
+
+const areOwnersEqual = (left: GestureOwnerMap, right: GestureOwnerMap) =>
+	DIRECTIONS.every((direction) => left[direction] === right[direction]);
+
+const areArraysEqual = <T>(left: readonly T[], right: readonly T[]) =>
+	left.length === right.length &&
+	left.every((value, index) => value === right[index]);
+
+const areScrollCoordinationsEqual = (
+	left: ScrollGestureCoordination,
+	right: ScrollGestureCoordination,
+) =>
+	areArraysEqual(left.panGestures, right.panGestures) &&
+	areArraysEqual(left.pinchGestures, right.pinchGestures) &&
+	areArraysEqual(left.scrollStates, right.scrollStates) &&
+	areArraysEqual(left.ownerRouteKeys, right.ownerRouteKeys);
+
+const getAxisDirections = (
+	axis: ScrollGestureAxis,
+): readonly [Direction, Direction] =>
+	axis === "vertical"
+		? ["vertical", "vertical-inverted"]
+		: ["horizontal", "horizontal-inverted"];
+
+export const createGestureOwnershipCoordinator = (
+	topology: ScreenTopology,
+): GestureOwnershipCoordinator => {
+	const registrations = new Map<string, GestureOwnershipRegistration>();
+	const scrollCache = new Map<
+		string,
+		Record<ScrollGestureAxis, ScrollGestureCoordination>
+	>();
+	const listenersByScreenKey = new Map<string, Set<() => void>>();
+
+	const getNearestAncestorOwner = (screenKey: string, direction: Direction) => {
+		const visited = new Set<string>();
+		let candidate: string | null = screenKey;
+
+		while (candidate && !visited.has(candidate)) {
+			visited.add(candidate);
+			if (registrations.get(candidate)?.claimedDirections[direction]) {
+				return candidate;
+			}
+			candidate = topology.getRelationships(candidate).parentScreenKey;
+		}
+
+		return null;
+	};
+
+	const getDeepestActiveOwner = (screenKey: string, direction: Direction) => {
+		const visited = new Set<string>();
+		let candidate: string | null = screenKey;
+		let owner: string | null = null;
+		let isOrigin = true;
+
+		while (candidate && !visited.has(candidate)) {
+			visited.add(candidate);
+			const registration = registrations.get(candidate);
+			const claims = isOrigin
+				? registration?.claimedDirections
+				: registration?.effectiveClaimedDirections;
+			if (claims?.[direction]) owner = candidate;
+
+			candidate = topology.getRelationships(candidate).activeChildScreenKey;
+			isOrigin = false;
+		}
+
+		return owner;
+	};
+
+	const resolveOwners = (screenKey: string): GestureOwnerMap => {
+		const owners = createEmptyOwners();
+		for (const direction of DIRECTIONS) {
+			owners[direction] =
+				getDeepestActiveOwner(screenKey, direction) ??
+				getNearestAncestorOwner(screenKey, direction);
+		}
+		return owners;
+	};
+
+	const resolveScrollCoordination = (
+		screenKey: string,
+		axis: ScrollGestureAxis,
+	): ScrollGestureCoordination => {
+		const ownerKeys: string[] = [];
+		for (const direction of getAxisDirections(axis)) {
+			const ownerKey = getNearestAncestorOwner(screenKey, direction);
+			if (ownerKey && !ownerKeys.includes(ownerKey)) ownerKeys.push(ownerKey);
+		}
+
+		const panGestures: PanGesture[] = [];
+		const scrollStates: SharedValue<ScrollGestureState | null>[] = [];
+		for (const ownerKey of ownerKeys) {
+			const source = registrations.get(ownerKey)?.source;
+			if (!source) continue;
+			panGestures.push(source.panGesture);
+			scrollStates.push(source.scrollState);
+		}
+
+		const pinchGestures: PinchGesture[] = [];
+		const visited = new Set<string>();
+		let candidate: string | null = screenKey;
+		while (candidate && !visited.has(candidate)) {
+			visited.add(candidate);
+			const pinchGesture = registrations.get(candidate)?.source.pinchGesture;
+			if (pinchGesture && !pinchGestures.includes(pinchGesture)) {
+				pinchGestures.push(pinchGesture);
+			}
+			candidate = topology.getRelationships(candidate).parentScreenKey;
+		}
+
+		return {
+			panGestures,
+			pinchGestures,
+			scrollStates,
+			ownerRouteKeys: ownerKeys,
+		};
+	};
+
+	const notify = (screenKey: string) => {
+		for (const listener of listenersByScreenKey.get(screenKey) ?? []) {
+			listener();
+		}
+	};
+
+	const recompute = () => {
+		for (const [screenKey, registration] of registrations) {
+			const nextOwners = resolveOwners(screenKey);
+			if (!areOwnersEqual(registration.owners.get(), nextOwners)) {
+				registration.owners.set(nextOwners);
+			}
+
+			const previousScroll = scrollCache.get(screenKey);
+			const nextScroll = {
+				vertical: resolveScrollCoordination(screenKey, "vertical"),
+				horizontal: resolveScrollCoordination(screenKey, "horizontal"),
+			};
+			const vertical =
+				previousScroll &&
+				areScrollCoordinationsEqual(
+					previousScroll.vertical,
+					nextScroll.vertical,
+				)
+					? previousScroll.vertical
+					: nextScroll.vertical;
+			const horizontal =
+				previousScroll &&
+				areScrollCoordinationsEqual(
+					previousScroll.horizontal,
+					nextScroll.horizontal,
+				)
+					? previousScroll.horizontal
+					: nextScroll.horizontal;
+			if (
+				!previousScroll ||
+				vertical !== previousScroll.vertical ||
+				horizontal !== previousScroll.horizontal
+			) {
+				scrollCache.set(screenKey, { vertical, horizontal });
+				notify(screenKey);
+			}
+		}
+	};
+
+	topology.subscribeResolution(recompute);
+
+	return {
+		register: (registration) => {
+			registrations.set(registration.screenKey, registration);
+			recompute();
+		},
+		unregister: (screenKey) => {
+			if (!registrations.has(screenKey)) return;
+
+			registrations.delete(screenKey);
+			scrollCache.delete(screenKey);
+			recompute();
+			notify(screenKey);
+		},
+		getScrollCoordination: (screenKey, axis) =>
+			scrollCache.get(screenKey)?.[axis] ?? EMPTY_SCROLL_COORDINATION,
+		subscribe: (screenKey, listener) => {
+			const listeners =
+				listenersByScreenKey.get(screenKey) ?? new Set<() => void>();
+			listeners.add(listener);
+			listenersByScreenKey.set(screenKey, listeners);
+
+			return () => {
+				listeners.delete(listener);
+				if (listeners.size === 0) listenersByScreenKey.delete(screenKey);
+			};
+		},
+	};
+};
+
+export const gestureOwnershipCoordinator =
+	createGestureOwnershipCoordinator(screenTopology);

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

@@ -0,0 +1,23 @@
+import { useCallback, useSyncExternalStore } from "react";
+import type { ScrollGestureAxis } from "../types";
+import { gestureOwnershipCoordinator } from "./gesture-ownership-coordinator";
+
+export const useGestureScrollCoordination = (
+	screenKey: string | null,
+	axis: ScrollGestureAxis,
+) => {
+	const subscribe = useCallback(
+		(listener: () => void) =>
+			screenKey
+				? gestureOwnershipCoordinator.subscribe(screenKey, listener)
+				: () => {},
+		[screenKey],
+	);
+	const getSnapshot = useCallback(
+		() =>
+			gestureOwnershipCoordinator.getScrollCoordination(screenKey ?? "", axis),
+		[axis, screenKey],
+	);
+
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+};

package/src/providers/screen/gestures/ownership/use-register-gesture-ownership.ts

@@ -0,0 +1,73 @@
+import { useLayoutEffect, useMemo } from "react";
+import type { SharedValue } from "react-native-reanimated";
+import {
+	type ClaimedDirections,
+	NO_CLAIMS,
+} from "../../../../types/ownership.types";
+import { useBlankStackStore } from "../../../stack/blank-stack.provider";
+import { type BaseDescriptor, useDescriptorsStore } from "../../descriptors";
+import { resolveScreenGestureConfig } from "../shared/policy";
+import type { GestureOwnerMap, ScreenGestureSource } from "../types";
+import { gestureOwnershipCoordinator } from "./gesture-ownership-coordinator";
+import { resolveShadowingClaimDirections } from "./shadowing-claims";
+
+const getDescriptorIsFirstKey = (descriptor: BaseDescriptor): boolean => {
+	const routes = descriptor.navigation.getState()?.routes ?? [];
+	return routes.findIndex((route) => route.key === descriptor.route.key) === 0;
+};
+
+const getDescriptorClaimedDirections = (
+	descriptor: BaseDescriptor | undefined,
+): ClaimedDirections => {
+	if (!descriptor) return NO_CLAIMS;
+
+	return resolveScreenGestureConfig({
+		options: descriptor.options,
+		isFirstKey: getDescriptorIsFirstKey(descriptor),
+	}).participation.claimedDirections;
+};
+
+export const useRegisterGestureOwnership = ({
+	claimedDirections,
+	owners,
+	source,
+}: {
+	claimedDirections: ClaimedDirections;
+	owners: SharedValue<GestureOwnerMap>;
+	source: ScreenGestureSource;
+}) => {
+	const previous = useDescriptorsStore((store) => store.descriptors.previous);
+	const isClosing = useBlankStackStore(
+		(store) => store.scenesByKey[source.routeKey]?.activity === "closing",
+	);
+	const previousClaimedDirections = useMemo(
+		() => getDescriptorClaimedDirections(previous),
+		[previous],
+	);
+	const effectiveClaimedDirections = useMemo(
+		() =>
+			resolveShadowingClaimDirections({
+				isCurrentScreenClosing: isClosing,
+				currentClaimedDirections: claimedDirections,
+				previousClaimedDirections,
+			}),
+		[claimedDirections, isClosing, previousClaimedDirections],
+	);
+
+	useLayoutEffect(() => {
+		gestureOwnershipCoordinator.register({
+			screenKey: source.routeKey,
+			source,
+			claimedDirections,
+			effectiveClaimedDirections,
+			owners,
+		});
+	}, [claimedDirections, effectiveClaimedDirections, owners, source]);
+
+	useLayoutEffect(
+		() => () => {
+			gestureOwnershipCoordinator.unregister(source.routeKey);
+		},
+		[source.routeKey],
+	);
+};

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

@@ -5,12 +5,11 @@ import {
 	type ScrollGestureState,
 } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
-import { shouldDeferToChildClaim } from "../../ownership/resolve-ownership";
 import { getPanSnapAxisConfigForDirection } from "../../shared/directions";
 import { resolveRuntimeSnapPoints } from "../../shared/snap-points";
 import type {
-	DirectionClaimMap,
 	GestureDimensions,
+	GestureOwnerMap,
 	PanGestureRuntime,
 } from "../../types";
 import {
@@ -23,7 +22,6 @@ export type PanActivationAction = "activate" | "fail" | "wait";
 export type PanActivationReason =
 	| "ancestor-dismissing"
 	| "already-dragging"
-	| "child-claim"
 	| "disabled"
 	| "dismissing"
 	| "multi-touch"
@@ -51,7 +49,7 @@ interface ResolvePanActivationMoveDecisionProps {
 	initialTouch: { x: number; y: number };
 	activationState: GestureActivationState;
 	ancestorDismissing: boolean;
-	childDirectionClaims: DirectionClaimMap;
+	gestureOwners: GestureOwnerMap;
 	currentScreenKey: string;
 	scrollState: ScrollGestureState | null;
 }
@@ -147,9 +145,8 @@ const resolveOffsetFailureDecision = (
 
 const resolveDirectionGateDecision = (
 	swipeDirection: Direction | null,
-	runtime: PanGestureRuntime,
 	offset: OffsetRuleResult,
-	childDirectionClaims: DirectionClaimMap,
+	gestureOwners: GestureOwnerMap,
 	currentScreenKey: string,
 ): PanActivationDecision | null => {
 	"worklet";
@@ -162,7 +159,7 @@ const resolveDirectionGateDecision = (
 		);
 	}
 
-	if (runtime.participation.ownershipStatus[swipeDirection] !== "self") {
+	if (gestureOwners[swipeDirection] !== currentScreenKey) {
 		return createDecision(
 			"fail",
 			"ownership",
@@ -171,16 +168,6 @@ const resolveDirectionGateDecision = (
 		);
 	}
 
-	const childClaim = childDirectionClaims[swipeDirection];
-	if (shouldDeferToChildClaim(childClaim, currentScreenKey)) {
-		return createDecision(
-			"fail",
-			"child-claim",
-			swipeDirection,
-			offset.nextActivationState,
-		);
-	}
-
 	if (offset.nextActivationState !== GestureActivationState.PASSED) {
 		return createDecision(
 			"wait",
@@ -389,7 +376,7 @@ export const resolvePanActivationMoveDecision = ({
 	initialTouch,
 	activationState,
 	ancestorDismissing,
-	childDirectionClaims,
+	gestureOwners,
 	currentScreenKey,
 	scrollState,
 }: ResolvePanActivationMoveDecisionProps): PanActivationDecision => {
@@ -427,9 +414,8 @@ export const resolvePanActivationMoveDecision = ({
 	const swipeDirection = getSwipeDirection(offset);
 	const directionGateDecision = resolveDirectionGateDecision(
 		swipeDirection,
-		runtime,
 		offset,
-		childDirectionClaims,
+		gestureOwners,
 		currentScreenKey,
 	);
 	if (directionGateDecision) return directionGateDecision;

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

@@ -12,9 +12,9 @@ import type { ScreenOptionsContextValue } from "../../../options";
 import { useCurrentScreenRelationships } from "../../../use-current-screen-relationships";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
-	DirectionClaimMap,
 	GestureCompositionOwner,
 	GestureDimensions,
+	GestureOwnerMap,
 	PanGestureRuntime,
 	ScrollGestureState,
 } from "../../types";
@@ -22,7 +22,7 @@ import { resolvePanActivationMoveDecision } from "./pan-activation-decision";
 
 interface UsePanActivationProps {
 	scrollState: SharedValue<ScrollGestureState | null>;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
+	gestureOwners: SharedValue<GestureOwnerMap>;
 	runtime: SharedValue<PanGestureRuntime>;
 	screenOptions: ScreenOptionsContextValue;
 	dimensions: GestureDimensions;
@@ -31,7 +31,7 @@ interface UsePanActivationProps {
 
 export const usePanActivation = ({
 	scrollState,
-	childDirectionClaims,
+	gestureOwners,
 	runtime,
 	screenOptions,
 	dimensions,
@@ -114,7 +114,7 @@ export const usePanActivation = ({
 				initialTouch: initialTouch.get(),
 				activationState: currentActivationState,
 				ancestorDismissing: Boolean(ancestorDismissing?.get()),
-				childDirectionClaims: childDirectionClaims.get(),
+				gestureOwners: gestureOwners.get(),
 				currentScreenKey,
 				scrollState: scrollState.get(),
 			});
@@ -141,12 +141,12 @@ export const usePanActivation = ({
 		},
 		[
 			ancestorDismissing,
-			childDirectionClaims,
 			currentScreenKey,
 			dimensions,
 			gestureActivationState,
 			initialTouch,
 			pendingDirection,
+			gestureOwners,
 			runtime,
 			screenOptions,
 			scrollState,

package/src/providers/screen/gestures/pan/use-build-pan-gesture.ts

@@ -5,8 +5,8 @@ import type { SharedValue } from "react-native-reanimated";
 import { useScreenOptionsStore } from "../../options";
 import { useStableRuntimeConfig } from "../hooks/use-stable-runtime-config";
 import type {
-	DirectionClaimMap,
 	GestureCompositionOwner,
+	GestureOwnerMap,
 	PanGesture,
 	ScreenGestureConfig,
 	ScrollGestureState,
@@ -17,14 +17,14 @@ import { usePanBehavior } from "./behavior/use-pan-behavior";
 interface UseBuildPanGestureProps {
 	scrollState: SharedValue<ScrollGestureState | null>;
 	gestureConfig: ScreenGestureConfig;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
+	gestureOwners: SharedValue<GestureOwnerMap>;
 	gestureCompositionOwner: SharedValue<GestureCompositionOwner>;
 }
 
 export const useBuildPanGesture = ({
 	scrollState,
 	gestureConfig,
-	childDirectionClaims,
+	gestureOwners,
 	gestureCompositionOwner,
 }: UseBuildPanGestureProps): PanGesture => {
 	const dimensions = useWindowDimensions();
@@ -38,7 +38,7 @@ export const useBuildPanGesture = ({
 
 	const activation = usePanActivation({
 		scrollState,
-		childDirectionClaims,
+		gestureOwners,
 		runtime,
 		screenOptions,
 		dimensions,

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

@@ -11,6 +11,7 @@ import useStableCallback from "../../../../hooks/use-stable-callback";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { ScrollStore } from "../../../../stores/scroll.store";
 import { useOptionalScreenGestureStore } from "../gestures.provider";
+import { useGestureScrollCoordination } from "../ownership/use-gesture-scroll-coordination";
 import type {
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
@@ -26,7 +27,6 @@ import {
 	updateScrollGestureAxisState,
 	updateScrollMetadataAxisState,
 } from "./update-scroll-gesture-state";
-import { walkUpScrollGestureCoordination } from "./walk-up-scroll-gesture-coordination";
 
 interface ScrollGestureCoordinationProps {
 	onContentSizeChange?: (width: number, height: number) => void;
@@ -90,10 +90,9 @@ export const useScrollGestureCoordination = (
 ) => {
 	const context = useOptionalScreenGestureStore();
 	const scrollDirection = props.direction ?? "vertical";
-	const gesturePath = useMemo(
-		() => (context ? [context, ...context.ancestorGestures] : []),
-		[context],
-	);
+	const routeKey = context?.routeKey ?? null;
+	const { scrollStates, panGestures, pinchGestures, ownerRouteKeys } =
+		useGestureScrollCoordination(routeKey, scrollDirection);
 
 	const metadataOwnerContext = useOptionalScrollMetadataOwnerStore();
 	const metadataOwnerProviderValue =
@@ -104,12 +103,6 @@ export const useScrollGestureCoordination = (
 	);
 	const [writesMetadata, setWritesMetadata] = useState(false);
 
-	const { scrollStates, panGestures, pinchGestures, ownerRouteKeys } = useMemo(
-		() => walkUpScrollGestureCoordination(gesturePath, scrollDirection),
-		[gesturePath, scrollDirection],
-	);
-
-	const routeKey = context?.routeKey;
 	const metadataState = useMemo(
 		() => (routeKey ? ScrollStore.getValue(routeKey, "metadata") : null),
 		[routeKey],
@@ -174,7 +167,10 @@ export const useScrollGestureCoordination = (
 	);
 
 	const nativeGesture = useMemo(() => {
-		if (panGestures.length === 0 && pinchGestures.length === 0) return null;
+		// Ownership registrations disappear while a screen's Activity is paused.
+		// Keep its detector mounted through that gap: removing the wrapper remounts
+		// scroll children and loses state, including captured boundary measurements.
+		if (!routeKey) return null;
 
 		const setIsTouched = () => {
 			"worklet";
@@ -230,6 +226,7 @@ export const useScrollGestureCoordination = (
 
 		return gesture;
 	}, [
+		routeKey,
 		panGestures,
 		pinchGestures,
 		scrollStates,

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

@@ -24,13 +24,11 @@ import type {
 	SnapPoint,
 } from "../../../../types/screen.types";
 import { computeClaimedDirections } from "../ownership/compute-claimed-directions";
-import { resolveOwnership } from "../ownership/resolve-ownership";
 import type {
 	PanGesturePolicy,
 	PinchGesturePolicy,
 	ScreenGestureConfig,
 	ScreenGestureParticipation,
-	ScreenGestureSource,
 } from "../types";
 import {
 	getGestureDirectionEntries,
@@ -293,11 +291,9 @@ export const resolvePinchPolicy = (
 const resolveGestureParticipation = ({
 	options,
 	isFirstKey,
-	ancestorGestures,
 }: {
 	options: GesturePolicyOptions;
 	isFirstKey: boolean;
-	ancestorGestures: readonly ScreenGestureSource[];
 }): ScreenGestureParticipation => {
 	const canDismiss = resolveGestureCanDismiss({
 		isFirstKey,
@@ -325,23 +321,19 @@ const resolveGestureParticipation = ({
 		canTrackGesture,
 		effectiveSnapPoints,
 		claimedDirections,
-		ownershipStatus: resolveOwnership(claimedDirections, ancestorGestures),
 	};
 };
 
 export const resolveScreenGestureConfig = ({
 	options,
 	isFirstKey,
-	ancestorGestures,
 }: {
 	options: ScreenTransitionConfig;
 	isFirstKey: boolean;
-	ancestorGestures: readonly ScreenGestureSource[];
 }): ScreenGestureConfig => {
 	const participation = resolveGestureParticipation({
 		options,
 		isFirstKey,
-		ancestorGestures,
 	});
 	const hasSnapPoints = participation.effectiveSnapPoints.hasSnapPoints;
 

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

@@ -25,7 +25,7 @@ import type {
 } from "../../../types/gesture.types";
 import type {
 	ClaimedDirections,
-	DirectionOwnership,
+	Direction,
 } from "../../../types/ownership.types";
 import type { ScreenTransitionConfig } from "../../../types/screen.types";
 import type { EffectiveSnapPointsResult } from "./shared/snap-points";
@@ -52,19 +52,9 @@ export type {
 	ScrollMetadataState,
 };
 
-export type DirectionClaim = {
-	routeKey: string;
-	isDismissing: SharedValue<number>;
-} | null;
-
-export type DirectionClaimMap = {
-	vertical: DirectionClaim;
-	"vertical-inverted": DirectionClaim;
-	horizontal: DirectionClaim;
-	"horizontal-inverted": DirectionClaim;
-};
+export type GestureOwnerMap = Record<Direction, string | null>;
 
-export const NO_DIRECTION_CLAIMS: DirectionClaimMap = {
+export const NO_GESTURE_OWNERS: GestureOwnerMap = {
 	vertical: null,
 	"vertical-inverted": null,
 	horizontal: null,
@@ -77,13 +67,9 @@ export interface ScreenGestureSource {
 	panGesture: PanGesture;
 	pinchGesture: PinchGesture;
 	scrollState: SharedValue<ScrollGestureState | null>;
-	claimedDirections: ClaimedDirections;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
 }
 
-export interface GestureContextType extends ScreenGestureSource {
-	ancestorGestures: readonly ScreenGestureSource[];
-}
+export type GestureContextType = ScreenGestureSource;
 
 export interface ScreenGestureParticipation {
 	/** Whether this route is the first route in its stack. First routes never track gestures. */
@@ -94,7 +80,6 @@ export interface ScreenGestureParticipation {
 	canTrackGesture: boolean;
 	effectiveSnapPoints: EffectiveSnapPointsResult;
 	claimedDirections: ClaimedDirections;
-	ownershipStatus: DirectionOwnership;
 }
 
 export interface ScreenGestureConfig {