react-native-screen-transitions 3.13.0-beta.0 → 3.13.0

package/src/shared/providers/screen/gestures/ownership/gesture-ownership-bridge.tsx

@@ -10,15 +10,14 @@ import {
 	type BaseDescriptor,
 	useDescriptorsStore,
 } from "../../../screen/descriptors";
-import { useBlankStackStore } from "../../../stack/blank-stack.provider";
-import { useGestureStore } from "../gestures.provider";
-import { walkGestureAncestors } from "../shared/ancestors";
+import { useOptionalBlankStackStore } from "../../../stack/blank-stack.provider";
+import { useScreenGestureStore } from "../gestures.provider";
 import { resolveScreenGestureConfig } from "../shared/policy";
-import type { GestureContextType } from "../types";
+import type { ScreenGestureSource } from "../types";
 import { resolveShadowingClaimDirections } from "./shadowing-claims";
 
 type ShadowedAncestor = {
-	ancestor: GestureContextType;
+	ancestor: ScreenGestureSource;
 	directions: Direction[];
 };
 
@@ -40,15 +39,15 @@ const findShadowedDirections = (
 };
 
 const findShadowedAncestors = (
-	parentContext: GestureContextType | null,
+	ancestorGestures: readonly ScreenGestureSource[],
 	claimedDirections: ClaimedDirections,
 ) => {
-	if (!parentContext) {
+	if (ancestorGestures.length === 0) {
 		return NO_SHADOWED_ANCESTORS;
 	}
 
 	const ancestors: ShadowedAncestor[] = [];
-	for (const ancestor of walkGestureAncestors(parentContext)) {
+	for (const ancestor of ancestorGestures) {
 		const directions = findShadowedDirections(
 			claimedDirections,
 			ancestor.claimedDirections,
@@ -107,7 +106,7 @@ const getDescriptorIsFirstKey = (descriptor: BaseDescriptor): boolean => {
 
 const getDescriptorClaimedDirections = (
 	descriptor: BaseDescriptor | undefined,
-	gestureContext: GestureContextType | null,
+	ancestorGestures: readonly ScreenGestureSource[],
 ): ClaimedDirections => {
 	if (!descriptor) {
 		return NO_CLAIMS;
@@ -116,32 +115,20 @@ const getDescriptorClaimedDirections = (
 	return resolveScreenGestureConfig({
 		options: descriptor.options,
 		isFirstKey: getDescriptorIsFirstKey(descriptor),
-		gestureContext,
+		ancestorGestures,
 	}).participation.claimedDirections;
 };
 
-const requireGestureContext = (
-	gestureContext: GestureContextType | null,
-): GestureContextType => {
-	if (!gestureContext) {
-		throw new Error(
-			"GestureOwnershipBridge must be rendered within a ScreenGestureProvider",
-		);
-	}
-
-	return gestureContext;
-};
-
 function ActiveGestureOwnershipBridge() {
-	const gestureContext = requireGestureContext(useGestureStore());
+	const gestureContext = useScreenGestureStore();
 	const previous = useDescriptorsStore((store) => store.previous);
-	const isCurrentScreenClosing = useBlankStackStore(
+	const isCurrentScreenClosing = useOptionalBlankStackStore(
 		(store) =>
 			store?.scenesByKey[gestureContext.routeKey]?.activity === "closing",
 	);
 	const {
 		claimedDirections,
-		gestureContext: parentContext,
+		ancestorGestures,
 		routeKey: currentScreenKey,
 	} = gestureContext;
 	// A retained closing screen cannot receive touches, so its ownership must
@@ -153,14 +140,14 @@ function ActiveGestureOwnershipBridge() {
 				currentClaimedDirections: claimedDirections,
 				previousClaimedDirections: getDescriptorClaimedDirections(
 					previous,
-					parentContext,
+					ancestorGestures,
 				),
 			}),
-		[isCurrentScreenClosing, claimedDirections, previous, parentContext],
+		[isCurrentScreenClosing, claimedDirections, previous, ancestorGestures],
 	);
 	const shadowedAncestors = useMemo(
-		() => findShadowedAncestors(parentContext, effectiveClaimedDirections),
-		[parentContext, effectiveClaimedDirections],
+		() => findShadowedAncestors(ancestorGestures, effectiveClaimedDirections),
+		[ancestorGestures, effectiveClaimedDirections],
 	);
 
 	useLayoutEffect(() => {

package/src/shared/providers/screen/gestures/ownership/resolve-ownership.ts

@@ -16,7 +16,6 @@ import type { DirectionClaim } from "../types";
  */
 interface AncestorClaimsContext {
 	claimedDirections: ClaimedDirections;
-	gestureContext: AncestorClaimsContext | null;
 }
 
 /**
@@ -31,12 +30,12 @@ interface AncestorClaimsContext {
  * used in worklets since it's a plain object.
  *
  * @param selfClaims - The directions claimed by the current screen
- * @param gestureContext - The gesture context chain (can be null if no ancestors)
+ * @param ancestors - Nearest-first ancestor gesture values from screen topology.
  * @returns Ownership status for all four directions
  */
 export function resolveOwnership(
 	selfClaims: ClaimedDirections,
-	gestureContext: AncestorClaimsContext | null,
+	ancestors: readonly AncestorClaimsContext[],
 ): DirectionOwnership {
 	const result: DirectionOwnership = { ...NO_OWNERSHIP };
 
@@ -44,7 +43,7 @@ export function resolveOwnership(
 		result[direction] = resolveDirectionOwnership(
 			direction,
 			selfClaims,
-			gestureContext,
+			ancestors,
 		);
 	}
 
@@ -57,7 +56,7 @@ export function resolveOwnership(
 function resolveDirectionOwnership(
 	direction: Direction,
 	selfClaims: ClaimedDirections,
-	gestureContext: AncestorClaimsContext | null,
+	ancestors: readonly AncestorClaimsContext[],
 ): OwnershipStatus {
 	// Check self first
 	if (selfClaims[direction]) {
@@ -65,12 +64,10 @@ function resolveDirectionOwnership(
 	}
 
 	// Walk ancestors looking for a claim
-	let ancestor = gestureContext;
-	while (ancestor) {
+	for (const ancestor of ancestors) {
 		if (ancestor.claimedDirections?.[direction]) {
 			return "ancestor";
 		}
-		ancestor = ancestor.gestureContext;
 	}
 
 	// No one claims this direction

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

@@ -9,6 +9,7 @@ import { GestureActivationState } from "../../../../../types/gesture.types";
 import type { Direction } from "../../../../../types/ownership.types";
 import { useDescriptorsStore } from "../../../descriptors";
 import type { ScreenOptionsContextValue } from "../../../options";
+import { useCurrentScreenRelationships } from "../../../use-current-screen-relationships";
 import { resolvePanRuntime } from "../../shared/runtime";
 import type {
 	DirectionClaimMap,
@@ -39,9 +40,7 @@ export const usePanActivation = ({
 	const currentScreenKey = useDescriptorsStore(
 		(store) => store.derivations.currentScreenKey,
 	);
-	const parentScreenKey = useDescriptorsStore(
-		(store) => store.derivations.parentScreenKey,
-	);
+	const { parentScreenKey } = useCurrentScreenRelationships();
 
 	const ancestorDismissing = useMemo(() => {
 		if (!parentScreenKey) return null;

package/src/shared/providers/screen/gestures/scroll-coordination/scroll-metadata-owner.tsx

@@ -14,21 +14,20 @@ const DEFAULT_SCROLL_METADATA_OWNER_CONTEXT: ScrollMetadataOwnerContextValue = {
 	horizontal: false,
 };
 
-const {
+export const {
 	ScrollMetadataOwnerProvider,
-	useScrollMetadataOwnerStore: useMaybeScrollMetadataOwnerStore,
-} = createProvider("ScrollMetadataOwner", { guarded: false })<
+	useOptionalScrollMetadataOwnerStore,
+} = createProvider("ScrollMetadataOwner")<
 	ScrollMetadataOwnerProviderProps,
 	ScrollMetadataOwnerContextValue
 >(({ children, value }) => ({ children, value }));
 
-export const useScrollMetadataOwnerStore = () =>
-	useMaybeScrollMetadataOwnerStore() ?? DEFAULT_SCROLL_METADATA_OWNER_CONTEXT;
-
 export const useScrollMetadataOwnerProviderValue = (
 	axis: ScrollGestureAxis,
 ) => {
-	const parent = useScrollMetadataOwnerStore();
+	const parent =
+		useOptionalScrollMetadataOwnerStore() ??
+		DEFAULT_SCROLL_METADATA_OWNER_CONTEXT;
 
 	return useMemo(() => {
 		if (parent[axis]) return parent;
@@ -39,5 +38,3 @@ export const useScrollMetadataOwnerProviderValue = (
 		};
 	}, [axis, parent]);
 };
-
-export { ScrollMetadataOwnerProvider };

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

@@ -10,7 +10,7 @@ import { useSharedValueState } from "../../../../hooks/reanimated/use-shared-val
 import useStableCallback from "../../../../hooks/use-stable-callback";
 import { AnimationStore } from "../../../../stores/animation.store";
 import { ScrollStore } from "../../../../stores/scroll.store";
-import { useGestureStore } from "../gestures.provider";
+import { useOptionalScreenGestureStore } from "../gestures.provider";
 import type {
 	ScrollGestureAxis,
 	ScrollGestureAxisState,
@@ -18,8 +18,8 @@ import type {
 	ScrollMetadataState,
 } from "../types";
 import {
+	useOptionalScrollMetadataOwnerStore,
 	useScrollMetadataOwnerProviderValue,
-	useScrollMetadataOwnerStore,
 } from "./scroll-metadata-owner";
 import {
 	clearScrollMetadataAxisState,
@@ -88,21 +88,25 @@ const clearScrollMetadataAxis = (
 export const useScrollGestureCoordination = (
 	props: ScrollGestureCoordinationProps,
 ) => {
-	const context = useGestureStore();
+	const context = useOptionalScreenGestureStore();
 	const scrollDirection = props.direction ?? "vertical";
+	const gesturePath = useMemo(
+		() => (context ? [context, ...context.ancestorGestures] : []),
+		[context],
+	);
 
-	const metadataOwnerContext = useScrollMetadataOwnerStore();
+	const metadataOwnerContext = useOptionalScrollMetadataOwnerStore();
 	const metadataOwnerProviderValue =
 		useScrollMetadataOwnerProviderValue(scrollDirection);
-	const isFirstMetadataWriterInTree = !metadataOwnerContext[scrollDirection];
+	const isFirstMetadataWriterInTree = !metadataOwnerContext?.[scrollDirection];
 	const [metadataWriterId] = useState(() =>
 		ScrollStore.createMetadataWriterId(),
 	);
 	const [writesMetadata, setWritesMetadata] = useState(false);
 
 	const { scrollStates, panGestures, pinchGestures, ownerRouteKeys } = useMemo(
-		() => walkUpScrollGestureCoordination(context, scrollDirection),
-		[context, scrollDirection],
+		() => walkUpScrollGestureCoordination(gesturePath, scrollDirection),
+		[gesturePath, scrollDirection],
 	);
 
 	const routeKey = context?.routeKey;

package/src/shared/providers/screen/gestures/scroll-coordination/walk-up-scroll-gesture-coordination.ts

@@ -1,19 +1,18 @@
 import type { SharedValue } from "react-native-reanimated";
 import type { Direction } from "../../../../types/ownership.types";
-import { walkGestureAncestors } from "../shared/ancestors";
 import type {
-	GestureContextType,
 	PanGesture,
 	PinchGesture,
+	ScreenGestureSource,
 	ScrollGestureAxis,
 	ScrollGestureState,
 } from "../types";
 
 /** Walks up the gesture tree until it finds the owner for a specific direction. */
 function findGestureOwnerForDirection(
-	ancestors: GestureContextType[],
+	ancestors: readonly ScreenGestureSource[],
 	direction: Direction,
-): GestureContextType | null {
+): ScreenGestureSource | null {
 	for (const ancestor of ancestors) {
 		if (ancestor.claimedDirections?.[direction]) return ancestor;
 	}
@@ -28,8 +27,10 @@ const getDirectionsForAxis = (
 		? ["vertical", "vertical-inverted"]
 		: ["horizontal", "horizontal-inverted"];
 
-const collectAncestorPinchGestures = (ancestors: GestureContextType[]) => {
-	const pinchGestures: GestureContextType["pinchGesture"][] = [];
+const collectAncestorPinchGestures = (
+	ancestors: readonly ScreenGestureSource[],
+) => {
+	const pinchGestures: ScreenGestureSource["pinchGesture"][] = [];
 
 	for (const ancestor of ancestors) {
 		if (!pinchGestures.includes(ancestor.pinchGesture)) {
@@ -41,12 +42,12 @@ const collectAncestorPinchGestures = (ancestors: GestureContextType[]) => {
 };
 
 const collectAxisOwners = (
-	ancestors: GestureContextType[],
+	ancestors: readonly ScreenGestureSource[],
 	directions: readonly [Direction, Direction],
 ) => {
-	const seenOwners: GestureContextType[] = [];
-	const panGestures: GestureContextType["panGesture"][] = [];
-	const scrollStates: GestureContextType["scrollState"][] = [];
+	const seenOwners: ScreenGestureSource[] = [];
+	const panGestures: ScreenGestureSource["panGesture"][] = [];
+	const scrollStates: ScreenGestureSource["scrollState"][] = [];
 	const ownerRouteKeys: string[] = [];
 
 	for (const direction of directions) {
@@ -73,10 +74,9 @@ interface WalkUpScrollGestureCoordinationResult {
 }
 
 export function walkUpScrollGestureCoordination(
-	context: GestureContextType | null,
+	ancestors: readonly ScreenGestureSource[],
 	axis: ScrollGestureAxis,
 ): WalkUpScrollGestureCoordinationResult {
-	const ancestors = walkGestureAncestors(context);
 	const axisOwners = collectAxisOwners(ancestors, getDirectionsForAxis(axis));
 
 	return {

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

@@ -25,11 +25,11 @@ import type {
 import { computeClaimedDirections } from "../ownership/compute-claimed-directions";
 import { resolveOwnership } from "../ownership/resolve-ownership";
 import type {
-	GestureContextType,
 	PanGesturePolicy,
 	PinchGesturePolicy,
 	ScreenGestureConfig,
 	ScreenGestureParticipation,
+	ScreenGestureSource,
 } from "../types";
 import {
 	getGestureDirectionEntries,
@@ -305,12 +305,12 @@ export const resolvePinchPolicy = (
 const resolveGestureParticipation = ({
 	options,
 	isFirstKey,
-	gestureContext,
+	ancestorGestures,
 	isRemovePrevented,
 }: {
 	options: GesturePolicyOptions;
 	isFirstKey: boolean;
-	gestureContext: GestureContextType | null;
+	ancestorGestures: readonly ScreenGestureSource[];
 	isRemovePrevented: boolean;
 }): ScreenGestureParticipation => {
 	const canDismiss =
@@ -342,25 +342,25 @@ const resolveGestureParticipation = ({
 		canTrackGesture,
 		effectiveSnapPoints,
 		claimedDirections,
-		ownershipStatus: resolveOwnership(claimedDirections, gestureContext),
+		ownershipStatus: resolveOwnership(claimedDirections, ancestorGestures),
 	};
 };
 
 export const resolveScreenGestureConfig = ({
 	options,
 	isFirstKey,
-	gestureContext,
+	ancestorGestures,
 	isRemovePrevented = false,
 }: {
 	options: ScreenTransitionConfig;
 	isFirstKey: boolean;
-	gestureContext: GestureContextType | null;
+	ancestorGestures: readonly ScreenGestureSource[];
 	isRemovePrevented?: boolean;
 }): ScreenGestureConfig => {
 	const participation = resolveGestureParticipation({
 		options,
 		isFirstKey,
-		gestureContext,
+		ancestorGestures,
 		isRemovePrevented,
 	});
 	const hasSnapPoints = participation.effectiveSnapPoints.hasSnapPoints;

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

@@ -71,17 +71,20 @@ export const NO_DIRECTION_CLAIMS: DirectionClaimMap = {
 	"horizontal-inverted": null,
 };
 
-export interface GestureContextType {
+export interface ScreenGestureSource {
 	routeKey: string;
 	detectorGesture: ComposedGesture;
 	panGesture: PanGesture;
 	pinchGesture: PinchGesture;
 	scrollState: SharedValue<ScrollGestureState | null>;
-	gestureContext: GestureContextType | null;
 	claimedDirections: ClaimedDirections;
 	childDirectionClaims: SharedValue<DirectionClaimMap>;
 }
 
+export interface GestureContextType extends ScreenGestureSource {
+	ancestorGestures: readonly ScreenGestureSource[];
+}
+
 export interface ScreenGestureParticipation {
 	/** Whether this route is the first route in its stack. First routes never track gestures. */
 	isFirstKey: boolean;

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

@@ -6,14 +6,21 @@ import {
 	composeSlotStyleWithLocalTransform,
 	getLocalTransformForSlotComposition,
 } from "../helpers/compose-slot-style";
-import { useScreenSlots } from "../slot.provider";
+import { useOptionalScreenSlotStore } from "../slot.provider";
 
 const useCurrentScreenSlotsMap = () => {
 	const route = useRoute();
-	const slotsMap = useScreenSlots(route.key, (store) => store.slotsMap);
+	const localSlotsMap = useOptionalScreenSlotStore(
+		(store) => store?.slotsMap ?? null,
+	);
+	const keyedSlotsMap = useOptionalScreenSlotStore(
+		localSlotsMap ? null : route.key,
+		(store) => store.slotsMap,
+	);
+	const slotsMap = localSlotsMap ?? keyedSlotsMap;
 
 	if (!slotsMap) {
-		throw new Error(`ScreenSlot store for route "${route.key}" was not found`);
+		throw new Error(`ScreenSlotStore is unavailable for route "${route.key}"`);
 	}
 
 	return slotsMap;

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

@@ -148,9 +148,6 @@ export const useInterpolatedStylesMap = ({
 	const screenInterpolatorProps = useScreenAnimationStore(
 		(store) => store.screenInterpolatorProps,
 	);
-	const screenInterpolatorPropsRevision = useScreenAnimationStore(
-		(store) => store.screenInterpolatorPropsRevision,
-	);
 	const selectedInterpolatorOptions = useScreenAnimationStore(
 		(store) => store.selectedInterpolatorOptions,
 	);
@@ -160,17 +157,15 @@ export const useInterpolatedStylesMap = ({
 	const currentInterpolator = useScreenAnimationStore(
 		(store) => store.currentInterpolator,
 	);
-	const ancestorScreenAnimationSources = useScreenAnimationStore(
-		(store) => store.ancestorScreenAnimationSources,
+	const transitionSources = useScreenAnimationStore(
+		(store) => store.transitionSources,
 	);
-	const descendantScreenAnimationSources = useScreenAnimationStore(
-		(store) => store.descendantScreenAnimationSources,
+	const transitionOriginIndex = useScreenAnimationStore(
+		(store) => store.transitionOriginIndex,
 	);
 	const transition = useBuildTransitionAccessor({
-		screenInterpolatorProps,
-		screenInterpolatorPropsRevision,
-		ancestorScreenAnimationSources,
-		descendantScreenAnimationSources,
+		transitionSources,
+		transitionOriginIndex,
 	});
 	const hasCurrentInterpolator = !!currentInterpolator;
 	const { closing: currentClosing, entering: currentEntering } =
@@ -242,12 +237,7 @@ export const useInterpolatedStylesMap = ({
 
 	const localStylesMaps = useDerivedValue<LocalStyleLayers>(() => {
 		"worklet";
-		readScreenAnimationRevisions(
-			screenInterpolatorPropsRevision,
-			ancestorScreenAnimationSources,
-			descendantScreenAnimationSources,
-			interpolatorSharedValues,
-		);
+		readScreenAnimationRevisions(transitionSources, interpolatorSharedValues);
 		const props = screenInterpolatorProps.get();
 
 		const { current, next } = props;

package/src/shared/providers/screen/styles/index.tsx

@@ -9,5 +9,6 @@ export {
 export {
 	type ScreenSlotName,
 	ScreenSlotProvider,
-	useScreenSlots,
+	useOptionalScreenSlotStore,
+	useScreenSlotStore,
 } from "./slot.provider";

package/src/shared/providers/screen/styles/slot.provider.tsx

@@ -8,6 +8,7 @@ import type {
 import type { NormalizedTransitionInterpolatedStyle } from "../../../types/animation.types";
 import createProvider from "../../../utils/create-provider";
 import { useDescriptorsStore } from "../descriptors";
+import { useCurrentScreenRelationships } from "../use-current-screen-relationships";
 import { useInterpolatedStylesMap } from "./hooks/use-interpolated-style-maps";
 import { useMaybeBlockVisibility } from "./hooks/use-maybe-block-visibility";
 import { useResolvedStylesMap } from "./hooks/use-resolved-slot-style-map";
@@ -30,33 +31,32 @@ export type ScreenSlotContextValue = {
 	visibilityBlocked: SharedValue<boolean>;
 };
 
-const NO_PARENT_SCREEN_KEY = "__no-parent-screen__";
+const createScreenSlotProvider = createProvider("ScreenSlot", {
+	global: true,
+})<Props, ScreenSlotContextValue>;
 
-export const useAreAnyBlockingVisibility = () => {
-	const parentScreenKey = useDescriptorsStore(
-		(store) => store.derivations.parentScreenKey,
-	);
-
-	return useScreenSlots(
-		parentScreenKey ?? NO_PARENT_SCREEN_KEY,
-		(store) => store.visibilityBlocked,
-	);
-};
-
-export const { ScreenSlotProvider, useScreenSlotStore: useScreenSlots } =
-	createProvider("ScreenSlot", {
-		guarded: true,
-		global: true,
-	})<Props, ScreenSlotContextValue>(({ children }, { useParentStore }) => {
-		const ancestorStylesMap = useParentStore(
-			(parentContext) => parentContext?.slotsMap,
-		);
+export const {
+	ScreenSlotProvider,
+	useOptionalScreenSlotStore,
+	useScreenSlotStore,
+}: ReturnType<typeof createScreenSlotProvider> = createScreenSlotProvider(
+	({ children }) => {
 		const currentScreenKey = useDescriptorsStore(
 			(store) => store.derivations.currentScreenKey,
 		);
-		const ancestorVisibilityBlocked = useAreAnyBlockingVisibility();
+		const { parentScreenKey } = useCurrentScreenRelationships();
+		const ancestorStylesMap = useOptionalScreenSlotStore(
+			parentScreenKey,
+			(store) => store.slotsMap,
+		);
+		const ancestorVisibilityBlocked = useOptionalScreenSlotStore(
+			parentScreenKey,
+			(store) => store.visibilityBlocked,
+		);
 		const { animatedStyle, animatedProps, visibilityBlocked } =
-			useMaybeBlockVisibility({ ancestorVisibilityBlocked });
+			useMaybeBlockVisibility({
+				ancestorVisibilityBlocked: ancestorVisibilityBlocked ?? null,
+			});
 
 		const { interpolatorReady, localStylesMaps } = useInterpolatedStylesMap({
 			enabled: true,
@@ -65,7 +65,7 @@ export const { ScreenSlotProvider, useScreenSlotStore: useScreenSlots } =
 
 		const slotsMap = useResolvedStylesMap({
 			localStylesMaps,
-			ancestorStylesMap,
+			ancestorStylesMap: ancestorStylesMap ?? undefined,
 		});
 		const value = useMemo(
 			() => ({
@@ -92,7 +92,8 @@ export const { ScreenSlotProvider, useScreenSlotStore: useScreenSlots } =
 			value,
 			children: content,
 		};
-	});
+	},
+);
 
 const styles = StyleSheet.create({
 	container: { flex: 1 },

package/src/shared/providers/screen/use-current-screen-relationships.ts

@@ -0,0 +1,10 @@
+import { useScreenRelationships } from "../../factories/screen-topology";
+import { useDescriptorsStore } from "./descriptors";
+
+export const useCurrentScreenRelationships = () => {
+	const screenKey = useDescriptorsStore(
+		(store) => store.derivations.currentScreenKey,
+	);
+
+	return useScreenRelationships(screenKey);
+};

package/src/shared/providers/stack/blank-stack.provider.tsx

@@ -42,11 +42,14 @@ type BlankStackStoreProviderProps = {
 	value: BlankStackStoreValue<BaseStackDescriptor>;
 };
 
-const { BlankStackProvider: BlankStackStoreProvider, useBlankStackStore } =
-	createProvider("BlankStack", { guarded: false })<
-		BlankStackStoreProviderProps,
-		BlankStackStoreValue<BaseStackDescriptor>
-	>(({ children, value }) => ({ children, value }));
+const {
+	BlankStackProvider: BlankStackStoreProvider,
+	useBlankStackStore,
+	useOptionalBlankStackStore,
+} = createProvider("BlankStack")<
+	BlankStackStoreProviderProps,
+	BlankStackStoreValue<BaseStackDescriptor>
+>(({ children, value }) => ({ children, value }));
 
 function BlankStackProvider({
 	state: stackState,
@@ -68,6 +71,15 @@ function BlankStackProvider({
 		() => createScenesByKey(state.scenes),
 		[state.scenes],
 	);
+	const paintDriverRouteKeyByRouteKey = useMemo(() => {
+		const paintDrivers = new Map<string, string>();
+
+		for (let index = 0; index + 2 < state.routeKeys.length; index++) {
+			paintDrivers.set(state.routeKeys[index], state.routeKeys[index + 2]);
+		}
+
+		return paintDrivers;
+	}, [state.routeKeys]);
 
 	const stackValue = useMemo<StackContextValue>(
 		() => ({
@@ -95,6 +107,7 @@ function BlankStackProvider({
 		routes: state.routes,
 		scenes: state.scenes,
 		scenesByKey,
+		paintDriverRouteKeyByRouteKey,
 		focusedIndex,
 		requestDismiss,
 		shouldShowFloatOverlay: state.shouldShowFloatOverlay,
@@ -111,4 +124,4 @@ function BlankStackProvider({
 }
 
 export type { BlankStackProviderProps, BlankStackStoreValue };
-export { BlankStackProvider, useBlankStackStore };
+export { BlankStackProvider, useBlankStackStore, useOptionalBlankStackStore };

package/src/shared/providers/stack/core.provider.tsx

@@ -45,7 +45,6 @@ const StackCoreRoot = memo(function StackCoreRoot({
 
 export const { StackCoreProvider, useStackCoreStore } = createProvider(
 	"StackCore",
-	{ guarded: true },
 )<StackCoreProviderProps, StackCoreContextValue>(({ config, children }) => {
 	const {
 		TRANSITIONS_ALWAYS_ON = false,

package/src/shared/providers/stack/direct.provider.tsx

@@ -23,7 +23,7 @@ type DirectStackStoreProviderProps = {
 };
 
 const { DirectStackProvider: DirectStackStoreProvider, useDirectStackStore } =
-	createProvider("DirectStack", { guarded: true })<
+	createProvider("DirectStack")<
 		DirectStackStoreProviderProps,
 		DirectStackContextValue
 	>(({ children, value }) => ({ children, value }));
@@ -51,7 +51,7 @@ function DirectStackProvider({
 		useMemo(() => {
 			const allRoutes = state.routes.concat(state.preloadedRoutes);
 			const scenes: DirectStackScene[] = [];
-			const routeKeys: string[] = [];
+			const routeKeys = state.routes.map((route) => route.key);
 			const allDescriptors: NativeStackDescriptorMap = {
 				...preloadedDescriptors,
 				...descriptors,
@@ -85,8 +85,6 @@ function DirectStackProvider({
 					descriptor,
 					isPreloaded,
 				});
-				routeKeys.push(route.key);
-
 				if (
 					!shouldShowFloatOverlay &&
 					descriptor.options?.enableTransitions === true &&