react-native-screen-transitions 4.0.0-alpha.9 → 4.1.0-alpha.0

package/src/providers/screen/gestures/ownership/use-register-gesture-ownership.ts

@@ -0,0 +1,73 @@
+import { useLayoutEffect, useMemo } from "react";
+import type { SharedValue } from "react-native-reanimated";
+import {
+	type ClaimedDirections,
+	NO_CLAIMS,
+} from "../../../../types/ownership.types";
+import { useBlankStackStore } from "../../../stack/blank-stack.provider";
+import { type BaseDescriptor, useDescriptorsStore } from "../../descriptors";
+import { resolveScreenGestureConfig } from "../shared/policy";
+import type { GestureOwnerMap, ScreenGestureSource } from "../types";
+import { gestureOwnershipCoordinator } from "./gesture-ownership-coordinator";
+import { resolveShadowingClaimDirections } from "./shadowing-claims";
+
+const getDescriptorIsFirstKey = (descriptor: BaseDescriptor): boolean => {
+	const routes = descriptor.navigation.getState()?.routes ?? [];
+	return routes.findIndex((route) => route.key === descriptor.route.key) === 0;
+};
+
+const getDescriptorClaimedDirections = (
+	descriptor: BaseDescriptor | undefined,
+): ClaimedDirections => {
+	if (!descriptor) return NO_CLAIMS;
+
+	return resolveScreenGestureConfig({
+		options: descriptor.options,
+		isFirstKey: getDescriptorIsFirstKey(descriptor),
+	}).participation.claimedDirections;
+};
+
+export const useRegisterGestureOwnership = ({
+	claimedDirections,
+	owners,
+	source,
+}: {
+	claimedDirections: ClaimedDirections;
+	owners: SharedValue<GestureOwnerMap>;
+	source: ScreenGestureSource;
+}) => {
+	const previous = useDescriptorsStore((store) => store.descriptors.previous);
+	const isClosing = useBlankStackStore(
+		(store) => store.scenesByKey[source.routeKey]?.activity === "closing",
+	);
+	const previousClaimedDirections = useMemo(
+		() => getDescriptorClaimedDirections(previous),
+		[previous],
+	);
+	const effectiveClaimedDirections = useMemo(
+		() =>
+			resolveShadowingClaimDirections({
+				isCurrentScreenClosing: isClosing,
+				currentClaimedDirections: claimedDirections,
+				previousClaimedDirections,
+			}),
+		[claimedDirections, isClosing, previousClaimedDirections],
+	);
+
+	useLayoutEffect(() => {
+		gestureOwnershipCoordinator.register({
+			screenKey: source.routeKey,
+			source,
+			claimedDirections,
+			effectiveClaimedDirections,
+			owners,
+		});
+	}, [claimedDirections, effectiveClaimedDirections, owners, source]);
+
+	useLayoutEffect(
+		() => () => {
+			gestureOwnershipCoordinator.unregister(source.routeKey);
+		},
+		[source.routeKey],
+	);
+};

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

@@ -5,12 +5,11 @@ import {
 	type ScrollGestureState,
 } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
-import { shouldDeferToChildClaim } from "../../ownership/resolve-ownership";
 import { getPanSnapAxisConfigForDirection } from "../../shared/directions";
 import { resolveRuntimeSnapPoints } from "../../shared/snap-points";
 import type {
-	DirectionClaimMap,
 	GestureDimensions,
+	GestureOwnerMap,
 	PanGestureRuntime,
 } from "../../types";
 import {
@@ -23,7 +22,6 @@ export type PanActivationAction = "activate" | "fail" | "wait";
 export type PanActivationReason =
 	| "ancestor-dismissing"
 	| "already-dragging"
-	| "child-claim"
 	| "disabled"
 	| "dismissing"
 	| "multi-touch"
@@ -51,7 +49,7 @@ interface ResolvePanActivationMoveDecisionProps {
 	initialTouch: { x: number; y: number };
 	activationState: GestureActivationState;
 	ancestorDismissing: boolean;
-	childDirectionClaims: DirectionClaimMap;
+	gestureOwners: GestureOwnerMap;
 	currentScreenKey: string;
 	scrollState: ScrollGestureState | null;
 }
@@ -147,9 +145,8 @@ const resolveOffsetFailureDecision = (
 
 const resolveDirectionGateDecision = (
 	swipeDirection: Direction | null,
-	runtime: PanGestureRuntime,
 	offset: OffsetRuleResult,
-	childDirectionClaims: DirectionClaimMap,
+	gestureOwners: GestureOwnerMap,
 	currentScreenKey: string,
 ): PanActivationDecision | null => {
 	"worklet";
@@ -162,7 +159,7 @@ const resolveDirectionGateDecision = (
 		);
 	}
 
-	if (runtime.participation.ownershipStatus[swipeDirection] !== "self") {
+	if (gestureOwners[swipeDirection] !== currentScreenKey) {
 		return createDecision(
 			"fail",
 			"ownership",
@@ -171,16 +168,6 @@ const resolveDirectionGateDecision = (
 		);
 	}
 
-	const childClaim = childDirectionClaims[swipeDirection];
-	if (shouldDeferToChildClaim(childClaim, currentScreenKey)) {
-		return createDecision(
-			"fail",
-			"child-claim",
-			swipeDirection,
-			offset.nextActivationState,
-		);
-	}
-
 	if (offset.nextActivationState !== GestureActivationState.PASSED) {
 		return createDecision(
 			"wait",
@@ -389,7 +376,7 @@ export const resolvePanActivationMoveDecision = ({
 	initialTouch,
 	activationState,
 	ancestorDismissing,
-	childDirectionClaims,
+	gestureOwners,
 	currentScreenKey,
 	scrollState,
 }: ResolvePanActivationMoveDecisionProps): PanActivationDecision => {
@@ -427,9 +414,8 @@ export const resolvePanActivationMoveDecision = ({
 	const swipeDirection = getSwipeDirection(offset);
 	const directionGateDecision = resolveDirectionGateDecision(
 		swipeDirection,
-		runtime,
 		offset,
-		childDirectionClaims,
+		gestureOwners,
 		currentScreenKey,
 	);
 	if (directionGateDecision) return directionGateDecision;

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

@@ -12,9 +12,9 @@ import type { ScreenOptionsContextValue } from "../../../options";
 import { useCurrentScreenRelationships } from "../../../use-current-screen-relationships";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
-	DirectionClaimMap,
 	GestureCompositionOwner,
 	GestureDimensions,
+	GestureOwnerMap,
 	PanGestureRuntime,
 	ScrollGestureState,
 } from "../../types";
@@ -22,7 +22,7 @@ import { resolvePanActivationMoveDecision } from "./pan-activation-decision";
 
 interface UsePanActivationProps {
 	scrollState: SharedValue<ScrollGestureState | null>;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
+	gestureOwners: SharedValue<GestureOwnerMap>;
 	runtime: SharedValue<PanGestureRuntime>;
 	screenOptions: ScreenOptionsContextValue;
 	dimensions: GestureDimensions;
@@ -31,7 +31,7 @@ interface UsePanActivationProps {
 
 export const usePanActivation = ({
 	scrollState,
-	childDirectionClaims,
+	gestureOwners,
 	runtime,
 	screenOptions,
 	dimensions,
@@ -114,7 +114,7 @@ export const usePanActivation = ({
 				initialTouch: initialTouch.get(),
 				activationState: currentActivationState,
 				ancestorDismissing: Boolean(ancestorDismissing?.get()),
-				childDirectionClaims: childDirectionClaims.get(),
+				gestureOwners: gestureOwners.get(),
 				currentScreenKey,
 				scrollState: scrollState.get(),
 			});
@@ -141,12 +141,12 @@ export const usePanActivation = ({
 		},
 		[
 			ancestorDismissing,
-			childDirectionClaims,
 			currentScreenKey,
 			dimensions,
 			gestureActivationState,
 			initialTouch,
 			pendingDirection,
+			gestureOwners,
 			runtime,
 			screenOptions,
 			scrollState,

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

@@ -5,8 +5,8 @@ import type { SharedValue } from "react-native-reanimated";
 import { useScreenOptionsStore } from "../../options";
 import { useStableRuntimeConfig } from "../hooks/use-stable-runtime-config";
 import type {
-	DirectionClaimMap,
 	GestureCompositionOwner,
+	GestureOwnerMap,
 	PanGesture,
 	ScreenGestureConfig,
 	ScrollGestureState,
@@ -17,14 +17,14 @@ import { usePanBehavior } from "./behavior/use-pan-behavior";
 interface UseBuildPanGestureProps {
 	scrollState: SharedValue<ScrollGestureState | null>;
 	gestureConfig: ScreenGestureConfig;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
+	gestureOwners: SharedValue<GestureOwnerMap>;
 	gestureCompositionOwner: SharedValue<GestureCompositionOwner>;
 }
 
 export const useBuildPanGesture = ({
 	scrollState,
 	gestureConfig,
-	childDirectionClaims,
+	gestureOwners,
 	gestureCompositionOwner,
 }: UseBuildPanGestureProps): PanGesture => {
 	const dimensions = useWindowDimensions();
@@ -38,7 +38,7 @@ export const useBuildPanGesture = ({
 
 	const activation = usePanActivation({
 		scrollState,
-		childDirectionClaims,
+		gestureOwners,
 		runtime,
 		screenOptions,
 		dimensions,

package/src/providers/screen/gestures/scroll-coordination/use-scroll-gesture-coordination.ts

@@ -11,6 +11,7 @@ import useStableCallback from "../../../../hooks/use-stable-callback";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { ScrollStore } from "../../../../stores/scroll.store";
 import { useOptionalScreenGestureStore } from "../gestures.provider";
+import { useGestureScrollCoordination } from "../ownership/use-gesture-scroll-coordination";
 import type {
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
@@ -26,7 +27,6 @@ import {
 	updateScrollGestureAxisState,
 	updateScrollMetadataAxisState,
 } from "./update-scroll-gesture-state";
-import { walkUpScrollGestureCoordination } from "./walk-up-scroll-gesture-coordination";
 
 interface ScrollGestureCoordinationProps {
 	onContentSizeChange?: (width: number, height: number) => void;
@@ -90,10 +90,9 @@ export const useScrollGestureCoordination = (
 ) => {
 	const context = useOptionalScreenGestureStore();
 	const scrollDirection = props.direction ?? "vertical";
-	const gesturePath = useMemo(
-		() => (context ? [context, ...context.ancestorGestures] : []),
-		[context],
-	);
+	const routeKey = context?.routeKey ?? null;
+	const { scrollStates, panGestures, pinchGestures, ownerRouteKeys } =
+		useGestureScrollCoordination(routeKey, scrollDirection);
 
 	const metadataOwnerContext = useOptionalScrollMetadataOwnerStore();
 	const metadataOwnerProviderValue =
@@ -104,12 +103,6 @@ export const useScrollGestureCoordination = (
 	);
 	const [writesMetadata, setWritesMetadata] = useState(false);
 
-	const { scrollStates, panGestures, pinchGestures, ownerRouteKeys } = useMemo(
-		() => walkUpScrollGestureCoordination(gesturePath, scrollDirection),
-		[gesturePath, scrollDirection],
-	);
-
-	const routeKey = context?.routeKey;
 	const metadataState = useMemo(
 		() => (routeKey ? ScrollStore.getValue(routeKey, "metadata") : null),
 		[routeKey],
@@ -174,7 +167,10 @@ export const useScrollGestureCoordination = (
 	);
 
 	const nativeGesture = useMemo(() => {
-		if (panGestures.length === 0 && pinchGestures.length === 0) return null;
+		// Ownership registrations disappear while a screen's Activity is paused.
+		// Keep its detector mounted through that gap: removing the wrapper remounts
+		// scroll children and loses state, including captured boundary measurements.
+		if (!routeKey) return null;
 
 		const setIsTouched = () => {
 			"worklet";
@@ -230,6 +226,7 @@ export const useScrollGestureCoordination = (
 
 		return gesture;
 	}, [
+		routeKey,
 		panGestures,
 		pinchGestures,
 		scrollStates,

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

@@ -24,13 +24,11 @@ import type {
 	SnapPoint,
 } from "../../../../types/screen.types";
 import { computeClaimedDirections } from "../ownership/compute-claimed-directions";
-import { resolveOwnership } from "../ownership/resolve-ownership";
 import type {
 	PanGesturePolicy,
 	PinchGesturePolicy,
 	ScreenGestureConfig,
 	ScreenGestureParticipation,
-	ScreenGestureSource,
 } from "../types";
 import {
 	getGestureDirectionEntries,
@@ -293,11 +291,9 @@ export const resolvePinchPolicy = (
 const resolveGestureParticipation = ({
 	options,
 	isFirstKey,
-	ancestorGestures,
 }: {
 	options: GesturePolicyOptions;
 	isFirstKey: boolean;
-	ancestorGestures: readonly ScreenGestureSource[];
 }): ScreenGestureParticipation => {
 	const canDismiss = resolveGestureCanDismiss({
 		isFirstKey,
@@ -325,23 +321,19 @@ const resolveGestureParticipation = ({
 		canTrackGesture,
 		effectiveSnapPoints,
 		claimedDirections,
-		ownershipStatus: resolveOwnership(claimedDirections, ancestorGestures),
 	};
 };
 
 export const resolveScreenGestureConfig = ({
 	options,
 	isFirstKey,
-	ancestorGestures,
 }: {
 	options: ScreenTransitionConfig;
 	isFirstKey: boolean;
-	ancestorGestures: readonly ScreenGestureSource[];
 }): ScreenGestureConfig => {
 	const participation = resolveGestureParticipation({
 		options,
 		isFirstKey,
-		ancestorGestures,
 	});
 	const hasSnapPoints = participation.effectiveSnapPoints.hasSnapPoints;
 

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

@@ -25,7 +25,7 @@ import type {
 } from "../../../types/gesture.types";
 import type {
 	ClaimedDirections,
-	DirectionOwnership,
+	Direction,
 } from "../../../types/ownership.types";
 import type { ScreenTransitionConfig } from "../../../types/screen.types";
 import type { EffectiveSnapPointsResult } from "./shared/snap-points";
@@ -52,19 +52,9 @@ export type {
 	ScrollMetadataState,
 };
 
-export type DirectionClaim = {
-	routeKey: string;
-	isDismissing: SharedValue<number>;
-} | null;
-
-export type DirectionClaimMap = {
-	vertical: DirectionClaim;
-	"vertical-inverted": DirectionClaim;
-	horizontal: DirectionClaim;
-	"horizontal-inverted": DirectionClaim;
-};
+export type GestureOwnerMap = Record<Direction, string | null>;
 
-export const NO_DIRECTION_CLAIMS: DirectionClaimMap = {
+export const NO_GESTURE_OWNERS: GestureOwnerMap = {
 	vertical: null,
 	"vertical-inverted": null,
 	horizontal: null,
@@ -77,13 +67,9 @@ export interface ScreenGestureSource {
 	panGesture: PanGesture;
 	pinchGesture: PinchGesture;
 	scrollState: SharedValue<ScrollGestureState | null>;
-	claimedDirections: ClaimedDirections;
-	childDirectionClaims: SharedValue<DirectionClaimMap>;
 }
 
-export interface GestureContextType extends ScreenGestureSource {
-	ancestorGestures: readonly ScreenGestureSource[];
-}
+export type GestureContextType = ScreenGestureSource;
 
 export interface ScreenGestureParticipation {
 	/** Whether this route is the first route in its stack. First routes never track gestures. */
@@ -94,7 +80,6 @@ export interface ScreenGestureParticipation {
 	canTrackGesture: boolean;
 	effectiveSnapPoints: EffectiveSnapPointsResult;
 	claimedDirections: ClaimedDirections;
-	ownershipStatus: DirectionOwnership;
 }
 
 export interface ScreenGestureConfig {

package/src/providers/screen/screen-composer.tsx

@@ -2,44 +2,33 @@ import type React from "react";
 import { ScreenContainer } from "../../components/screen-container";
 import { ScreenLifecycle } from "../../components/screen-lifecycle";
 import { ScreenAnimationProvider } from "./animation";
-import { type BaseDescriptor, DescriptorsProvider } from "./descriptors";
+import { DescriptorsProvider } from "./descriptors";
 import { ScreenGestureProvider } from "./gestures";
 import { ScreenOptionsProvider } from "./options";
 import { ScreenSlotProvider } from "./styles";
+import { ScreenTopologyProvider } from "./topology";
 
 type Props = {
-	previous?: BaseDescriptor;
-	current?: BaseDescriptor;
-	next?: BaseDescriptor;
-	routeKey?: string;
+	routeKey: string;
 	children: React.ReactNode;
 };
 
-export function ScreenComposer({
-	previous,
-	current,
-	next,
-	routeKey,
-	children,
-}: Props) {
+export function ScreenComposer({ routeKey, children }: Props) {
 	return (
-		<DescriptorsProvider
-			previous={previous}
-			current={current}
-			next={next}
-			routeKey={routeKey}
-		>
-			<ScreenLifecycle>
-				<ScreenOptionsProvider>
-					<ScreenGestureProvider>
-						<ScreenAnimationProvider>
-							<ScreenSlotProvider>
-								<ScreenContainer>{children}</ScreenContainer>
-							</ScreenSlotProvider>
-						</ScreenAnimationProvider>
-					</ScreenGestureProvider>
-				</ScreenOptionsProvider>
-			</ScreenLifecycle>
+		<DescriptorsProvider routeKey={routeKey}>
+			<ScreenTopologyProvider>
+				<ScreenLifecycle>
+					<ScreenOptionsProvider>
+						<ScreenGestureProvider>
+							<ScreenAnimationProvider>
+								<ScreenSlotProvider>
+									<ScreenContainer>{children}</ScreenContainer>
+								</ScreenSlotProvider>
+							</ScreenAnimationProvider>
+						</ScreenGestureProvider>
+					</ScreenOptionsProvider>
+				</ScreenLifecycle>
+			</ScreenTopologyProvider>
 		</DescriptorsProvider>
 	);
 }

package/src/providers/screen/styles/constants.ts

@@ -22,6 +22,7 @@ const IDENTITY_TRANSFORM = [
  * please add its identity value here in a PR.
  */
 export const STYLE_RESET_VALUES: Record<string, unknown> = {
+	filter: [{ blur: 0.01 }],
 	transform: IDENTITY_TRANSFORM,
 	translateX: 0,
 	translateY: 0,
@@ -67,6 +68,7 @@ export const PROP_RESET_VALUES: Record<string, unknown> = {
 const RESERVED_STYLE_SLOT_IDS = {
 	overlay: true,
 	content: true,
+	surface: true,
 	backdrop: true,
 	[NAVIGATION_MASK_ELEMENT_STYLE_ID]: true,
 	[NAVIGATION_MASK_CONTAINER_STYLE_ID]: true,

package/src/providers/screen/styles/helpers/create-interpolator-scope.ts

@@ -1,7 +1,4 @@
-import type {
-	ScreenInterpolationProps,
-	ScreenTransitionAccessor,
-} from "../../../../types/animation.types";
+import type { ScreenInterpolationProps } from "../../../../types/animation.types";
 import { createBoundsAccessor } from "../../../../utils/bounds";
 import type { ScreenInterpolatorFrame } from "../../animation/helpers/pipeline";
 import type { SelectedInterpolatorFrame } from "./select-interpolator-frame";
@@ -9,11 +6,9 @@ import type { SelectedInterpolatorFrame } from "./select-interpolator-frame";
 export const createInterpolatorScope = ({
 	frame,
 	selectedFrame,
-	transition,
 }: {
 	frame: ScreenInterpolatorFrame;
 	selectedFrame: SelectedInterpolatorFrame;
-	transition: ScreenTransitionAccessor;
 }): ScreenInterpolationProps => {
 	"worklet";
 
@@ -21,25 +16,11 @@ export const createInterpolatorScope = ({
 		...frame,
 		...selectedFrame,
 	};
-	let scope: ScreenInterpolationProps;
-	const scopedTransition: ScreenTransitionAccessor = (target) => {
-		"worklet";
-
-		if ((target?.depth ?? 0) === 0) {
-			return scope;
-		}
-
-		return transition(target);
-	};
-
-	scope = {
+	return {
 		...selectedProps,
 		bounds: createBoundsAccessor(() => {
 			"worklet";
 			return selectedProps;
 		}),
-		transition: scopedTransition,
 	};
-
-	return scope;
 };

package/src/providers/screen/styles/hooks/slot-resolvers.tsx

@@ -1,29 +1,14 @@
 import { useMemo } from "react";
 import { useAnimatedProps, useAnimatedStyle } from "react-native-reanimated";
 import { NO_PROPS, NO_STYLES } from "../../../../constants";
-import { useNavigationRoute } from "../../../navigation/navigation-host.provider";
 import {
 	composeSlotStyleWithLocalTransform,
 	getLocalTransformForSlotComposition,
 } from "../helpers/compose-slot-style";
-import { useOptionalScreenSlotStore } from "../slot.provider";
+import { useScreenSlotStore } from "../slot.provider";
 
 const useCurrentScreenSlotsMap = () => {
-	const routeKey = useNavigationRoute().key;
-	const localSlotsMap = useOptionalScreenSlotStore(
-		(store) => store?.slotsMap ?? null,
-	);
-	const keyedSlotsMap = useOptionalScreenSlotStore(
-		localSlotsMap ? null : routeKey,
-		(store) => store.slotsMap,
-	);
-	const slotsMap = localSlotsMap ?? keyedSlotsMap;
-
-	if (!slotsMap) {
-		throw new Error(`ScreenSlotStore is unavailable for route "${routeKey}"`);
-	}
-
-	return slotsMap;
+	return useScreenSlotStore((store) => store.slotsMap);
 };
 
 export const useSlotStyles = (slotId: string | undefined) => {

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

@@ -1,4 +1,3 @@
-import { useMemo } from "react";
 import {
 	type SharedValue,
 	useAnimatedReaction,
@@ -18,16 +17,13 @@ import type {
 } from "../../../../types/animation.types";
 import { logger } from "../../../../utils/logger";
 import { useScreenAnimationStore } from "../../animation";
-import { useBuildTransitionAccessor } from "../../animation/helpers/accessors/use-build-transition-accessor";
 import type { ScreenInterpolatorFrame } from "../../animation/helpers/pipeline";
-import { readScreenAnimationRevisions } from "../../animation/helpers/read-screen-animation-revisions";
 import { syncSelectedInterpolatorOptions } from "../../animation/helpers/selected-interpolator-options";
 import { useDescriptorsStore } from "../../descriptors";
 import {
 	syncScreenOptionsOverrides,
 	useScreenOptionsStore,
 } from "../../options";
-import { collectInterpolatorSharedValues } from "../helpers/collect-interpolator-shared-values";
 import { createInterpolatorScope } from "../helpers/create-interpolator-scope";
 import { normalizeSlots } from "../helpers/normalize-slots";
 import { resolveInterpolatorStyleHandoff } from "../helpers/resolve-interpolator-style-handoff";
@@ -55,7 +51,6 @@ type RunInterpolatorParams = {
 	interpolator: ScreenStyleInterpolator | undefined;
 	props: ScreenInterpolatorFrame;
 	selectedFrame: SelectedInterpolatorFrame;
-	transition: Parameters<ScreenStyleInterpolator>[0]["transition"];
 };
 
 const normalizeRawStyleMap = (
@@ -76,7 +71,6 @@ const runInterpolator = ({
 	interpolator,
 	props,
 	selectedFrame,
-	transition,
 }: RunInterpolatorParams): InterpolatorResult | undefined => {
 	"worklet";
 
@@ -89,7 +83,6 @@ const runInterpolator = ({
 			createInterpolatorScope({
 				frame: props,
 				selectedFrame,
-				transition,
 			}),
 		);
 
@@ -157,16 +150,6 @@ export const useInterpolatedStylesMap = ({
 	const currentInterpolator = useScreenAnimationStore(
 		(store) => store.currentInterpolator,
 	);
-	const transitionSources = useScreenAnimationStore(
-		(store) => store.transitionSources,
-	);
-	const transitionOriginIndex = useScreenAnimationStore(
-		(store) => store.transitionOriginIndex,
-	);
-	const transition = useBuildTransitionAccessor({
-		transitionSources,
-		transitionOriginIndex,
-	});
 	const hasCurrentInterpolator = !!currentInterpolator;
 	const { closing: currentClosing, entering: currentEntering } =
 		AnimationStore.getBag(currentScreenKey);
@@ -194,14 +177,6 @@ export const useInterpolatedStylesMap = ({
 			: 0;
 	});
 
-	// In some cases, a user may want to use external shared values to drive animations in the interpoaltor.
-	// We can now support this by collecting those shared values and reading them here to trigger an update.
-	const interpolatorSharedValues = useMemo(
-		() =>
-			collectInterpolatorSharedValues([currentInterpolator, nextInterpolator]),
-		[currentInterpolator, nextInterpolator],
-	);
-
 	const activeScreenKey = nextScreenKey ?? currentScreenKey;
 	const { closing: activeClosing, entering: activeEntering } =
 		AnimationStore.getBag(activeScreenKey);
@@ -236,8 +211,6 @@ export const useInterpolatedStylesMap = ({
 	);
 
 	const localStylesMaps = useDerivedValue<LocalStyleLayers>(() => {
-		"worklet";
-		readScreenAnimationRevisions(transitionSources, interpolatorSharedValues);
 		const props = screenInterpolatorProps.get();
 
 		const { current, next } = props;
@@ -298,7 +271,6 @@ export const useInterpolatedStylesMap = ({
 			interpolator: currentInterpolator,
 			props,
 			selectedFrame: currentSelectedFrame,
-			transition,
 		});
 
 		const initialDestinationStyleGate = resolveInitialDestinationStyleGate({
@@ -335,7 +307,6 @@ export const useInterpolatedStylesMap = ({
 			interpolator: nextInterpolator,
 			props,
 			selectedFrame: nextSelectedFrame,
-			transition,
 		});
 
 		syncSelectedInterpolatorOptions(