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

package/src/providers/screen/gestures/ownership/{use-walk-up-and-register-shadowing-claims.ts → gesture-ownership-bridge.tsx}

@@ -8,17 +8,16 @@ import {
 } from "../../../../types/ownership.types";
 import {
 	type BaseDescriptor,
-	useDescriptorDerivations,
-	useDescriptors,
+	useDescriptorsStore,
 } from "../../../screen/descriptors";
-import { useGestureContext } from "../gestures.provider";
-import { walkGestureAncestors } from "../shared/ancestors";
+import { useBlankStackStore } 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[];
 };
 
@@ -30,9 +29,9 @@ const findShadowedDirections = (
 ) => {
 	const shadowedDirections: Direction[] = [];
 
-	for (const dir of DIRECTIONS) {
-		if (claimedDirections[dir] && ancestorDirections[dir]) {
-			shadowedDirections.push(dir);
+	for (const direction of DIRECTIONS) {
+		if (claimedDirections[direction] && ancestorDirections[direction]) {
+			shadowedDirections.push(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,
@@ -70,8 +69,8 @@ const registerShadowingClaims = (
 
 	for (const { ancestor, directions } of shadowedAncestors) {
 		const newClaims = { ...ancestor.childDirectionClaims.get() };
-		for (const dir of directions) {
-			newClaims[dir] = { routeKey: currentScreenKey, isDismissing };
+		for (const direction of directions) {
+			newClaims[direction] = { routeKey: currentScreenKey, isDismissing };
 		}
 		ancestor.childDirectionClaims.set(newClaims);
 	}
@@ -86,10 +85,9 @@ const clearShadowingClaims = (
 		const newClaims = { ...currentClaims };
 		let needsUpdate = false;
 
-		for (const dir of directions) {
-			// Only remove claims written by this screen; a newer descendant may own it now.
-			if (currentClaims[dir]?.routeKey === currentScreenKey) {
-				newClaims[dir] = null;
+		for (const direction of directions) {
+			if (currentClaims[direction]?.routeKey === currentScreenKey) {
+				newClaims[direction] = null;
 				needsUpdate = true;
 			}
 		}
@@ -108,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;
@@ -117,67 +115,41 @@ const getDescriptorClaimedDirections = (
 	return resolveScreenGestureConfig({
 		options: descriptor.options,
 		isFirstKey: getDescriptorIsFirstKey(descriptor),
-		gestureContext,
+		ancestorGestures,
 	}).participation.claimedDirections;
 };
 
-/**
- * Registers this screen with ancestors that claim the same direction.
- *
- * Example, when C is top-most:
- * A claims vertical
- * └─ B claims horizontal
- *    └─ C claims vertical
- *
- * C walks up the tree and writes itself into A.childDirectionClaims.vertical.
- * B is skipped because it does not claim vertical.
- */
-export function useWalkUpAndRegisterShadowingClaims(
-	claimedDirections: ClaimedDirections,
-): void {
-	const parentContext = useGestureContext();
-	const { current, previous } = useDescriptors();
-	const { isTopMostScreen, currentScreenKey } = useDescriptorDerivations();
-
-	/*
-	 * We want to calculate effective claimed directions as claimedDirections is not enough for us.
-	 * What this solves is lingering claimed directions when a screen is closing.
-	 *
-	 * Overlay claims horizontal
-	 *   └─ A has no local horizontal claim
-	 *   └─ B claims horizontal (closing)
-	 *   └─ C claims horizontal (closing)
-	 *
-	 * Closing screens are still mounted, so they can still block parent gestures.
-	 * But they cannot receive touches anymore.
-	 *
-	 * So when B/C are closing and the user is really touching A, B/C should not
-	 * keep blocking the parent with their own gesture config.
-	 *
-	 * A closing screen should act like the visible screen underneath it:
-	 * - if the screen underneath claims the gesture, keep blocking the parent
-	 * - if the screen underneath does not claim it, let the parent handle it
-	 */
+function ActiveGestureOwnershipBridge() {
+	const gestureContext = useScreenGestureStore();
+	const previous = useDescriptorsStore((store) => store.previous);
+	const isCurrentScreenClosing = useBlankStackStore(
+		(store) =>
+			store.scenesByKey[gestureContext.routeKey]?.activity === "closing",
+	);
+	const {
+		claimedDirections,
+		ancestorGestures,
+		routeKey: currentScreenKey,
+	} = gestureContext;
 	const effectiveClaimedDirections = useMemo(
 		() =>
 			resolveShadowingClaimDirections({
-				currentActivity: current.activity,
+				isCurrentScreenClosing,
 				currentClaimedDirections: claimedDirections,
 				previousClaimedDirections: getDescriptorClaimedDirections(
 					previous,
-					parentContext,
+					ancestorGestures,
 				),
 			}),
-		[current.activity, claimedDirections, previous, parentContext],
+		[isCurrentScreenClosing, claimedDirections, previous, ancestorGestures],
 	);
-
 	const shadowedAncestors = useMemo(
-		() => findShadowedAncestors(parentContext, effectiveClaimedDirections),
-		[parentContext, effectiveClaimedDirections],
+		() => findShadowedAncestors(ancestorGestures, effectiveClaimedDirections),
+		[ancestorGestures, effectiveClaimedDirections],
 	);
 
 	useLayoutEffect(() => {
-		if (!isTopMostScreen || !shadowedAncestors.length) {
+		if (!shadowedAncestors.length) {
 			return;
 		}
 
@@ -186,5 +158,16 @@ export function useWalkUpAndRegisterShadowingClaims(
 		return () => {
 			clearShadowingClaims(shadowedAncestors, currentScreenKey);
 		};
-	}, [shadowedAncestors, currentScreenKey, isTopMostScreen]);
+	}, [shadowedAncestors, currentScreenKey]);
+
+	return null;
+}
+
+/** Keeps gesture ownership subscriptions attached only to participating screens. */
+export function GestureOwnershipBridge() {
+	const isTopMostScreen = useDescriptorsStore(
+		(store) => store.derivations.isTopMostScreen,
+	);
+
+	return isTopMostScreen ? <ActiveGestureOwnershipBridge /> : null;
 }

package/src/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/providers/screen/gestures/ownership/shadowing-claims.ts

@@ -1,16 +1,15 @@
 import type { ClaimedDirections } from "../../../../types/ownership.types";
-import type { StackSceneActivity } from "../../../../types/stack.types";
 
 export const resolveShadowingClaimDirections = ({
-	currentActivity,
+	isCurrentScreenClosing,
 	currentClaimedDirections,
 	previousClaimedDirections,
 }: {
-	currentActivity: StackSceneActivity | undefined;
+	isCurrentScreenClosing: boolean;
 	currentClaimedDirections: ClaimedDirections;
 	previousClaimedDirections: ClaimedDirections;
 }): ClaimedDirections => {
-	if (currentActivity === "closing") {
+	if (isCurrentScreenClosing) {
 		return previousClaimedDirections;
 	}
 

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

@@ -410,7 +410,6 @@ export const resolvePanActivationMoveDecision = ({
 		dimensions,
 		activationState,
 		activationArea: policy.gestureActivationArea,
-		responseDistance: policy.gestureResponseDistance,
 	});
 
 	const offsetFailureDecision = resolveOffsetFailureDecision(offset);

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

@@ -15,7 +15,6 @@ interface ResolveOffsetRulesProps {
 	activationState: GestureActivationState;
 	activationArea?: ResolvedGestureActivationArea;
 	dimensions: Layout;
-	responseDistance?: number;
 }
 
 type NormalizedSides = {
@@ -137,11 +136,10 @@ export function computeEdgeConstraints(
 	initialTouch: { x: number; y: number },
 	dimensions: Layout,
 	sides: NormalizedSides,
-	responseDistance?: number,
 ) {
 	"worklet";
-	const xDist = responseDistance ?? DEFAULT_EDGE_DISTANCE_HORIZONTAL;
-	const yDist = responseDistance ?? DEFAULT_EDGE_DISTANCE_VERTICAL;
+	const xDist = DEFAULT_EDGE_DISTANCE_HORIZONTAL;
+	const yDist = DEFAULT_EDGE_DISTANCE_VERTICAL;
 
 	return {
 		horizontalRight: canActivateFromStartEdge(
@@ -293,7 +291,6 @@ export const resolveOffsetRules = ({
 	activationState,
 	activationArea,
 	dimensions,
-	responseDistance,
 }: ResolveOffsetRulesProps): OffsetRuleResult => {
 	"worklet";
 
@@ -331,7 +328,7 @@ export const resolveOffsetRules = ({
 		horizontalLeft: horizontalGateLeft,
 		verticalDown: verticalGateDown,
 		verticalUp: verticalGateUp,
-	} = computeEdgeConstraints(initialTouch, dimensions, sides, responseDistance);
+	} = computeEdgeConstraints(initialTouch, dimensions, sides);
 
 	const { shouldActivate, shouldFail } = shouldActivateOrFail({
 		deltaX,

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

@@ -7,8 +7,9 @@ import { type SharedValue, useSharedValue } from "react-native-reanimated";
 import { GestureStore } from "../../../../../stores/gesture.store";
 import { GestureActivationState } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
-import { useDescriptorDerivations } from "../../../descriptors";
+import { useDescriptorsStore } from "../../../descriptors";
 import type { ScreenOptionsContextValue } from "../../../options";
+import { useCurrentScreenRelationships } from "../../../use-current-screen-relationships";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
 	DirectionClaimMap,
@@ -36,7 +37,10 @@ export const usePanActivation = ({
 	dimensions,
 	gestureCompositionOwner,
 }: UsePanActivationProps) => {
-	const { currentScreenKey, parentScreenKey } = useDescriptorDerivations();
+	const currentScreenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+	const { parentScreenKey } = useCurrentScreenRelationships();
 
 	const ancestorDismissing = useMemo(() => {
 		if (!parentScreenKey) return null;

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

@@ -1,8 +1,8 @@
 import { clamp, type SharedValue } from "react-native-reanimated";
 import { scheduleOnRN } from "react-native-worklets";
-import { EPSILON, FALSE, TRUE } from "../../../../../constants";
+import { EPSILON, TRUE } from "../../../../../constants";
+import { emitMotionStart } from "../../../../../stores/animation.store";
 import { animateToProgress } from "../../../../../utils/animation/animate-to-progress";
-import { emit } from "../../../../../utils/animation/emit";
 import {
 	normalizeGestureTranslation,
 	resolveGestureVelocity,
@@ -30,16 +30,7 @@ export const startPanBase = (runtime: PanGestureRuntime) => {
 		stores: { gestures, animations },
 	} = runtime;
 
-	const wasSettling = gestures.settling.get();
-	const hasResidualGesture =
-		Math.abs(gestures.normX.get()) > EPSILON ||
-		Math.abs(gestures.normY.get()) > EPSILON ||
-		Math.abs(gestures.normScale.get()) > EPSILON ||
-		Math.abs(gestures.rotation.get()) > EPSILON;
-
-	if (!wasSettling || !hasResidualGesture) {
-		emit(animations.willAnimate, TRUE, FALSE);
-	}
+	emitMotionStart(animations);
 
 	gestures.dragging.set(TRUE);
 	gestures.dismissing.set(0);
@@ -99,7 +90,6 @@ export const trackPanGesture = (
 export const finalizePanRelease = (
 	release: PanReleaseResult,
 	runtime: PanGestureRuntime,
-	dismissScreen: ((finished: boolean) => void) | undefined,
 	dimensions: GestureDimensions,
 	rawEvent: PanGestureEvent,
 	requestDismiss?: () => void,
@@ -134,6 +124,9 @@ export const finalizePanRelease = (
 		system.targetProgress.set(plan.commitProgress);
 	}
 
+	const progressAlreadyAtTarget =
+		Math.abs(animations.transitionProgress.get() - plan.target) <= EPSILON;
+
 	if (canDriveRelease && plan.shouldDismiss) {
 		snapshotGestureHandoff(gestures, {
 			velocity: plan.handoffVelocity,
@@ -143,6 +136,8 @@ export const finalizePanRelease = (
 	resetPanGestureValues({
 		plan,
 		gestures,
+		animations,
+		completeMotion: !plan.shouldDismiss && progressAlreadyAtTarget,
 		updateLifecycle: canDriveRelease,
 	});
 
@@ -150,27 +145,23 @@ export const finalizePanRelease = (
 		return;
 	}
 
-	const progressAlreadyAtTarget =
-		Math.abs(animations.transitionProgress.get() - plan.target) <= EPSILON;
-
 	if (!plan.shouldDismiss && progressAlreadyAtTarget) {
 		system.targetProgress.set(plan.target);
-		animations.progressAnimating.set(FALSE);
 		return;
 	}
 
-	if (plan.shouldDismiss && requestDismiss) {
-		scheduleOnRN(requestDismiss);
-	}
-
 	animateToProgress({
 		target: plan.target,
-		onAnimationFinish: plan.shouldDismiss ? dismissScreen : undefined,
 		spec: plan.transitionSpec,
 		emitWillAnimate: false,
 		markEntering: false,
 		targetProgress: system.targetProgress,
+		animationProgress: system.animationProgress,
 		animations,
 		initialVelocity: plan.progressVelocity,
 	});
+
+	if (plan.shouldDismiss && requestDismiss) {
+		scheduleOnRN(requestDismiss);
+	}
 };

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

@@ -1,4 +1,5 @@
 import { FALSE, TRUE } from "../../../../../constants";
+import type { AnimationStoreMap } from "../../../../../stores/animation.store";
 import type { GestureStoreMap } from "../../../../../stores/gesture.store";
 import { animateMany } from "../../shared/reset";
 import {
@@ -10,12 +11,16 @@ import type { PanReleasePlan } from "../../types";
 interface ResetPanGestureValuesProps {
 	plan: PanReleasePlan;
 	gestures: GestureStoreMap;
+	animations?: AnimationStoreMap;
+	completeMotion?: boolean;
 	updateLifecycle?: boolean;
 }
 
 export const resetPanGestureValues = ({
 	plan,
 	gestures,
+	animations,
+	completeMotion = false,
 	updateLifecycle = true,
 }: ResetPanGestureValuesProps) => {
 	"worklet";
@@ -25,11 +30,19 @@ 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);
+			animations?.progressSettled.set(TRUE);
+		}
 	};
 
+	if (animations && updateLifecycle && !plan.shouldDismiss) {
+		animations.progressAnimating.set(TRUE);
+		animations.progressSettled.set(FALSE);
+	}
+
 	clearRawPanValues(gestures);
 
 	if (updateLifecycle) {

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

@@ -31,7 +31,7 @@ export const usePanBehavior = (
 	gestureCompositionOwner: SharedValue<GestureCompositionOwner>,
 	pendingDirection: SharedValue<Direction | null>,
 ): PanBehavior => {
-	const { dismissScreen, requestDismiss } = useNavigationHelpers();
+	const { requestDismiss } = useNavigationHelpers();
 	const { withSensitivity, resetSensitivity } =
 		usePanGestureSensitivity(screenOptions);
 
@@ -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");
@@ -109,7 +108,6 @@ export const usePanBehavior = (
 			finalizePanRelease(
 				release,
 				latestRuntime,
-				dismissScreen,
 				dimensions,
 				rawEvent,
 				requestDismiss,
@@ -124,7 +122,6 @@ export const usePanBehavior = (
 			runtime,
 			screenOptions,
 			dimensions,
-			dismissScreen,
 			requestDismiss,
 			withSensitivity,
 			gestureCompositionOwner,

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

@@ -2,7 +2,7 @@ import { useMemo } from "react";
 import { useWindowDimensions } from "react-native";
 import { Gesture } from "react-native-gesture-handler";
 import type { SharedValue } from "react-native-reanimated";
-import { useScreenOptionsContext } from "../../options";
+import { useScreenOptionsStore } from "../../options";
 import { useStableRuntimeConfig } from "../hooks/use-stable-runtime-config";
 import type {
 	DirectionClaimMap,
@@ -29,7 +29,7 @@ export const useBuildPanGesture = ({
 }: UseBuildPanGestureProps): PanGesture => {
 	const dimensions = useWindowDimensions();
 	const { participation, pan: policy } = gestureConfig;
-	const screenOptions = useScreenOptionsContext();
+	const screenOptions = useScreenOptionsStore();
 
 	const runtime = useStableRuntimeConfig({
 		participation,