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

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

@@ -10,7 +10,6 @@ interface CalculateProgressProps {
 	event: PanGestureEvent;
 	dimensions: { width: number; height: number };
 	directions: GestureDirections;
-	gestureReleaseVelocityScale?: number;
 }
 
 type GestureAxisCandidate = {
@@ -32,25 +31,28 @@ export const toProgressVelocity = (
 };
 
 /**
- * Converts normalized pan velocity into a 0-1 scalar for interpolators.
+ * Converts normalized gesture velocity into a 0-1 scalar for interpolators.
  *
  * `1` means the velocity reached or exceeded the library's full-velocity
  * threshold, not a physical maximum for the device.
  */
+export const resolveGestureVelocityMagnitude = (velocity: number) => {
+	"worklet";
+
+	return Math.min(
+		1,
+		Math.abs(velocity) / FULL_GESTURE_VELOCITY_PROGRESS_PER_SECOND,
+	);
+};
+
 export const resolveGestureVelocity = (
 	velocityNormX: number,
 	velocityNormY: number,
 ) => {
 	"worklet";
 
-	const dominantVelocity = Math.max(
-		Math.abs(velocityNormX),
-		Math.abs(velocityNormY),
-	);
-
-	return Math.min(
-		1,
-		dominantVelocity / FULL_GESTURE_VELOCITY_PROGRESS_PER_SECOND,
+	return resolveGestureVelocityMagnitude(
+		Math.max(Math.abs(velocityNormX), Math.abs(velocityNormY)),
 	);
 };
 
@@ -85,7 +87,6 @@ const getPanAxisCandidate = (
 	translationTowardDismiss: number,
 	velocityTowardDismiss: number,
 	screenSize: number,
-	gestureReleaseVelocityScale?: number,
 ): GestureAxisCandidate | null => {
 	"worklet";
 	if (!isEnabled || translationTowardDismiss <= 0) {
@@ -97,7 +98,6 @@ const getPanAxisCandidate = (
 		velocityContribution: getPanReleaseHandoffVelocity(
 			velocityTowardDismiss,
 			screenSize,
-			gestureReleaseVelocityScale,
 		),
 	};
 };
@@ -116,11 +116,7 @@ const collectPanAxisCandidates = ({
 	event,
 	dimensions,
 	directions,
-	gestureReleaseVelocityScale,
-}: Pick<
-	CalculateProgressProps,
-	"event" | "dimensions" | "directions" | "gestureReleaseVelocityScale"
->) => {
+}: Pick<CalculateProgressProps, "event" | "dimensions" | "directions">) => {
 	"worklet";
 	const candidates: GestureAxisCandidate[] = [];
 
@@ -131,7 +127,6 @@ const collectPanAxisCandidates = ({
 			event.translationX,
 			event.velocityX,
 			dimensions.width,
-			gestureReleaseVelocityScale,
 		),
 	);
 	pushPanAxisCandidate(
@@ -141,7 +136,6 @@ const collectPanAxisCandidates = ({
 			-event.translationX,
 			-event.velocityX,
 			dimensions.width,
-			gestureReleaseVelocityScale,
 		),
 	);
 	pushPanAxisCandidate(
@@ -151,7 +145,6 @@ const collectPanAxisCandidates = ({
 			event.translationY,
 			event.velocityY,
 			dimensions.height,
-			gestureReleaseVelocityScale,
 		),
 	);
 	pushPanAxisCandidate(
@@ -161,7 +154,6 @@ const collectPanAxisCandidates = ({
 			-event.translationY,
 			-event.velocityY,
 			dimensions.height,
-			gestureReleaseVelocityScale,
 		),
 	);
 
@@ -190,21 +182,15 @@ const getDominantPanCandidateVelocity = (
 const getFallbackPanReleaseVelocityMagnitude = ({
 	event,
 	dimensions,
-	gestureReleaseVelocityScale,
-}: Pick<
-	CalculateProgressProps,
-	"event" | "dimensions" | "gestureReleaseVelocityScale"
->) => {
+}: Pick<CalculateProgressProps, "event" | "dimensions">) => {
 	"worklet";
 	const normalizedVelocityX = getPanReleaseHandoffVelocity(
 		event.velocityX,
 		dimensions.width,
-		gestureReleaseVelocityScale,
 	);
 	const normalizedVelocityY = getPanReleaseHandoffVelocity(
 		event.velocityY,
 		dimensions.height,
-		gestureReleaseVelocityScale,
 	);
 
 	return Math.max(Math.abs(normalizedVelocityX), Math.abs(normalizedVelocityY));
@@ -232,11 +218,10 @@ export const getPanReleaseProgressVelocity = ({
 	event,
 	dimensions,
 	directions,
-	gestureReleaseVelocityScale,
 }: CalculateProgressProps) => {
 	"worklet";
 
-	const currentProgress = animations.progress.get();
+	const currentProgress = animations.transitionProgress.get();
 	const targetProgress = shouldDismiss ? 0 : 1;
 	const progressDelta = targetProgress - currentProgress;
 
@@ -247,7 +232,6 @@ export const getPanReleaseProgressVelocity = ({
 			event,
 			dimensions,
 			directions,
-			gestureReleaseVelocityScale,
 		}),
 	);
 	const progressVelocityMagnitude =
@@ -255,7 +239,6 @@ export const getPanReleaseProgressVelocity = ({
 		getFallbackPanReleaseVelocityMagnitude({
 			event,
 			dimensions,
-			gestureReleaseVelocityScale,
 		});
 
 	return progressDirection * progressVelocityMagnitude;

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

@@ -1,7 +1,6 @@
 import {
 	DEFAULT_GESTURE_ACTIVATION_AREA,
 	DEFAULT_GESTURE_DIRECTION,
-	DEFAULT_GESTURE_PROGRESS_MODE,
 	DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
 	DEFAULT_GESTURE_SENSITIVITY,
 	DEFAULT_GESTURE_SNAP_LOCKED,
@@ -15,7 +14,6 @@ import type {
 	GestureDirectionActivationArea,
 	GestureDirectionEntry,
 	GestureDirectionOption,
-	GestureProgressMode,
 	ResolvedGestureActivationArea,
 } from "../../../../types/gesture.types";
 import type {
@@ -24,7 +22,6 @@ import type {
 	SheetScrollGestureBehavior,
 	SnapPoint,
 } from "../../../../types/screen.types";
-import { resolveGestureProgressMode } from "../../../../utils/gesture-progress-mode";
 import { computeClaimedDirections } from "../ownership/compute-claimed-directions";
 import { resolveOwnership } from "../ownership/resolve-ownership";
 import type {
@@ -49,9 +46,7 @@ export type GesturePolicyOptions = {
 	expandViaScrollView?: boolean;
 	gestureActivationArea?: GestureActivationArea;
 	gestureDirection?: GestureDirectionOption;
-	gestureDrivesProgress?: boolean;
 	gestureEnabled?: boolean;
-	gestureProgressMode?: GestureProgressMode;
 	gestureTracking?: GestureTracking;
 	gestureReleaseVelocityScale?: number;
 	gestureResponseDistance?: number;
@@ -155,19 +150,9 @@ const resolveGestureActivationArea = (
 	);
 };
 
-function resolveGestureProgressModePolicy(options: GesturePolicyOptions) {
-	"worklet";
-	return resolveGestureProgressMode({
-		gestureProgressMode: options.gestureProgressMode,
-		gestureDrivesProgress: options.gestureDrivesProgress,
-		fallback: DEFAULT_GESTURE_PROGRESS_MODE,
-	});
-}
-
 const resolveCommonGesturePolicy = (options: GesturePolicyOptions) => {
 	"worklet";
 	return {
-		gestureProgressMode: resolveGestureProgressModePolicy(options),
 		gestureSensitivity:
 			options.gestureSensitivity ?? DEFAULT_GESTURE_SENSITIVITY,
 		gestureSnapVelocityImpact:

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

@@ -1,6 +1,4 @@
 import type { SharedValue } from "react-native-reanimated";
-import { FALSE } from "../../../../constants";
-import type { GestureStoreMap } from "../../../../stores/gesture.store";
 import type { AnimationConfig } from "../../../../types/animation.types";
 import {
 	animate,
@@ -10,12 +8,18 @@ import {
 
 type ResetSpringSpec = SpringAnimationConfig & { velocity?: number };
 
+type AnimateManyJob = {
+	value: SharedValue<number>;
+	toValue: number;
+	velocity?: number;
+};
+
 const isResetSpringSpec = (spec?: AnimationConfig): spec is ResetSpringSpec => {
 	"worklet";
 	return isSpringAnimationConfig(spec);
 };
 
-export const getGestureResetSpec = (
+const getGestureResetSpec = (
 	spec?: AnimationConfig,
 	velocity?: number,
 ): AnimationConfig | undefined => {
@@ -34,7 +38,7 @@ export const getGestureResetSpec = (
 	return { ...resetSpec, velocity };
 };
 
-export const animateResetValue = (
+const animateResetValue = (
 	value: SharedValue<number>,
 	toValue: number,
 	config: AnimationConfig | undefined,
@@ -51,16 +55,34 @@ export const animateResetValue = (
 	);
 };
 
-export const clearGestureSettlingIfResting = (
-	gestures: GestureStoreMap,
-	isResting: boolean,
+export const animateMany = (
+	jobs: AnimateManyJob[],
+	spec: AnimationConfig | undefined,
+	onFinished: () => void,
 ) => {
 	"worklet";
-	if (!isResting) {
+	let pendingJobs = jobs.length;
+
+	if (pendingJobs === 0) {
+		onFinished();
 		return;
 	}
 
-	gestures.active.set(null);
-	gestures.direction.set(null);
-	gestures.settling.set(FALSE);
+	const finishJob = () => {
+		"worklet";
+		pendingJobs -= 1;
+
+		if (pendingJobs === 0) {
+			onFinished();
+		}
+	};
+
+	for (const job of jobs) {
+		animateResetValue(
+			job.value,
+			job.toValue,
+			getGestureResetSpec(spec, job.velocity),
+			finishJob,
+		);
+	}
 };

package/src/shared/providers/screen/gestures/shared/snap-points.ts

@@ -232,19 +232,20 @@ export const primeRuntimeSnapPoint = (
 	"worklet";
 	const {
 		policy,
-		stores: { animations },
-		lockedSnapPoint,
+		stores: { animations, gestures },
 	} = runtime;
 
-	const { resolvedSnapPoints, resolvedMaxSnapPoint } =
-		resolveRuntimeGestureSnapPoints(runtime);
+	const { resolvedSnapPoints } = resolveRuntimeGestureSnapPoints(runtime);
 
 	if (policy.gestureSnapLocked) {
-		lockedSnapPoint.set(
-			findNearestSnapPoint(animations.progress.get(), resolvedSnapPoints),
+		gestures.internal.lockedSnapPoint.set(
+			findNearestSnapPoint(
+				animations.transitionProgress.get(),
+				resolvedSnapPoints,
+			),
 		);
 		return;
 	}
 
-	lockedSnapPoint.set(resolvedMaxSnapPoint);
+	gestures.internal.lockedSnapPoint.set(null);
 };

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

@@ -0,0 +1,33 @@
+import type { GestureStoreMap } from "../../../../stores/gesture.store";
+
+type SnapshotGestureHandoffOptions = {
+	velocity?: number;
+};
+
+export const snapshotGestureHandoff = (
+	gestures: GestureStoreMap,
+	options?: SnapshotGestureHandoffOptions,
+) => {
+	"worklet";
+	const snapshot = gestures.internal.snapshot;
+
+	snapshot.x.set(gestures.x.get());
+	snapshot.y.set(gestures.y.get());
+	snapshot.normX.set(gestures.normX.get());
+	snapshot.normY.set(gestures.normY.get());
+	snapshot.velocity.set(options?.velocity ?? gestures.velocity.get());
+	snapshot.scale.set(gestures.scale.get());
+	snapshot.normScale.set(gestures.normScale.get());
+	snapshot.focalX.set(gestures.focalX.get());
+	snapshot.focalY.set(gestures.focalY.get());
+	snapshot.rotation.set(gestures.rotation.get());
+	snapshot.raw.x.set(gestures.raw.x.get());
+	snapshot.raw.y.set(gestures.raw.y.get());
+	snapshot.raw.normX.set(gestures.raw.normX.get());
+	snapshot.raw.normY.set(gestures.raw.normY.get());
+	snapshot.raw.scale.set(gestures.raw.scale.get());
+	snapshot.raw.normScale.set(gestures.raw.normScale.get());
+	snapshot.raw.rotation.set(gestures.raw.rotation.get());
+	snapshot.active.set(gestures.active.get());
+	snapshot.direction.set(gestures.direction.get());
+};

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

@@ -0,0 +1,52 @@
+import type { GestureStoreMap } from "../../../../stores/gesture.store";
+
+export const clearRawPanValues = (gestures: GestureStoreMap) => {
+	"worklet";
+	gestures.raw.x.set(0);
+	gestures.raw.y.set(0);
+	gestures.raw.normX.set(0);
+	gestures.raw.normY.set(0);
+};
+
+export const clearPanProgressDeltaValues = (gestures: GestureStoreMap) => {
+	"worklet";
+	gestures.internal.progressDeltaX.set(0);
+	gestures.internal.progressDeltaY.set(0);
+};
+
+export const clearPanProgressValues = (gestures: GestureStoreMap) => {
+	"worklet";
+	gestures.x.set(0);
+	gestures.y.set(0);
+	gestures.normX.set(0);
+	gestures.normY.set(0);
+	clearPanProgressDeltaValues(gestures);
+};
+
+export const clearPanTrackingValues = (gestures: GestureStoreMap) => {
+	"worklet";
+	clearPanProgressValues(gestures);
+	clearRawPanValues(gestures);
+	gestures.velocity.set(0);
+};
+
+export const clearFocalPoint = (gestures: GestureStoreMap) => {
+	"worklet";
+	gestures.focalX.set(0);
+	gestures.focalY.set(0);
+};
+
+export const clearRawTransformValues = (gestures: GestureStoreMap) => {
+	"worklet";
+	gestures.raw.scale.set(1);
+	gestures.raw.normScale.set(0);
+	gestures.raw.rotation.set(0);
+};
+
+export const clearTransformTrackingValues = (gestures: GestureStoreMap) => {
+	"worklet";
+	gestures.scale.set(1);
+	gestures.normScale.set(0);
+	gestures.rotation.set(0);
+	clearRawTransformValues(gestures);
+};

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

@@ -16,7 +16,6 @@ import type {
 } from "../../../types/animation.types";
 import type {
 	GestureDirections,
-	GestureProgressMode,
 	ResolvedGestureActivationArea,
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
@@ -49,11 +48,10 @@ export type RotationGestureEvent =
 	| GestureUpdateEvent<RotationGestureHandlerEventPayload>
 	| GestureStateChangeEvent<RotationGestureHandlerEventPayload>;
 
-/** Gesture that initiated the current simultaneous gesture composition. */
-export type GestureCompositionActivation = "pan" | "pinch" | null;
+/** Gesture that owns navigation release for the current simultaneous composition. */
+export type GestureCompositionOwner = "pan" | "pinch" | null;
 
 export type {
-	GestureProgressMode,
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
 	ScrollGestureState,
@@ -114,7 +112,6 @@ export interface PanGesturePolicy {
 	gestureDirection: NonNullable<ScreenTransitionConfig["gestureDirection"]>;
 	panActivationDirections: GestureDirections;
 	snapAxisDirections: SnapPanDirectionConfig;
-	gestureProgressMode: GestureProgressMode;
 	gestureSensitivity: NonNullable<ScreenTransitionConfig["gestureSensitivity"]>;
 	gestureVelocityImpact: number;
 	gestureSnapVelocityImpact: number;
@@ -134,7 +131,6 @@ export interface PinchGesturePolicy {
 	snapDirections: SnapPinchDirectionConfig;
 	pinchInEnabled: boolean;
 	pinchOutEnabled: boolean;
-	gestureProgressMode: GestureProgressMode;
 	gestureSensitivity: NonNullable<ScreenTransitionConfig["gestureSensitivity"]>;
 	gestureSnapVelocityImpact: number;
 	gestureSnapLocked: boolean;
@@ -154,8 +150,6 @@ export interface GestureRuntime<TPolicy extends GesturePolicy> {
 	participation: ScreenGestureParticipation;
 	policy: TPolicy;
 	stores: GestureRuntimeStores;
-	gestureProgressBaseline: SharedValue<number>;
-	lockedSnapPoint: SharedValue<number>;
 }
 
 export type PanGestureRuntime = GestureRuntime<PanGesturePolicy>;
@@ -187,7 +181,6 @@ export interface PanReleaseResult {
 	shouldDismiss: boolean;
 	initialVelocity: number;
 	commitProgress?: number;
-	resetNormalizedValuesImmediately?: boolean;
 	transitionSpec: TransitionSpec | undefined;
 	resetSpec: AnimationConfig | undefined;
 }
@@ -200,10 +193,7 @@ export interface PanReleasePlan {
 	resetVelocityY: number;
 	resetVelocityNormX: number;
 	resetVelocityNormY: number;
-	releaseVelocity: number;
-	resetNormalizedValues: boolean;
-	resetNormalizedValuesImmediately: boolean;
-	preserveRawValues: boolean;
+	handoffVelocity: number;
 	commitProgress?: number;
 	transitionSpec: TransitionSpec | undefined;
 	resetSpec: AnimationConfig | undefined;
@@ -213,6 +203,7 @@ export interface PinchReleaseResult {
 	target: number;
 	shouldDismiss: boolean;
 	initialVelocity: number;
+	handoffVelocity: number;
 	commitProgress?: number;
 	resetValuesImmediately?: boolean;
 	transitionSpec: TransitionSpec | undefined;

package/src/shared/providers/screen/options/helpers.ts

@@ -1,7 +1,6 @@
 import {
 	DEFAULT_GESTURE_ACTIVATION_AREA,
 	DEFAULT_GESTURE_DIRECTION,
-	DEFAULT_GESTURE_PROGRESS_MODE,
 	DEFAULT_GESTURE_RELEASE_VELOCITY_SCALE,
 	DEFAULT_GESTURE_SENSITIVITY,
 	DEFAULT_GESTURE_SNAP_LOCKED,
@@ -20,11 +19,6 @@ import type {
 	TransitionInterpolatedStyle,
 } from "../../../types";
 import type { BackdropBehavior } from "../../../types/screen.types";
-import {
-	gestureProgressModeDrivesProgress,
-	isGestureProgressMode,
-	resolveGestureProgressMode,
-} from "../../../utils/gesture-progress-mode";
 import { resolveSheetScrollGestureBehavior } from "../../../utils/resolve-screen-transition-options";
 import type {
 	RequiredScreenOption,
@@ -186,25 +180,6 @@ const resolveBackdropBehaviorOption = (
 		: fallback;
 };
 
-const resolveGestureProgressModeOption = (
-	gestureProgressMode: unknown,
-	gestureDrivesProgress: unknown,
-	fallback: RequiredScreenOption<"gestureProgressMode">,
-): RequiredScreenOption<"gestureProgressMode"> => {
-	"worklet";
-	if (isGestureProgressMode(gestureProgressMode)) {
-		return gestureProgressMode;
-	}
-
-	return resolveGestureProgressMode({
-		gestureDrivesProgress:
-			typeof gestureDrivesProgress === "boolean"
-				? gestureDrivesProgress
-				: undefined,
-		fallback,
-	});
-};
-
 const areGestureActivationAreasEqual = (
 	left: RequiredScreenOption<"gestureActivationArea">,
 	right: RequiredScreenOption<"gestureActivationArea">,
@@ -282,8 +257,6 @@ const areScreenOptionsEqual = (
 		left.gestureSnapVelocityImpact === right.gestureSnapVelocityImpact &&
 		left.gestureReleaseVelocityScale === right.gestureReleaseVelocityScale &&
 		left.gestureResponseDistance === right.gestureResponseDistance &&
-		left.gestureProgressMode === right.gestureProgressMode &&
-		left.gestureDrivesProgress === right.gestureDrivesProgress &&
 		areGestureActivationAreasEqual(
 			left.gestureActivationArea,
 			right.gestureActivationArea,
@@ -299,12 +272,6 @@ const areScreenOptionsEqual = (
 export const resolveBaseScreenOptions = (
 	options: ScreenTransitionConfig,
 ): ScreenOptionsSnapshot => {
-	const gestureProgressMode = resolveGestureProgressModeOption(
-		options.gestureProgressMode,
-		options.gestureDrivesProgress,
-		DEFAULT_GESTURE_PROGRESS_MODE,
-	);
-
 	return {
 		navigationMaskEnabled: resolveBooleanOption(
 			options.navigationMaskEnabled,
@@ -339,9 +306,6 @@ export const resolveBaseScreenOptions = (
 			options.gestureResponseDistance,
 			undefined,
 		),
-		gestureProgressMode,
-		gestureDrivesProgress:
-			gestureProgressModeDrivesProgress(gestureProgressMode),
 		gestureActivationArea: resolveGestureActivationAreaOption(
 			options.gestureActivationArea,
 			DEFAULT_GESTURE_ACTIVATION_AREA,
@@ -384,11 +348,6 @@ export const syncScreenOptionsOverrides = (
 	"worklet";
 	const options = raw?.options;
 	const base = screenOptions.get().baseOptions;
-	const gestureProgressMode = resolveGestureProgressModeOption(
-		options?.gestureProgressMode,
-		options?.gestureDrivesProgress,
-		base.gestureProgressMode,
-	);
 
 	const next: ScreenOptionsState = {
 		navigationMaskEnabled: base.navigationMaskEnabled,
@@ -421,9 +380,6 @@ export const syncScreenOptionsOverrides = (
 			options?.gestureResponseDistance,
 			base.gestureResponseDistance,
 		),
-		gestureProgressMode,
-		gestureDrivesProgress:
-			gestureProgressModeDrivesProgress(gestureProgressMode),
 		gestureActivationArea: resolveGestureActivationAreaOption(
 			options?.gestureActivationArea,
 			base.gestureActivationArea,

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

@@ -18,8 +18,6 @@ export type ScreenOptionsSnapshot = {
 	gestureSnapVelocityImpact: RequiredScreenOption<"gestureSnapVelocityImpact">;
 	gestureReleaseVelocityScale: RequiredScreenOption<"gestureReleaseVelocityScale">;
 	gestureResponseDistance: OptionalScreenOption<"gestureResponseDistance">;
-	gestureProgressMode: RequiredScreenOption<"gestureProgressMode">;
-	gestureDrivesProgress: RequiredScreenOption<"gestureDrivesProgress">;
 	gestureActivationArea: RequiredScreenOption<"gestureActivationArea">;
 	gestureSnapLocked: RequiredScreenOption<"gestureSnapLocked">;
 	sheetScrollGestureBehavior: RequiredScreenOption<"sheetScrollGestureBehavior">;

package/src/shared/providers/screen/styles/hooks/use-interpolated-style-maps.tsx

@@ -197,19 +197,19 @@ export const useInterpolatedStylesMap = () => {
 		const interpolatorOptionsOwner =
 			isInGestureMode || !nextInterpolator ? "current" : "next";
 
-		let effectiveProgress = progress;
-		let effectiveNext = next;
+		let selectedProgress = progress;
+		let selectedNext = next;
 
 		if (isInGestureMode) {
-			effectiveProgress = current.progress;
-			effectiveNext = undefined;
+			selectedProgress = current.progress;
+			selectedNext = undefined;
 		}
 
 		const currentResult = runInterpolator({
 			interpolator: currentInterpolator,
 			props,
-			progress: effectiveProgress,
-			next: effectiveNext,
+			progress: selectedProgress,
+			next: selectedNext,
 			bounds: boundsAccessor,
 			transition,
 			shouldDeferStyleBuckets,
@@ -233,8 +233,8 @@ export const useInterpolatedStylesMap = () => {
 		const nextResult = runInterpolator({
 			interpolator: nextInterpolator,
 			props,
-			progress: effectiveProgress,
-			next: effectiveNext,
+			progress: selectedProgress,
+			next: selectedNext,
 			bounds: boundsAccessor,
 			transition,
 			shouldDeferStyleBuckets,

package/src/shared/providers/screen/styles/hooks/use-maybe-block-visibility.tsx

@@ -14,7 +14,8 @@ import { resolveScreenVisibilityGate } from "../helpers/visibility-gate";
 export const useMaybeBlockVisibility = (isFloatingOverlay?: boolean) => {
 	const { height } = useWindowDimensions();
 	const { currentScreenKey } = useDescriptorDerivations();
-	const { entering, progress } = AnimationStore.getBag(currentScreenKey);
+	const { entering, transitionProgress } =
+		AnimationStore.getBag(currentScreenKey);
 
 	const { pendingLifecycleStartBlockCount, pendingLifecycleRequestKind } =
 		SystemStore.getBag(currentScreenKey);
@@ -40,7 +41,7 @@ export const useMaybeBlockVisibility = (isFloatingOverlay?: boolean) => {
 				hasVisibilityGateOpened: hasVisibilityGateOpened.get(),
 				pendingLifecycleStartBlockCount: pendingLifecycleStartBlockCount.get(),
 				pendingLifecycleRequestKind: pendingLifecycleRequestKind.get(),
-				progress: progress.get(),
+				progress: transitionProgress.get(),
 				entering: entering.get(),
 			});
 		},

package/src/shared/stores/animation.store.ts

@@ -6,8 +6,8 @@ import {
 import { createStore } from "../utils/create-store";
 
 export type AnimationStoreMap = {
-	progress: SharedValue<number>;
-	effectiveProgress: SharedValue<number>;
+	transitionProgress: SharedValue<number>;
+	visualProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	progressAnimating: SharedValue<number>;
 	progressSettled: SharedValue<number>;
@@ -17,8 +17,8 @@ export type AnimationStoreMap = {
 
 function createAnimationBag(): AnimationStoreMap {
 	return {
-		progress: makeMutable(0),
-		effectiveProgress: makeMutable(0),
+		transitionProgress: makeMutable(0),
+		visualProgress: makeMutable(0),
 		willAnimate: makeMutable(0),
 		closing: makeMutable(0),
 		progressAnimating: makeMutable(0),
@@ -29,14 +29,14 @@ function createAnimationBag(): AnimationStoreMap {
 
 /**
  * Route-keyed screen transition state for the public animation lifecycle.
- * `progress` tracks committed transition progress; `effectiveProgress` tracks
- * the hydrated progress after live gesture policy is applied.
+ * `transitionProgress` tracks committed transition progress; `visualProgress`
+ * tracks hydrated progress after live gestures are applied.
  */
 export const AnimationStore = createStore<AnimationStoreMap>({
 	createBag: createAnimationBag,
 	disposeBag: (bag) => {
-		cancelAnimation(bag.progress);
-		cancelAnimation(bag.effectiveProgress);
+		cancelAnimation(bag.transitionProgress);
+		cancelAnimation(bag.visualProgress);
 		cancelAnimation(bag.willAnimate);
 		cancelAnimation(bag.progressAnimating);
 		cancelAnimation(bag.progressSettled);