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

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

@@ -6,8 +6,14 @@ import {
 	normalizeGestureTranslation,
 	resolveGestureVelocity,
 } from "../../shared/physics";
+import { snapshotGestureHandoff } from "../../shared/snapshot";
+import {
+	clearFocalPoint,
+	clearPanTrackingValues,
+	clearTransformTrackingValues,
+} from "../../shared/values";
 import type {
-	GestureCompositionActivation,
+	GestureCompositionOwner,
 	GestureDimensions,
 	PanGestureEvent,
 	PanGestureRuntime,
@@ -21,7 +27,6 @@ export const startPanBase = (runtime: PanGestureRuntime) => {
 	"worklet";
 	const {
 		stores: { gestures, animations },
-		gestureProgressBaseline,
 	} = runtime;
 
 	const wasSettling = gestures.settling.get();
@@ -38,24 +43,10 @@ export const startPanBase = (runtime: PanGestureRuntime) => {
 	gestures.dragging.set(TRUE);
 	gestures.dismissing.set(0);
 	gestures.settling.set(0);
-	gestures.x.set(0);
-	gestures.y.set(0);
-	gestures.normX.set(0);
-	gestures.normY.set(0);
-	gestures.velocity.set(0);
-	gestures.scale.set(1);
-	gestures.normScale.set(0);
-	gestures.focalX.set(0);
-	gestures.focalY.set(0);
-	gestures.rotation.set(0);
-	gestures.raw.x.set(0);
-	gestures.raw.y.set(0);
-	gestures.raw.normX.set(0);
-	gestures.raw.normY.set(0);
-	gestures.raw.scale.set(1);
-	gestures.raw.normScale.set(0);
-	gestures.raw.rotation.set(0);
-	gestureProgressBaseline.set(animations.progress.get());
+	clearPanTrackingValues(gestures);
+	clearTransformTrackingValues(gestures);
+	clearFocalPoint(gestures);
+	gestures.internal.progressBaseline.set(animations.transitionProgress.get());
 };
 
 export const trackPanGesture = (
@@ -87,6 +78,8 @@ export const trackPanGesture = (
 	gestures.y.set(y);
 	gestures.normX.set(normX);
 	gestures.normY.set(normY);
+	gestures.internal.progressDeltaX.set(normX);
+	gestures.internal.progressDeltaY.set(normY);
 	gestures.velocity.set(velocity);
 	gestures.raw.x.set(rawX);
 	gestures.raw.y.set(rawY);
@@ -109,7 +102,7 @@ export const finalizePanRelease = (
 	dimensions: GestureDimensions,
 	rawEvent: PanGestureEvent,
 	requestDismiss?: () => void,
-	gestureCompositionActivation?: SharedValue<GestureCompositionActivation>,
+	gestureCompositionOwner?: SharedValue<GestureCompositionOwner>,
 ) => {
 	"worklet";
 	const {
@@ -118,18 +111,15 @@ export const finalizePanRelease = (
 	} = runtime;
 
 	const canDriveRelease =
-		!gestureCompositionActivation ||
-		gestureCompositionActivation.get() === "pan";
+		!gestureCompositionOwner || gestureCompositionOwner.get() === "pan";
 
 	const plan = buildPanReleasePlan(
 		canDriveRelease
 			? release
 			: {
-					target: animations.progress.get(),
+					target: animations.transitionProgress.get(),
 					shouldDismiss: false,
 					initialVelocity: 0,
-					resetNormalizedValuesImmediately:
-						policy.gestureProgressMode === "progress-driven",
 					transitionSpec: undefined,
 					resetSpec: policy.transitionSpec?.open,
 				},
@@ -139,22 +129,19 @@ export const finalizePanRelease = (
 	);
 
 	if (typeof plan.commitProgress === "number") {
-		animations.progress.set(plan.commitProgress);
+		animations.transitionProgress.set(plan.commitProgress);
 		system.targetProgress.set(plan.commitProgress);
 	}
 
+	if (canDriveRelease && plan.shouldDismiss) {
+		snapshotGestureHandoff(gestures, {
+			velocity: plan.handoffVelocity,
+		});
+	}
+
 	resetPanGestureValues({
-		spec: plan.resetSpec,
+		plan,
 		gestures,
-		shouldDismiss: plan.shouldDismiss,
-		velocityX: plan.resetVelocityX,
-		velocityY: plan.resetVelocityY,
-		velocityNormX: plan.resetVelocityNormX,
-		velocityNormY: plan.resetVelocityNormY,
-		releaseVelocity: plan.releaseVelocity,
-		resetNormalizedValues: plan.resetNormalizedValues,
-		resetNormalizedValuesImmediately: plan.resetNormalizedValuesImmediately,
-		preserveRawValues: plan.preserveRawValues,
 		updateLifecycle: canDriveRelease,
 	});
 
@@ -163,7 +150,7 @@ export const finalizePanRelease = (
 	}
 
 	const progressAlreadyAtTarget =
-		Math.abs(animations.progress.get() - plan.target) <= EPSILON;
+		Math.abs(animations.transitionProgress.get() - plan.target) <= EPSILON;
 
 	if (!plan.shouldDismiss && progressAlreadyAtTarget) {
 		system.targetProgress.set(plan.target);

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

@@ -96,7 +96,7 @@ const getPanSnapReleaseProgress = ({
 	const axisDimension = isHorizontal ? dimensions.width : dimensions.height;
 	const axisProgress = axisTranslation / Math.max(1, axisDimension);
 	const progress =
-		runtime.gestureProgressBaseline.get() +
+		runtime.stores.gestures.internal.progressBaseline.get() +
 		activeAxis.config.progressSign * axisProgress;
 
 	return clamp(progress, minSnapPoint, maxSnapPoint);
@@ -109,7 +109,7 @@ const buildInactivePanSnapRelease = (
 	const { policy, stores } = runtime;
 
 	return {
-		target: stores.animations.progress.get(),
+		target: stores.animations.transitionProgress.get(),
 		shouldDismiss: false,
 		initialVelocity: 0,
 		transitionSpec: policy.transitionSpec,
@@ -152,7 +152,6 @@ export const resolvePanRelease = (
 			event,
 			dimensions,
 			directions: policy.panActivationDirections,
-			gestureReleaseVelocityScale: policy.gestureReleaseVelocityScale,
 		}),
 		transitionSpec: policy.transitionSpec,
 		resetSpec: shouldDismiss
@@ -167,7 +166,7 @@ export const resolveSnapPanRelease = (
 	dimensions: GestureDimensions,
 ): PanReleaseResult => {
 	"worklet";
-	const { participation, policy, lockedSnapPoint } = runtime;
+	const { participation, policy } = runtime;
 	const activeAxis = resolveActivePanSnapAxis(runtime);
 
 	if (!activeAxis) {
@@ -192,7 +191,10 @@ export const resolveSnapPanRelease = (
 	const result = determineSnapTarget({
 		currentProgress,
 		snapPoints: policy.gestureSnapLocked
-			? [lockedSnapPoint.get()]
+			? [
+					runtime.stores.gestures.internal.lockedSnapPoint.get() ??
+						resolvedMaxSnapPoint,
+				]
 			: resolvedSnapPoints,
 		velocity: snapVelocity,
 		dimension: axisDimension,
@@ -210,14 +212,11 @@ export const resolveSnapPanRelease = (
 			handoffVelocity: getPanReleaseHandoffVelocity(
 				axisVelocity,
 				axisDimension,
-				policy.gestureReleaseVelocityScale,
 			),
 			target,
 			currentProgress,
 		}),
 		commitProgress: currentProgress,
-		resetNormalizedValuesImmediately:
-			policy.gestureProgressMode === "progress-driven",
 		transitionSpec: resolveGestureSnapTransitionSpec({
 			transitionSpec: policy.transitionSpec,
 			shouldDismiss,
@@ -238,40 +237,39 @@ export const buildPanReleasePlan = (
 ): PanReleasePlan => {
 	"worklet";
 	const { policy } = runtime;
-	const progressDriven = policy.gestureProgressMode === "progress-driven";
 	const releaseVelocityScale = Math.max(0, policy.gestureReleaseVelocityScale);
-	const resetUsesReleaseVelocity = !release.shouldDismiss || !progressDriven;
-	const resetVelocityFactor = resetUsesReleaseVelocity ? 1 : 0;
-	const resetVelocityScale = releaseVelocityScale * resetVelocityFactor;
+	const resetVelocityScale = releaseVelocityScale;
 	const resetVelocityX =
 		resetVelocityScale === 0 ? 0 : rawEvent.velocityX * resetVelocityScale;
 	const resetVelocityY =
 		resetVelocityScale === 0 ? 0 : rawEvent.velocityY * resetVelocityScale;
-	const releaseVelocityNormX =
-		rawEvent.velocityX / Math.max(1, dimensions.width);
-	const releaseVelocityNormY =
-		rawEvent.velocityY / Math.max(1, dimensions.height);
-	const releaseVelocity = release.shouldDismiss
+	const handoffVelocityNormX = getPanReleaseHandoffVelocity(
+		rawEvent.velocityX,
+		dimensions.width,
+		releaseVelocityScale,
+	);
+	const handoffVelocityNormY = getPanReleaseHandoffVelocity(
+		rawEvent.velocityY,
+		dimensions.height,
+		releaseVelocityScale,
+	);
+	const handoffVelocity = release.shouldDismiss
 		? resolvePanReleaseVelocity(
 				runtime,
-				releaseVelocityNormX,
-				releaseVelocityNormY,
+				handoffVelocityNormX,
+				handoffVelocityNormY,
 			)
 		: 0;
 
 	return {
 		target: release.target,
 		shouldDismiss: release.shouldDismiss,
-		progressVelocity: progressDriven ? release.initialVelocity : 0,
+		progressVelocity: release.initialVelocity,
 		resetVelocityX,
 		resetVelocityY,
 		resetVelocityNormX: resetVelocityX / Math.max(1, dimensions.width),
 		resetVelocityNormY: resetVelocityY / Math.max(1, dimensions.height),
-		releaseVelocity,
-		resetNormalizedValues: !release.shouldDismiss || progressDriven,
-		resetNormalizedValuesImmediately:
-			release.resetNormalizedValuesImmediately === true,
-		preserveRawValues: release.shouldDismiss,
+		handoffVelocity,
 		commitProgress: release.commitProgress,
 		transitionSpec: release.transitionSpec,
 		resetSpec: release.resetSpec,

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

@@ -1,105 +1,73 @@
-import { EPSILON, FALSE, TRUE } from "../../../../../constants";
+import { FALSE, TRUE } from "../../../../../constants";
 import type { GestureStoreMap } from "../../../../../stores/gesture.store";
-import type { AnimationConfig } from "../../../../../types/animation.types";
+import { animateMany } from "../../shared/reset";
 import {
-	animateResetValue,
-	clearGestureSettlingIfResting,
-	getGestureResetSpec,
-} from "../../shared/reset";
+	clearPanProgressDeltaValues,
+	clearRawPanValues,
+} from "../../shared/values";
+import type { PanReleasePlan } from "../../types";
 
 interface ResetPanGestureValuesProps {
-	spec?: AnimationConfig;
+	plan: PanReleasePlan;
 	gestures: GestureStoreMap;
-	shouldDismiss: boolean;
-	velocityX?: number;
-	velocityY?: number;
-	velocityNormX?: number;
-	velocityNormY?: number;
-	releaseVelocity?: number;
-	resetNormalizedValues?: boolean;
-	resetNormalizedValuesImmediately?: boolean;
-	preserveRawValues?: boolean;
 	updateLifecycle?: boolean;
 }
 
-const clearPanSettlingIfResting = (gestures: GestureStoreMap) => {
-	"worklet";
-
-	clearGestureSettlingIfResting(
-		gestures,
-		!gestures.dragging.get() &&
-			!gestures.dismissing.get() &&
-			Math.abs(gestures.x.get()) <= EPSILON &&
-			Math.abs(gestures.y.get()) <= EPSILON &&
-			Math.abs(gestures.normX.get()) <= EPSILON &&
-			Math.abs(gestures.normY.get()) <= EPSILON,
-	);
-};
-
 export const resetPanGestureValues = ({
-	spec,
+	plan,
 	gestures,
-	shouldDismiss,
-	velocityX,
-	velocityY,
-	velocityNormX,
-	velocityNormY,
-	releaseVelocity,
-	resetNormalizedValues = true,
-	resetNormalizedValuesImmediately = false,
-	preserveRawValues = shouldDismiss,
 	updateLifecycle = true,
 }: ResetPanGestureValuesProps) => {
 	"worklet";
-	const clearSettlingIfNeeded = () => {
+	const finishPanReset = () => {
 		"worklet";
-		if (updateLifecycle) {
-			clearPanSettlingIfResting(gestures);
+		if (!updateLifecycle || plan.shouldDismiss) {
+			return;
 		}
+
+		gestures.active.set(null);
+		gestures.direction.set(null);
+		gestures.settling.set(FALSE);
 	};
 
-	if (!preserveRawValues) {
-		gestures.raw.x.set(0);
-		gestures.raw.y.set(0);
-		gestures.raw.normX.set(0);
-		gestures.raw.normY.set(0);
-	}
+	clearRawPanValues(gestures);
 
 	if (updateLifecycle) {
 		gestures.dragging.set(FALSE);
-		gestures.dismissing.set(shouldDismiss ? TRUE : FALSE);
-		gestures.settling.set(shouldDismiss ? FALSE : TRUE);
+		gestures.dismissing.set(plan.shouldDismiss ? TRUE : FALSE);
+		gestures.settling.set(plan.shouldDismiss ? FALSE : TRUE);
 	}
-	gestures.velocity.set(shouldDismiss ? (releaseVelocity ?? 0) : 0);
 
-	animateResetValue(gestures.x, 0, getGestureResetSpec(spec, velocityX), () =>
-		clearSettlingIfNeeded(),
-	);
-	animateResetValue(gestures.y, 0, getGestureResetSpec(spec, velocityY), () =>
-		clearSettlingIfNeeded(),
-	);
+	gestures.velocity.set(0);
 
-	if (!resetNormalizedValues) {
-		return;
-	}
+	const progressDeltaWasCommitted = typeof plan.commitProgress === "number";
 
-	if (resetNormalizedValuesImmediately) {
-		gestures.normX.set(0);
-		gestures.normY.set(0);
-		clearSettlingIfNeeded();
-		return;
+	if (progressDeltaWasCommitted) {
+		clearPanProgressDeltaValues(gestures);
 	}
 
-	animateResetValue(
-		gestures.normX,
-		0,
-		getGestureResetSpec(spec, velocityNormX),
-		() => clearSettlingIfNeeded(),
-	);
-	animateResetValue(
-		gestures.normY,
-		0,
-		getGestureResetSpec(spec, velocityNormY),
-		() => clearSettlingIfNeeded(),
+	animateMany(
+		[
+			{ value: gestures.x, toValue: 0, velocity: plan.resetVelocityX },
+			{ value: gestures.y, toValue: 0, velocity: plan.resetVelocityY },
+			{ value: gestures.normX, toValue: 0, velocity: plan.resetVelocityNormX },
+			{ value: gestures.normY, toValue: 0, velocity: plan.resetVelocityNormY },
+			...(progressDeltaWasCommitted
+				? []
+				: [
+						{
+							value: gestures.internal.progressDeltaX,
+							toValue: 0,
+							velocity: plan.resetVelocityNormX,
+						},
+						{
+							value: gestures.internal.progressDeltaY,
+							toValue: 0,
+							velocity: plan.resetVelocityNormY,
+						},
+					]),
+		],
+		plan.resetSpec,
+		finishPanReset,
 	);
 };

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

@@ -4,8 +4,9 @@ import { useNavigationHelpers } from "../../../../../hooks/navigation/use-naviga
 import type { ScreenOptionsContextValue } from "../../../options";
 import { usePanGestureSensitivity } from "../../hooks/use-gesture-sensitivity";
 import { resolvePanRuntime } from "../../shared/runtime";
+import { clearPanTrackingValues } from "../../shared/values";
 import type {
-	GestureCompositionActivation,
+	GestureCompositionOwner,
 	GestureDimensions,
 	PanBehavior,
 	PanGestureEvent,
@@ -26,7 +27,7 @@ export const usePanBehavior = (
 	runtime: SharedValue<PanGestureRuntime>,
 	screenOptions: ScreenOptionsContextValue,
 	dimensions: GestureDimensions,
-	gestureCompositionActivation: SharedValue<GestureCompositionActivation>,
+	gestureCompositionOwner: SharedValue<GestureCompositionOwner>,
 ): PanBehavior => {
 	const { dismissScreen, requestDismiss } = useNavigationHelpers();
 	const { withSensitivity, resetSensitivity } =
@@ -35,17 +36,8 @@ export const usePanBehavior = (
 	const onStart = useCallback(() => {
 		"worklet";
 		const latestRuntime = resolvePanRuntime(runtime.get(), screenOptions.get());
-		if (gestureCompositionActivation.get() === "pinch") {
-			const { gestures } = latestRuntime.stores;
-			gestures.x.set(0);
-			gestures.y.set(0);
-			gestures.normX.set(0);
-			gestures.normY.set(0);
-			gestures.velocity.set(0);
-			gestures.raw.x.set(0);
-			gestures.raw.y.set(0);
-			gestures.raw.normX.set(0);
-			gestures.raw.normY.set(0);
+		if (gestureCompositionOwner.get() === "pinch") {
+			clearPanTrackingValues(latestRuntime.stores.gestures);
 			resetSensitivity();
 			return;
 		}
@@ -55,7 +47,7 @@ export const usePanBehavior = (
 		}
 		startPanBase(latestRuntime);
 		resetSensitivity();
-	}, [runtime, screenOptions, resetSensitivity, gestureCompositionActivation]);
+	}, [runtime, screenOptions, resetSensitivity, gestureCompositionOwner]);
 
 	const onUpdate = useCallback(
 		(rawEvent: PanGestureEvent) => {
@@ -86,7 +78,7 @@ export const usePanBehavior = (
 
 			const release = !latestRuntime.policy.enabled
 				? {
-						target: latestRuntime.stores.animations.progress.get(),
+						target: latestRuntime.stores.animations.transitionProgress.get(),
 						shouldDismiss: false,
 						initialVelocity: 0,
 						transitionSpec: undefined,
@@ -95,7 +87,7 @@ export const usePanBehavior = (
 				: latestRuntime.participation.effectiveSnapPoints.hasSnapPoints
 					? resolveSnapPanRelease(event, latestRuntime, dimensions)
 					: resolvePanRelease(event, latestRuntime, dimensions);
-			const isPanComposition = gestureCompositionActivation.get() === "pan";
+			const isPanCompositionOwner = gestureCompositionOwner.get() === "pan";
 
 			finalizePanRelease(
 				release,
@@ -104,11 +96,11 @@ export const usePanBehavior = (
 				dimensions,
 				rawEvent,
 				requestDismiss,
-				gestureCompositionActivation,
+				gestureCompositionOwner,
 			);
 
-			if (isPanComposition) {
-				gestureCompositionActivation.set(null);
+			if (isPanCompositionOwner) {
+				gestureCompositionOwner.set(null);
 			}
 		},
 		[
@@ -118,7 +110,7 @@ export const usePanBehavior = (
 			dismissScreen,
 			requestDismiss,
 			withSensitivity,
-			gestureCompositionActivation,
+			gestureCompositionOwner,
 		],
 	);
 

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

@@ -3,11 +3,10 @@ import { useWindowDimensions } from "react-native";
 import { Gesture } from "react-native-gesture-handler";
 import type { SharedValue } from "react-native-reanimated";
 import { useScreenOptionsContext } from "../../options";
-import { useGestureBuilderState } from "../hooks/use-gesture-builder-state";
 import { useStableRuntimeConfig } from "../hooks/use-stable-runtime-config";
 import type {
 	DirectionClaimMap,
-	GestureCompositionActivation,
+	GestureCompositionOwner,
 	PanGesture,
 	ScreenGestureConfig,
 	ScrollGestureState,
@@ -19,27 +18,22 @@ interface UseBuildPanGestureProps {
 	scrollState: SharedValue<ScrollGestureState | null>;
 	gestureConfig: ScreenGestureConfig;
 	childDirectionClaims: SharedValue<DirectionClaimMap>;
-	gestureCompositionActivation: SharedValue<GestureCompositionActivation>;
+	gestureCompositionOwner: SharedValue<GestureCompositionOwner>;
 }
 
 export const useBuildPanGesture = ({
 	scrollState,
 	gestureConfig,
 	childDirectionClaims,
-	gestureCompositionActivation,
+	gestureCompositionOwner,
 }: UseBuildPanGestureProps): PanGesture => {
 	const dimensions = useWindowDimensions();
 	const { participation, pan: policy } = gestureConfig;
 	const screenOptions = useScreenOptionsContext();
 
-	const { gestureProgressBaseline, lockedSnapPoint } =
-		useGestureBuilderState(participation);
-
 	const runtime = useStableRuntimeConfig({
 		participation,
 		policy,
-		gestureProgressBaseline,
-		lockedSnapPoint,
 	});
 
 	const activation = usePanActivation({
@@ -48,14 +42,14 @@ export const useBuildPanGesture = ({
 		runtime,
 		screenOptions,
 		dimensions,
-		gestureCompositionActivation,
+		gestureCompositionOwner,
 	});
 
 	const behavior = usePanBehavior(
 		runtime,
 		screenOptions,
 		dimensions,
-		gestureCompositionActivation,
+		gestureCompositionOwner,
 	);
 
 	const panGesture = useMemo(() => {

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

@@ -6,21 +6,18 @@ import type {
 import type { SharedValue } from "react-native-reanimated";
 import type { ScreenOptionsContextValue } from "../../../options";
 import { resolvePinchRuntime } from "../../shared/runtime";
-import type {
-	GestureCompositionActivation,
-	PinchGestureRuntime,
-} from "../../types";
+import type { GestureCompositionOwner, PinchGestureRuntime } from "../../types";
 
 interface UsePinchActivationProps {
 	runtime: SharedValue<PinchGestureRuntime>;
 	screenOptions: ScreenOptionsContextValue;
-	gestureCompositionActivation: SharedValue<GestureCompositionActivation>;
+	gestureCompositionOwner: SharedValue<GestureCompositionOwner>;
 }
 
 export const usePinchActivation = ({
 	runtime,
 	screenOptions,
-	gestureCompositionActivation,
+	gestureCompositionOwner,
 }: UsePinchActivationProps) => {
 	const onTouchesDown = useCallback(
 		(
@@ -33,18 +30,15 @@ export const usePinchActivation = ({
 				screenOptions.get(),
 			);
 
-			if (gestureCompositionActivation.get() === "pan") {
-				stateManager?.fail();
-				return;
-			}
-
 			if (!participation.canTrackGesture || !policy.enabled) {
 				stateManager?.fail();
 				return;
 			}
 
 			if (event.numberOfTouches === 2) {
-				gestureCompositionActivation.set("pinch");
+				if (gestureCompositionOwner.get() === null) {
+					gestureCompositionOwner.set("pinch");
+				}
 				stateManager?.activate();
 				return;
 			}
@@ -53,7 +47,7 @@ export const usePinchActivation = ({
 				stateManager?.fail();
 			}
 		},
-		[runtime, screenOptions, gestureCompositionActivation],
+		[runtime, screenOptions, gestureCompositionOwner],
 	);
 
 	const onTouchesMove = useCallback(
@@ -70,14 +64,18 @@ export const usePinchActivation = ({
 			}
 
 			if (event.numberOfTouches === 2) {
-				gestureCompositionActivation.set("pinch");
+				if (gestureCompositionOwner.get() === null) {
+					gestureCompositionOwner.set("pinch");
+				}
 				stateManager.activate();
 				return;
 			}
 
-			stateManager.fail();
+			if (event.numberOfTouches > 2) {
+				stateManager.fail();
+			}
 		},
-		[runtime, screenOptions, gestureCompositionActivation],
+		[runtime, screenOptions, gestureCompositionOwner],
 	);
 
 	return useMemo(

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

@@ -3,6 +3,8 @@ import { EPSILON, FALSE, TRUE } from "../../../../../constants";
 import { animateToProgress } from "../../../../../utils/animation/animate-to-progress";
 import { emit } from "../../../../../utils/animation/emit";
 import { normalizePinchScale } from "../../shared/physics";
+import { snapshotGestureHandoff } from "../../shared/snapshot";
+import { clearTransformTrackingValues } from "../../shared/values";
 import type {
 	PinchGestureEvent,
 	PinchGestureRuntime,
@@ -18,7 +20,6 @@ export const startPinchBase = (
 	"worklet";
 	const {
 		stores: { gestures, animations },
-		gestureProgressBaseline,
 	} = runtime;
 
 	const wasSettling = gestures.settling.get();
@@ -36,15 +37,10 @@ export const startPinchBase = (
 	gestures.active.set(null);
 	gestures.direction.set(null);
 	gestures.velocity.set(0);
-	gestures.scale.set(1);
-	gestures.normScale.set(0);
-	gestures.rotation.set(0);
-	gestures.raw.scale.set(1);
-	gestures.raw.normScale.set(0);
-	gestures.raw.rotation.set(0);
+	clearTransformTrackingValues(gestures);
 	gestures.focalX.set(event.focalX);
 	gestures.focalY.set(event.focalY);
-	gestureProgressBaseline.set(animations.progress.get());
+	gestures.internal.progressBaseline.set(animations.transitionProgress.get());
 };
 
 export const trackPinchGesture = (
@@ -60,6 +56,8 @@ export const trackPinchGesture = (
 
 	gestures.scale.set(scale);
 	gestures.normScale.set(normScale);
+	gestures.focalX.set(event.focalX);
+	gestures.focalY.set(event.focalY);
 	gestures.raw.scale.set(rawScale);
 	gestures.raw.normScale.set(rawNormScale);
 	gestures.active.set(
@@ -84,10 +82,16 @@ export const finalizePinchRelease = (
 	} = runtime;
 
 	if (typeof release.commitProgress === "number") {
-		animations.progress.set(release.commitProgress);
+		animations.transitionProgress.set(release.commitProgress);
 		system.targetProgress.set(release.commitProgress);
 	}
 
+	if (release.shouldDismiss) {
+		snapshotGestureHandoff(gestures, {
+			velocity: release.handoffVelocity,
+		});
+	}
+
 	resetPinchGestureValues({
 		spec: release.resetSpec,
 		gestures,