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

package/src/providers/screen/animation/animation.provider.tsx

@@ -1,15 +1,10 @@
-import { type ReactNode, useCallback, useLayoutEffect, useMemo } from "react";
-import { useSharedValue } from "react-native-reanimated";
+import { type ReactNode, useMemo } from "react";
 import { createBoundsAccessor } from "../../../utils/bounds";
 import createProvider from "../../../utils/create-provider";
+import { useDescriptorsStore } from "../descriptors";
+import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useScreenAnimationPipeline } from "./helpers/pipeline";
-import type {
-	RegisterScreenAnimationDescendant,
-	ScreenAnimationAncestorDescendantRegistrar,
-	ScreenAnimationDescendantSources,
-	ScreenAnimationSource,
-	ScreenAnimationTransitionSource,
-} from "./types";
+import type { ScreenAnimationTransitionSource } from "./types";
 
 type Props = {
 	children: ReactNode;
@@ -18,191 +13,76 @@ type Props = {
 export type ScreenAnimationContextValue = ReturnType<
 	typeof useScreenAnimationPipeline
 > & {
-	ancestorScreenAnimationSources: ScreenAnimationSource[];
-	descendantScreenAnimationSources: ScreenAnimationDescendantSources;
-	registerDescendantScreenAnimationSource: RegisterScreenAnimationDescendant;
-	ancestorDescendantScreenAnimationRegistrars: ScreenAnimationAncestorDescendantRegistrar[];
+	transitionSources: readonly ScreenAnimationTransitionSource[];
+	transitionOriginIndex: number;
+	transitionSourcesThroughSelf: readonly ScreenAnimationTransitionSource[];
+	transitionSourcesFromSelf: readonly ScreenAnimationTransitionSource[];
 };
 
-export type ScreenAnimationContextResult = {
-	value: ScreenAnimationContextValue;
-};
-
-export const { ScreenAnimationProvider, useScreenAnimationStore } =
-	createProvider("ScreenAnimation", {
-		guarded: true,
-	})<Props, ScreenAnimationContextValue>(
-		(_props, { useParentStore }): ScreenAnimationContextResult => {
-			const parentContext = useParentStore();
-			const parentScreenInterpolatorProps =
-				parentContext?.screenInterpolatorProps;
-			const parentScreenInterpolatorPropsRevision =
-				parentContext?.screenInterpolatorPropsRevision;
-			const parentAncestorScreenAnimationSources =
-				parentContext?.ancestorScreenAnimationSources;
-			const parentRegisterDescendantScreenAnimationSource =
-				parentContext?.registerDescendantScreenAnimationSource;
-			const parentAncestorDescendantScreenAnimationRegistrars =
-				parentContext?.ancestorDescendantScreenAnimationRegistrars;
-
-			const {
-				screenInterpolatorProps,
-				screenInterpolatorPropsRevision,
-				selectedInterpolatorOptions,
-				nextInterpolator,
-				currentInterpolator,
-			} = useScreenAnimationPipeline();
-
-			const selfScreenAnimationSource = useMemo<ScreenAnimationSource>(
-				() => ({
-					screenInterpolatorProps,
-					screenInterpolatorPropsRevision,
+const EMPTY_TRANSITION_SOURCES: readonly ScreenAnimationTransitionSource[] = [];
+
+const createScreenAnimationProvider = createProvider("ScreenAnimation", {
+	global: true,
+})<Props, ScreenAnimationContextValue>;
+
+export const {
+	ScreenAnimationProvider,
+	useOptionalScreenAnimationStore,
+	useScreenAnimationStore,
+}: ReturnType<typeof createScreenAnimationProvider> =
+	createScreenAnimationProvider((_props) => {
+		const currentScreenKey = useDescriptorsStore(
+			(store) => store.derivations.currentScreenKey,
+		);
+		const relationships = useCurrentScreenRelationships();
+		const pipeline = useScreenAnimationPipeline();
+
+		const screenAnimationSource = useMemo<ScreenAnimationTransitionSource>(
+			() => ({
+				screenInterpolatorProps: pipeline.screenInterpolatorProps,
+				screenInterpolatorPropsRevision:
+					pipeline.screenInterpolatorPropsRevision,
+				boundsAccessor: createBoundsAccessor(() => {
+					"worklet";
+					return pipeline.screenInterpolatorProps.get();
 				}),
-				[screenInterpolatorProps, screenInterpolatorPropsRevision],
-			);
-
-			const selfScreenAnimationTransitionSource =
-				useMemo<ScreenAnimationTransitionSource>(
-					() => ({
-						...selfScreenAnimationSource,
-						boundsAccessor: createBoundsAccessor(() => {
-							"worklet";
-							return selfScreenAnimationSource.screenInterpolatorProps.get();
-						}),
-					}),
-					[selfScreenAnimationSource],
-				);
-
-			const descendantScreenAnimationSources = useSharedValue<
-				ScreenAnimationDescendantSources["value"]
-			>([]);
-
-			const registerDescendantScreenAnimationSource =
-				useCallback<RegisterScreenAnimationDescendant>(
-					(source, depth) => {
-						descendantScreenAnimationSources.modify(
-							<T extends ScreenAnimationDescendantSources["value"]>(
-								currentSources: T,
-							): T => {
-								"worklet";
-								const existingIndex = currentSources.findIndex(
-									(currentSource) => currentSource.source === source,
-								);
-
-								if (
-									existingIndex !== -1 &&
-									currentSources[existingIndex]?.depth === depth
-								) {
-									return currentSources;
-								}
-
-								const nextSources =
-									existingIndex === -1
-										? [...currentSources, { source, depth }]
-										: currentSources.map((currentSource, index) =>
-												index === existingIndex
-													? { source, depth }
-													: currentSource,
-											);
-
-								return nextSources.sort((a, b) => a.depth - b.depth) as T;
-							},
-						);
-
-						return () => {
-							descendantScreenAnimationSources.modify(
-								<T extends ScreenAnimationDescendantSources["value"]>(
-									currentSources: T,
-								): T => {
-									"worklet";
-									return currentSources.filter(
-										(currentSource) => currentSource.source !== source,
-									) as T;
-								},
-							);
-						};
-					},
-					[descendantScreenAnimationSources],
-				);
-
-			const ancestorScreenAnimationSources = useMemo(() => {
-				if (
-					!parentScreenInterpolatorProps ||
-					!parentScreenInterpolatorPropsRevision ||
-					!parentAncestorScreenAnimationSources
-				) {
-					return [];
-				}
-
-				return [
-					{
-						screenInterpolatorProps: parentScreenInterpolatorProps,
-						screenInterpolatorPropsRevision:
-							parentScreenInterpolatorPropsRevision,
-					},
-					...parentAncestorScreenAnimationSources,
-				];
-			}, [
-				parentScreenInterpolatorProps,
-				parentScreenInterpolatorPropsRevision,
-				parentAncestorScreenAnimationSources,
-			]);
-
-			const ancestorDescendantScreenAnimationRegistrars = useMemo(() => {
-				if (!parentRegisterDescendantScreenAnimationSource) {
-					return [];
-				}
-
-				// Each provider exposes its own descendant registrar and forwards ancestor
-				// registrars, letting a mounted child register with every ancestor scope.
-				return [
-					{
-						register: parentRegisterDescendantScreenAnimationSource,
-						depth: 1,
-					},
-					...(parentAncestorDescendantScreenAnimationRegistrars ?? []).map(
-						(registrar) => ({
-							register: registrar.register,
-							depth: registrar.depth + 1,
-						}),
-					),
-				];
-			}, [
-				parentRegisterDescendantScreenAnimationSource,
-				parentAncestorDescendantScreenAnimationRegistrars,
-			]);
-
-			useLayoutEffect(() => {
-				const cleanups = ancestorDescendantScreenAnimationRegistrars.map(
-					(registrar) =>
-						registrar.register(
-							selfScreenAnimationTransitionSource,
-							registrar.depth,
-						),
-				);
-
-				return () => {
-					for (const cleanup of cleanups) {
-						cleanup();
-					}
-				};
-			}, [
-				ancestorDescendantScreenAnimationRegistrars,
-				selfScreenAnimationTransitionSource,
-			]);
-
-			return {
-				value: {
-					screenInterpolatorProps,
-					screenInterpolatorPropsRevision,
-					selectedInterpolatorOptions,
-					nextInterpolator,
-					currentInterpolator,
-					ancestorScreenAnimationSources,
-					descendantScreenAnimationSources,
-					registerDescendantScreenAnimationSource,
-					ancestorDescendantScreenAnimationRegistrars,
-				},
-			};
-		},
-	);
+			}),
+			[
+				pipeline.screenInterpolatorProps,
+				pipeline.screenInterpolatorPropsRevision,
+			],
+		);
+		const ancestorSources =
+			useOptionalScreenAnimationStore(
+				relationships.parentScreenKey,
+				(store) => store.transitionSourcesThroughSelf,
+			) ?? EMPTY_TRANSITION_SOURCES;
+		const descendantSources =
+			useOptionalScreenAnimationStore(
+				relationships.activeChildScreenKey,
+				(store) => store.transitionSourcesFromSelf,
+			) ?? EMPTY_TRANSITION_SOURCES;
+		const transitionSourcesThroughSelf = useMemo(
+			() => [...ancestorSources, screenAnimationSource],
+			[ancestorSources, screenAnimationSource],
+		);
+		const transitionSourcesFromSelf = useMemo(
+			() => [screenAnimationSource, ...descendantSources],
+			[screenAnimationSource, descendantSources],
+		);
+		const transitionSources = useMemo(
+			() => [...transitionSourcesThroughSelf, ...descendantSources],
+			[transitionSourcesThroughSelf, descendantSources],
+		);
+
+		return {
+			key: currentScreenKey,
+			value: {
+				...pipeline,
+				transitionSources,
+				transitionOriginIndex: ancestorSources.length,
+				transitionSourcesThroughSelf,
+				transitionSourcesFromSelf,
+			},
+		};
+	});

package/src/providers/screen/animation/helpers/accessors/use-build-transition-accessor.ts

@@ -3,18 +3,18 @@ import type {
 	ScreenInterpolationProps,
 	ScreenTransitionTarget,
 } from "../../../../../types/animation.types";
-import { createBoundsAccessor } from "../../../../../utils/bounds";
-import { useScreenAnimationStore } from "../../animation.provider";
-import type {
-	ScreenAnimationDescendantSources,
-	ScreenAnimationSource,
-	ScreenAnimationTransitionSource,
-} from "../../types";
+import type { ScreenAnimationContextValue } from "../../animation.provider";
+import type { ScreenAnimationTransitionSource } from "../../types";
 
 type TransitionSourceIndex = number;
 
 export type TransitionAccessorSource = ScreenAnimationTransitionSource;
 
+type TransitionAccessorStore = Pick<
+	ScreenAnimationContextValue,
+	"transitionSources" | "transitionOriginIndex"
+>;
+
 const resolveTargetIndex = (
 	target: ScreenTransitionTarget | undefined,
 	currentIndex: TransitionSourceIndex,
@@ -40,29 +40,9 @@ const resolveTargetIndex = (
 export const createTransitionAccessor = (
 	sources: readonly TransitionAccessorSource[],
 	originIndex = 0,
-	descendantSources?: ScreenAnimationDescendantSources,
 ) => {
 	"worklet";
 
-	const getSources = (): readonly TransitionAccessorSource[] => {
-		"worklet";
-		if (!descendantSources) {
-			return sources;
-		}
-
-		const descendants = descendantSources.get();
-		if (descendants.length === 0) {
-			return sources;
-		}
-
-		const currentSources = sources.slice();
-		for (let index = 0; index < descendants.length; index++) {
-			currentSources.push(descendants[index].source);
-		}
-
-		return currentSources;
-	};
-
 	const buildScope = (
 		sourceIndex: TransitionSourceIndex,
 		currentSources: readonly TransitionAccessorSource[],
@@ -96,66 +76,21 @@ export const createTransitionAccessor = (
 
 	return (target?: ScreenTransitionTarget): ScreenInterpolationProps | null => {
 		"worklet";
-		const currentSources = getSources();
-		const targetIndex = resolveTargetIndex(
-			target,
-			originIndex,
-			currentSources.length,
-		);
+		const targetIndex = resolveTargetIndex(target, originIndex, sources.length);
 		if (targetIndex === -1) {
 			return null;
 		}
 
-		return buildScope(targetIndex, currentSources);
+		return buildScope(targetIndex, sources);
 	};
 };
 
-const buildSourceBoundsAccessor = (source: ScreenAnimationSource) => {
-	"worklet";
-	return createBoundsAccessor(() => {
-		"worklet";
-		return source.screenInterpolatorProps.get();
-	});
-};
-
-export const useBuildTransitionAccessor = () => {
-	const {
-		screenInterpolatorProps,
-		screenInterpolatorPropsRevision,
-		ancestorScreenAnimationSources,
-		descendantScreenAnimationSources,
-	} = useScreenAnimationStore();
-
-	return useMemo(() => {
-		const selfSource = {
-			screenInterpolatorProps,
-			screenInterpolatorPropsRevision,
-		};
-
-		const transitionSources: TransitionAccessorSource[] =
-			ancestorScreenAnimationSources.map((source) => ({
-				...source,
-				boundsAccessor: buildSourceBoundsAccessor(source),
-			}));
-
-		const selfTransitionSource = {
-			...selfSource,
-			boundsAccessor: buildSourceBoundsAccessor(selfSource),
-		};
-
-		transitionSources.reverse();
-		const originIndex = transitionSources.length;
-		transitionSources.push(selfTransitionSource);
-
-		return createTransitionAccessor(
-			transitionSources,
-			originIndex,
-			descendantScreenAnimationSources,
-		);
-	}, [
-		screenInterpolatorProps,
-		screenInterpolatorPropsRevision,
-		ancestorScreenAnimationSources,
-		descendantScreenAnimationSources,
-	]);
+export const useBuildTransitionAccessor = ({
+	transitionSources,
+	transitionOriginIndex,
+}: TransitionAccessorStore) => {
+	return useMemo(
+		() => createTransitionAccessor(transitionSources, transitionOriginIndex),
+		[transitionSources, transitionOriginIndex],
+	);
 };

package/src/providers/screen/animation/helpers/build-screen-transition-options.ts

@@ -7,10 +7,6 @@ import { resolveSheetScrollGestureBehavior } from "../../../../utils/resolve-scr
 export const buildScreenTransitionOptions = (
 	options: ScreenTransitionConfig,
 ): ScreenTransitionOptions => {
-	const hasSheetScrollGestureBehavior =
-		options.sheetScrollGestureBehavior !== undefined ||
-		options.expandViaScrollView !== undefined;
-
 	return {
 		navigationMaskEnabled: options.navigationMaskEnabled,
 		gestureEnabled: options.gestureEnabled,
@@ -20,14 +16,11 @@ export const buildScreenTransitionOptions = (
 		gestureVelocityImpact: options.gestureVelocityImpact,
 		gestureSnapVelocityImpact: options.gestureSnapVelocityImpact,
 		gestureReleaseVelocityScale: options.gestureReleaseVelocityScale,
-		gestureResponseDistance: options.gestureResponseDistance,
-		gestureProgressMode: options.gestureProgressMode,
-		gestureDrivesProgress: options.gestureDrivesProgress,
-		gestureActivationArea: options.gestureActivationArea,
 		gestureSnapLocked: options.gestureSnapLocked,
-		sheetScrollGestureBehavior: hasSheetScrollGestureBehavior
-			? resolveSheetScrollGestureBehavior(options)
-			: undefined,
+		sheetScrollGestureBehavior:
+			options.sheetScrollGestureBehavior !== undefined
+				? resolveSheetScrollGestureBehavior(options)
+				: undefined,
 		backdropBehavior: options.backdropBehavior,
 	};
 };

package/src/providers/screen/animation/helpers/hydrate-transition-state/gesture-progress.ts

@@ -30,7 +30,8 @@ const resolvePanGestureAffectedProgress = (
 	"worklet";
 
 	if (hasSnapPoints) {
-		const activeGesture = gesture.active;
+		const activeGesture =
+			gesture.initiator === "none" ? null : gesture.initiator;
 		const activeAxis = isResolvedPanGestureDirection(activeGesture)
 			? getPanSnapAxisConfigForDirection(
 					getPanSnapAxisDirections(gestureDirection),
@@ -141,8 +142,8 @@ export const resolveGestureAffectedProgress = (
 	const hasSnapPoints = snapBounds !== null;
 
 	if (
-		gesture.active === "pinch-in" ||
-		gesture.active === "pinch-out" ||
+		gesture.initiator === "pinch-in" ||
+		gesture.initiator === "pinch-out" ||
 		Math.abs(gesture.normScale) > EPSILON
 	) {
 		return resolvePinchGestureAffectedProgress(

package/src/providers/screen/animation/helpers/hydrate-transition-state/index.ts

@@ -33,14 +33,6 @@ const mergeTransitionOptions = (
 		effective.gestureSnapVelocityImpact ?? base.gestureSnapVelocityImpact;
 	slot.gestureReleaseVelocityScale =
 		effective.gestureReleaseVelocityScale ?? base.gestureReleaseVelocityScale;
-	slot.gestureResponseDistance =
-		effective.gestureResponseDistance ?? base.gestureResponseDistance;
-	slot.gestureProgressMode =
-		effective.gestureProgressMode ?? base.gestureProgressMode;
-	slot.gestureDrivesProgress =
-		effective.gestureDrivesProgress ?? base.gestureDrivesProgress;
-	slot.gestureActivationArea =
-		effective.gestureActivationArea ?? base.gestureActivationArea;
 	slot.gestureSnapLocked =
 		effective.gestureSnapLocked ?? base.gestureSnapLocked;
 	slot.sheetScrollGestureBehavior =
@@ -90,9 +82,7 @@ export const hydrateTransitionState = (
 	out.gesture.dismissing = s.gesture.dismissing.get();
 	out.gesture.dragging = s.gesture.dragging.get();
 	out.gesture.settling = s.gesture.settling.get();
-	out.gesture.active = s.gesture.active.get();
-	out.gesture.initiator = out.gesture.active ?? "none";
-	out.gesture.direction = s.gesture.direction.get();
+	out.gesture.initiator = s.gesture.initiator.get() ?? "none";
 	const handoff = out.gesture.handoff;
 	const useHandoffSnapshot = out.gesture.dismissing;
 
@@ -155,10 +145,7 @@ export const hydrateTransitionState = (
 		: out.gesture.raw.rotation;
 	handoff.active = useHandoffSnapshot
 		? s.gesture.internal.snapshot.active.get()
-		: out.gesture.active;
-	handoff.direction = useHandoffSnapshot
-		? s.gesture.internal.snapshot.direction.get()
-		: out.gesture.direction;
+		: s.gesture.initiator.get();
 	out.progress = resolveGestureAffectedProgress(
 		transitionProgress,
 		out.gesture,
@@ -180,13 +167,7 @@ export const hydrateTransitionState = (
 
 	out.animating = s.progressAnimating.get();
 
-	out.gesture.normalizedX = out.gesture.normX;
-	out.gesture.normalizedY = out.gesture.normY;
-	out.gesture.isDismissing = out.gesture.dismissing;
-	out.gesture.isDragging = out.gesture.dragging;
-
 	out.settled = s.progressSettled.get();
-	out.logicallySettled = out.settled;
 
 	out.meta = s.meta;
 	out.options = options;

package/src/providers/screen/animation/helpers/hydrate-transition-state/types.ts

@@ -11,7 +11,6 @@ import type { BaseStackRoute } from "../../../../../types/stack.types";
 export type BuiltState = {
 	transitionProgress: SharedValue<number>;
 	visualProgress: SharedValue<number>;
-	stackProgress: SharedValue<number>;
 	willAnimate: SharedValue<number>;
 	closing: SharedValue<number>;
 	progressAnimating: SharedValue<number>;

package/src/providers/screen/animation/helpers/pipeline.ts

@@ -11,20 +11,21 @@ import {
 	createScreenTransitionState,
 	DEFAULT_SCREEN_TRANSITION_STATE,
 } from "../../../../constants";
-import { useStack } from "../../../../hooks/navigation/use-stack";
+import { AnimationStore } from "../../../../stores/animation.store";
 import type {
 	ScreenInterpolationProps,
 	ScreenStyleInterpolator,
 	ScreenTransitionState,
 } from "../../../../types/animation.types";
-
+import { useBlankStackStore } from "../../../stack/blank-stack.provider";
+import { useStackCoreStore } from "../../../stack/core.provider";
 import { type BaseDescriptor, useDescriptorsStore } from "../../descriptors";
 import { buildScreenTransitionOptions } from "./build-screen-transition-options";
 import { updateDerivations } from "./derivations";
 import { hasTransitionsEnabled } from "./has-transitions-enabled";
 import { hydrateTransitionState } from "./hydrate-transition-state";
 import type { SelectedInterpolatorOptions } from "./selected-interpolator-options";
-import { resolveStackProgress } from "./stack-progress";
+import { readStackProgress, type StackProgressEntry } from "./stack-progress";
 import { useBuildTransitionState } from "./use-build-transition-state";
 import { toPlainRoute, toPlainValue } from "./worklet";
 
@@ -83,7 +84,6 @@ const applyInitialProgress = ({
 	state.animating = animating;
 	state.willAnimate = willAnimate;
 	state.settled = settled;
-	state.logicallySettled = settled;
 	state.layouts.screen = dimensions;
 
 	return state;
@@ -186,7 +186,6 @@ const createInitialInterpolatorProps = ({
 		progress: 0,
 		transitionProgress: 0,
 		stackProgress: 0,
-		logicallySettled: 1,
 		focused: true,
 		active: current,
 		inactive: undefined,
@@ -194,7 +193,6 @@ const createInitialInterpolatorProps = ({
 
 	updateDerivations(frame);
 	frame.stackProgress = frame.progress;
-	frame.logicallySettled = frame.active.settled;
 
 	return frame;
 };
@@ -212,6 +210,8 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 	prevAnimation,
 	nextHasTransitions,
 	interpolatorOptions,
+	stackProgressEntries,
+	currentRouteKey,
 }: {
 	frame: TFrame;
 	dimensions: ScreenInterpolatorFrame["layouts"]["screen"];
@@ -221,6 +221,8 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 	prevAnimation: BuiltTransitionState | undefined;
 	nextHasTransitions: boolean;
 	interpolatorOptions: SelectedInterpolatorOptions;
+	stackProgressEntries: readonly StackProgressEntry[];
+	currentRouteKey: string;
 }): TFrame => {
 	"worklet";
 	const shouldApplyOptionsToCurrent = interpolatorOptions.owner === "current";
@@ -228,12 +230,6 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 		interpolatorOptions.owner === "next" &&
 		!!nextAnimation &&
 		nextHasTransitions;
-	const previousCurrentProgress = currentAnimation?.visualProgress.get();
-	const previousNextProgress =
-		nextAnimation && nextHasTransitions
-			? nextAnimation.visualProgress.get()
-			: undefined;
-
 	frame.previous = prevAnimation
 		? hydrateTransitionState(prevAnimation, dimensions)
 		: undefined;
@@ -260,33 +256,38 @@ const hydrateInterpolatorFrame = <TFrame extends ScreenInterpolatorFrame>({
 
 	updateDerivations(frame);
 
-	frame.stackProgress = resolveStackProgress(
-		currentAnimation?.stackProgress,
+	frame.stackProgress = readStackProgress(
+		stackProgressEntries,
+		currentRouteKey,
 		frame.progress,
-		frame.current.progress,
-		previousCurrentProgress,
-		frame.next?.progress,
-		previousNextProgress,
 	);
-	frame.logicallySettled = frame.active.settled;
 
 	return frame;
 };
 
 export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
-	const transitionsAlwaysOn = useStack(
-		(stack) => stack.flags.TRANSITIONS_ALWAYS_ON,
+	const transitionsAlwaysOn = useStackCoreStore(
+		(store) => store.flags.TRANSITIONS_ALWAYS_ON,
 	);
+	const routeKeys = useBlankStackStore((store) => store.routeKeys);
 	const dimensions = useWindowDimensions();
 	const insets = useSafeAreaInsets();
+	const stackProgressEntries = useMemo(
+		() =>
+			routeKeys.map((routeKey) => ({
+				routeKey,
+				visualProgress: AnimationStore.getValue(routeKey, "visualProgress"),
+			})),
+		[routeKeys],
+	);
 
 	const currDescriptor = useDescriptorsStore((store) => store.current);
 	const nextDescriptor = useDescriptorsStore((store) => store.next);
 	const prevDescriptor = useDescriptorsStore((store) => store.previous);
-
 	const currentAnimation = useBuildTransitionState(currDescriptor);
 	const nextAnimation = useBuildTransitionState(nextDescriptor);
 	const prevAnimation = useBuildTransitionState(prevDescriptor);
+	const currentRouteKey = currDescriptor.route.key;
 
 	const nextRouteKey = nextDescriptor?.route?.key;
 	const nextHasTransitions =
@@ -326,15 +327,13 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 				prevAnimation,
 				nextHasTransitions,
 				interpolatorOptions,
+				stackProgressEntries,
+				currentRouteKey,
 			});
 		}, false);
 
-		// Critical reactive dependency for `screenInterpolatorProps`.
-		//
-		// `screenInterpolatorProps` is mutated in place to avoid allocating a large
-		// interpolator frame every tick. Consumers must read this revision before
-		// reading `screenInterpolatorProps`, otherwise Reanimated may not subscribe
-		// to frame updates and can observe stale transition state.
+		// `screenInterpolatorProps` is mutated in place. Consumers read this
+		// revision first so Reanimated subscribes to the hydrated frame.
 		propsRevisionState.modify((revision) => {
 			"worklet";
 			revision.value += 1;
@@ -345,7 +344,7 @@ export function useScreenAnimationPipeline(): ScreenAnimationPipeline {
 	});
 
 	const nextInterpolator = nextDescriptor?.options.screenStyleInterpolator;
-	const currentInterpolator = currDescriptor?.options.screenStyleInterpolator;
+	const currentInterpolator = currDescriptor.options.screenStyleInterpolator;
 
 	return {
 		screenInterpolatorProps,