react-native-screen-transitions 4.0.0-alpha.7 → 4.0.0-alpha.9

package/src/providers/screen/gestures/pan/behavior/pan-release.ts

@@ -13,8 +13,12 @@ import {
 	resolveGestureSnapTransitionSpec,
 } from "../../shared/release";
 import {
+	getStepSnapProgressVelocityScale,
 	primeRuntimeSnapPoint,
 	resolveRuntimeGestureSnapPoints,
+	resolveRuntimeGestureSnapTargets,
+	resolveStepSnapProgress,
+	resolveStepSnapTargets,
 } from "../../shared/snap-points";
 import { determineDismissal, determineSnapTarget } from "../../shared/targets";
 import type {
@@ -31,7 +35,7 @@ const resolvePanReleaseVelocity = (
 	velocityNormY: number,
 ) => {
 	"worklet";
-	const activeGesture = runtime.stores.gestures.active.get();
+	const activeGesture = runtime.stores.gestures.initiator.get();
 
 	switch (activeGesture) {
 		case "horizontal":
@@ -47,7 +51,7 @@ const resolvePanReleaseVelocity = (
 
 const resolveActivePanSnapAxis = (runtime: PanGestureRuntime) => {
 	"worklet";
-	const activeGesture = runtime.stores.gestures.active.get();
+	const activeGesture = runtime.stores.gestures.initiator.get();
 
 	return isResolvedPanGestureDirection(activeGesture)
 		? getPanSnapAxisConfigForDirection(
@@ -80,6 +84,8 @@ const getPanSnapReleaseProgress = ({
 	activeAxis,
 	minSnapPoint,
 	maxSnapPoint,
+	snapPoints,
+	sheetSnapBehavior,
 }: {
 	runtime: PanGestureRuntime;
 	event: PanGestureEvent;
@@ -87,6 +93,8 @@ const getPanSnapReleaseProgress = ({
 	activeAxis: NonNullable<ReturnType<typeof resolveActivePanSnapAxis>>;
 	minSnapPoint: number;
 	maxSnapPoint: number;
+	snapPoints: number[];
+	sheetSnapBehavior: PanGestureRuntime["policy"]["sheetSnapBehavior"];
 }) => {
 	"worklet";
 	const isHorizontal = activeAxis.axis === "horizontal";
@@ -95,9 +103,17 @@ const getPanSnapReleaseProgress = ({
 		: event.translationY;
 	const axisDimension = isHorizontal ? dimensions.width : dimensions.height;
 	const axisProgress = axisTranslation / Math.max(1, axisDimension);
+	const signedProgressDelta = activeAxis.config.progressSign * axisProgress;
+	if (sheetSnapBehavior === "step") {
+		return resolveStepSnapProgress({
+			baseline: runtime.stores.gestures.internal.progressBaseline.get(),
+			normalizedDelta: signedProgressDelta,
+			snapPoints,
+		});
+	}
 	const progress =
 		runtime.stores.gestures.internal.progressBaseline.get() +
-		activeAxis.config.progressSign * axisProgress;
+		signedProgressDelta;
 
 	return clamp(progress, minSnapPoint, maxSnapPoint);
 };
@@ -180,6 +196,24 @@ export const resolveSnapPanRelease = (
 	);
 	const { resolvedSnapPoints, resolvedMinSnapPoint, resolvedMaxSnapPoint } =
 		resolveRuntimeGestureSnapPoints(runtime);
+	const allSnapTargets = resolveRuntimeGestureSnapTargets(runtime);
+	const axisTranslation =
+		activeAxis.axis === "horizontal" ? event.translationX : event.translationY;
+	const progressDirection =
+		activeAxis.config.progressSign * axisTranslation || -snapVelocity;
+	const releaseSnapPoints =
+		policy.sheetSnapBehavior === "step"
+			? resolveStepSnapTargets({
+					baseline: runtime.stores.gestures.internal.progressBaseline.get(),
+					direction: progressDirection,
+					snapPoints: allSnapTargets,
+				})
+			: resolvedSnapPoints;
+	const canDismissToReleaseTarget =
+		participation.canDismiss &&
+		(policy.gestureSnapLocked ||
+			policy.sheetSnapBehavior === "continuous" ||
+			releaseSnapPoints.includes(0));
 	const currentProgress = getPanSnapReleaseProgress({
 		runtime,
 		event,
@@ -187,6 +221,8 @@ export const resolveSnapPanRelease = (
 		activeAxis,
 		minSnapPoint: resolvedMinSnapPoint,
 		maxSnapPoint: resolvedMaxSnapPoint,
+		snapPoints: allSnapTargets,
+		sheetSnapBehavior: policy.sheetSnapBehavior,
 	});
 	const result = determineSnapTarget({
 		currentProgress,
@@ -195,24 +231,27 @@ export const resolveSnapPanRelease = (
 					runtime.stores.gestures.internal.lockedSnapPoint.get() ??
 						resolvedMaxSnapPoint,
 				]
-			: resolvedSnapPoints,
+			: releaseSnapPoints,
 		velocity: snapVelocity,
 		dimension: axisDimension,
 		velocityFactor: policy.gestureSnapVelocityImpact,
-		canDismiss: participation.canDismiss,
+		canDismiss: canDismissToReleaseTarget,
 	});
 
 	const shouldDismiss = participation.canDismiss && result.shouldDismiss;
 	const target = shouldDismiss ? 0 : result.targetProgress;
+	const progressVelocityScale =
+		policy.sheetSnapBehavior === "step" && !policy.gestureSnapLocked
+			? getStepSnapProgressVelocityScale(releaseSnapPoints)
+			: 1;
 
 	return {
 		target,
 		shouldDismiss,
 		initialVelocity: getProgressVelocityTowardTarget({
-			handoffVelocity: getPanReleaseHandoffVelocity(
-				axisVelocity,
-				axisDimension,
-			),
+			handoffVelocity:
+				getPanReleaseHandoffVelocity(axisVelocity, axisDimension) *
+				progressVelocityScale,
 			target,
 			currentProgress,
 		}),

package/src/providers/screen/gestures/pan/behavior/pan-reset.ts

@@ -30,8 +30,7 @@ export const resetPanGestureValues = ({
 			return;
 		}
 
-		gestures.active.set(null);
-		gestures.direction.set(null);
+		gestures.initiator.set(null);
 		gestures.settling.set(FALSE);
 		if (completeMotion) {
 			animations?.progressAnimating.set(FALSE);

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

@@ -47,8 +47,7 @@ export const usePanBehavior = (
 
 		const direction = pendingDirection.get();
 		if (direction) {
-			latestRuntime.stores.gestures.active.set(direction);
-			latestRuntime.stores.gestures.direction.set(direction);
+			latestRuntime.stores.gestures.initiator.set(direction);
 		}
 		pendingDirection.set(null);
 		gestureCompositionOwner.set("pan");

package/src/providers/screen/gestures/pinch/behavior/pinch-lifecycle.ts

@@ -24,8 +24,7 @@ export const startPinchBase = (runtime: PinchGestureRuntime) => {
 	gestures.dragging.set(TRUE);
 	gestures.dismissing.set(0);
 	gestures.settling.set(0);
-	gestures.active.set(null);
-	gestures.direction.set(null);
+	gestures.initiator.set(null);
 	gestures.velocity.set(0);
 	clearTransformTrackingValues(gestures);
 	gestures.internal.progressBaseline.set(animations.transitionProgress.get());
@@ -47,8 +46,8 @@ export const trackPinchGesture = (
 	gestures.raw.scale.set(rawScale);
 	gestures.raw.normScale.set(rawNormScale);
 
-	if (gestures.active.get() === null) {
-		gestures.active.set(
+	if (gestures.initiator.get() === null) {
+		gestures.initiator.set(
 			normScale < 0 ? "pinch-in" : normScale > 0 ? "pinch-out" : null,
 		);
 	}

package/src/providers/screen/gestures/pinch/behavior/pinch-release.ts

@@ -10,8 +10,12 @@ import {
 	resolveGestureSnapTransitionSpec,
 } from "../../shared/release";
 import {
+	getStepSnapProgressVelocityScale,
 	primeRuntimeSnapPoint,
 	resolveRuntimeGestureSnapPoints,
+	resolveRuntimeGestureSnapTargets,
+	resolveStepSnapProgress,
+	resolveStepSnapTargets,
 } from "../../shared/snap-points";
 import { determineSnapTarget } from "../../shared/targets";
 import type {
@@ -56,11 +60,13 @@ const getPinchSnapReleaseProgress = ({
 	normalizedScale,
 	minSnapPoint,
 	maxSnapPoint,
+	snapPoints,
 }: {
 	runtime: PinchGestureRuntime;
 	normalizedScale: number;
 	minSnapPoint: number;
 	maxSnapPoint: number;
+	snapPoints: number[];
 }) => {
 	"worklet";
 	const pinchDirection = getPinchSnapDirection(normalizedScale);
@@ -74,6 +80,13 @@ const getPinchSnapReleaseProgress = ({
 		snapDirections.collapse === pinchDirection
 			? -Math.abs(normalizedScale)
 			: Math.abs(normalizedScale);
+	if (runtime.policy.sheetSnapBehavior === "step") {
+		return resolveStepSnapProgress({
+			baseline: runtime.stores.gestures.internal.progressBaseline.get(),
+			normalizedDelta: progressDelta,
+			snapPoints,
+		});
+	}
 
 	return clamp(
 		runtime.stores.gestures.internal.progressBaseline.get() + progressDelta,
@@ -141,11 +154,34 @@ export const resolveSnapPinchRelease = (
 
 	const { resolvedSnapPoints, resolvedMinSnapPoint, resolvedMaxSnapPoint } =
 		resolveRuntimeGestureSnapPoints(runtime);
+	const allSnapTargets = resolveRuntimeGestureSnapTargets(runtime);
+	const snapVelocity = getPinchSnapVelocity(event, runtime, normalizedScale);
+	const pinchDirection = getPinchSnapDirection(normalizedScale);
+	const progressDirection =
+		pinchDirection && policy.snapDirections
+			? policy.snapDirections.collapse === pinchDirection
+				? -1
+				: 1
+			: -snapVelocity;
+	const releaseSnapPoints =
+		policy.sheetSnapBehavior === "step"
+			? resolveStepSnapTargets({
+					baseline: runtime.stores.gestures.internal.progressBaseline.get(),
+					direction: progressDirection,
+					snapPoints: allSnapTargets,
+				})
+			: resolvedSnapPoints;
+	const canDismissToReleaseTarget =
+		participation.canDismiss &&
+		(policy.gestureSnapLocked ||
+			policy.sheetSnapBehavior === "continuous" ||
+			releaseSnapPoints.includes(0));
 	const currentProgress = getPinchSnapReleaseProgress({
 		runtime,
 		normalizedScale,
 		minSnapPoint: resolvedMinSnapPoint,
 		maxSnapPoint: resolvedMaxSnapPoint,
+		snapPoints: allSnapTargets,
 	});
 
 	const result = determineSnapTarget({
@@ -155,16 +191,21 @@ export const resolveSnapPinchRelease = (
 					runtime.stores.gestures.internal.lockedSnapPoint.get() ??
 						resolvedMaxSnapPoint,
 				]
-			: resolvedSnapPoints,
-		velocity: getPinchSnapVelocity(event, runtime, normalizedScale),
+			: releaseSnapPoints,
+		velocity: snapVelocity,
 		dimension: 1,
 		velocityFactor: policy.gestureSnapVelocityImpact,
-		canDismiss: participation.canDismiss,
+		canDismiss: canDismissToReleaseTarget,
 	});
 
 	const shouldDismiss = participation.canDismiss && result.shouldDismiss;
 	const target = shouldDismiss ? 0 : result.targetProgress;
-	const progressVelocity = getPinchReleaseHandoffVelocity(event.velocity);
+	const progressVelocityScale =
+		policy.sheetSnapBehavior === "step" && !policy.gestureSnapLocked
+			? getStepSnapProgressVelocityScale(releaseSnapPoints)
+			: 1;
+	const progressVelocity =
+		getPinchReleaseHandoffVelocity(event.velocity) * progressVelocityScale;
 	const handoffVelocity = getPinchReleaseHandoffVelocity(
 		event.velocity,
 		policy.gestureReleaseVelocityScale,

package/src/providers/screen/gestures/pinch/behavior/pinch-reset.ts

@@ -32,8 +32,7 @@ export const resetPinchGestureValues = ({
 		}
 
 		clearFocalPoint(gestures);
-		gestures.active.set(null);
-		gestures.direction.set(null);
+		gestures.initiator.set(null);
 		gestures.settling.set(FALSE);
 		animations?.progressAnimating.set(FALSE);
 		animations?.progressSettled.set(TRUE);

package/src/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/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/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/providers/screen/gestures/shared/policy.ts

@@ -8,9 +8,9 @@ import {
 	DEFAULT_GESTURE_TRACKING,
 	DEFAULT_GESTURE_VELOCITY_IMPACT,
 	DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR,
+	DEFAULT_SHEET_SNAP_BEHAVIOR,
 } from "../../../../constants";
 import type {
-	GestureActivationArea,
 	GestureDirectionActivationArea,
 	GestureDirectionEntry,
 	GestureDirectionOption,
@@ -20,16 +20,17 @@ import type {
 	GestureTracking,
 	ScreenTransitionConfig,
 	SheetScrollGestureBehavior,
+	SheetSnapBehavior,
 	SnapPoint,
 } from "../../../../types/screen.types";
 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,
@@ -43,17 +44,15 @@ import {
 import { validateSnapPoints } from "./snap-points";
 
 export type GesturePolicyOptions = {
-	expandViaScrollView?: boolean;
-	gestureActivationArea?: GestureActivationArea;
 	gestureDirection?: GestureDirectionOption;
 	gestureEnabled?: boolean;
 	gestureTracking?: GestureTracking;
 	gestureReleaseVelocityScale?: number;
-	gestureResponseDistance?: number;
 	gestureSensitivity?: number;
 	gestureSnapLocked?: boolean;
 	gestureSnapVelocityImpact?: number;
 	gestureVelocityImpact?: number;
+	sheetSnapBehavior?: SheetSnapBehavior;
 	sheetScrollGestureBehavior?: SheetScrollGestureBehavior;
 	snapPoints?: SnapPoint[];
 	transitionSpec?: ScreenTransitionConfig["transitionSpec"];
@@ -138,14 +137,12 @@ const resolveConfiguredGestureActivationArea = (
 };
 
 const resolveGestureActivationArea = (
-	options: GesturePolicyOptions,
 	gestureDirection: GestureDirectionOption,
 	hasSnapPoints: boolean,
 ): ResolvedGestureActivationArea => {
 	"worklet";
 	return (
 		resolveConfiguredGestureActivationArea(gestureDirection, hasSnapPoints) ??
-		options.gestureActivationArea ??
 		DEFAULT_GESTURE_ACTIVATION_AREA
 	);
 };
@@ -158,6 +155,7 @@ const resolveCommonGesturePolicy = (options: GesturePolicyOptions) => {
 		gestureSnapVelocityImpact:
 			options.gestureSnapVelocityImpact ?? DEFAULT_GESTURE_SNAP_VELOCITY_IMPACT,
 		gestureSnapLocked: options.gestureSnapLocked ?? DEFAULT_GESTURE_SNAP_LOCKED,
+		sheetSnapBehavior: options.sheetSnapBehavior ?? DEFAULT_SHEET_SNAP_BEHAVIOR,
 		gestureReleaseVelocityScale:
 			options.gestureReleaseVelocityScale ??
 			DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
@@ -169,17 +167,9 @@ function resolvePolicySheetScrollGestureBehavior(
 	options: GesturePolicyOptions,
 ): SheetScrollGestureBehavior {
 	"worklet";
-	const explicitBehavior = options.sheetScrollGestureBehavior;
-	if (explicitBehavior) {
-		return explicitBehavior;
-	}
-
-	const legacyBehavior = options.expandViaScrollView;
-	if (legacyBehavior !== undefined) {
-		return legacyBehavior ? "expand-and-collapse" : "collapse-only";
-	}
-
-	return DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR;
+	return (
+		options.sheetScrollGestureBehavior ?? DEFAULT_SHEET_SCROLL_GESTURE_BEHAVIOR
+	);
 }
 
 const resolvePinchDirections = (
@@ -273,13 +263,11 @@ export const resolvePanPolicy = (
 		gestureVelocityImpact:
 			options.gestureVelocityImpact ?? DEFAULT_GESTURE_VELOCITY_IMPACT,
 		gestureActivationArea: resolveGestureActivationArea(
-			options,
 			gestureDirection,
 			hasSnapPoints,
 		),
 		sheetScrollGestureBehavior:
 			resolvePolicySheetScrollGestureBehavior(options),
-		gestureResponseDistance: options.gestureResponseDistance,
 	};
 };
 
@@ -305,20 +293,16 @@ export const resolvePinchPolicy = (
 const resolveGestureParticipation = ({
 	options,
 	isFirstKey,
-	gestureContext,
-	isRemovePrevented,
+	ancestorGestures,
 }: {
 	options: GesturePolicyOptions;
 	isFirstKey: boolean;
-	gestureContext: GestureContextType | null;
-	isRemovePrevented: boolean;
+	ancestorGestures: readonly ScreenGestureSource[];
 }): ScreenGestureParticipation => {
-	const canDismiss =
-		!isRemovePrevented &&
-		resolveGestureCanDismiss({
-			isFirstKey,
-			gestureEnabled: options.gestureEnabled,
-		});
+	const canDismiss = resolveGestureCanDismiss({
+		isFirstKey,
+		gestureEnabled: options.gestureEnabled,
+	});
 	const effectiveSnapPoints = validateSnapPoints({
 		snapPoints: options.snapPoints,
 		canDismiss,
@@ -337,31 +321,27 @@ const resolveGestureParticipation = ({
 
 	return {
 		isFirstKey,
-		isRemovePrevented,
 		canDismiss,
 		canTrackGesture,
 		effectiveSnapPoints,
 		claimedDirections,
-		ownershipStatus: resolveOwnership(claimedDirections, gestureContext),
+		ownershipStatus: resolveOwnership(claimedDirections, ancestorGestures),
 	};
 };
 
 export const resolveScreenGestureConfig = ({
 	options,
 	isFirstKey,
-	gestureContext,
-	isRemovePrevented = false,
+	ancestorGestures,
 }: {
 	options: ScreenTransitionConfig;
 	isFirstKey: boolean;
-	gestureContext: GestureContextType | null;
-	isRemovePrevented?: boolean;
+	ancestorGestures: readonly ScreenGestureSource[];
 }): ScreenGestureConfig => {
 	const participation = resolveGestureParticipation({
 		options,
 		isFirstKey,
-		gestureContext,
-		isRemovePrevented,
+		ancestorGestures,
 	});
 	const hasSnapPoints = participation.effectiveSnapPoints.hasSnapPoints;
 
@@ -373,14 +353,11 @@ export const resolveScreenGestureConfig = ({
 };
 
 function resolveRuntimeCanDismiss(
-	participation: Pick<
-		ScreenGestureParticipation,
-		"isFirstKey" | "isRemovePrevented" | "canDismiss"
-	>,
+	participation: Pick<ScreenGestureParticipation, "isFirstKey" | "canDismiss">,
 	options: GesturePolicyOptions,
 ) {
 	"worklet";
-	if (participation.isFirstKey || participation.isRemovePrevented) {
+	if (participation.isFirstKey) {
 		return false;
 	}