react-native-screen-transitions 3.4.0-alpha.0 → 3.4.0-alpha.2

package/src/shared/providers/screen/animation/helpers/resolve-screen-animation-target.ts

@@ -0,0 +1,44 @@
+import type { DerivedValue } from "react-native-reanimated";
+import type { ScreenInterpolationProps } from "../../../../types/animation.types";
+import type { ScreenAnimationTarget } from "../types";
+
+type Params = {
+	target: ScreenAnimationTarget | undefined;
+	self: DerivedValue<ScreenInterpolationProps>;
+	ancestors: DerivedValue<ScreenInterpolationProps>[];
+};
+
+const isAncestorTarget = (
+	target: ScreenAnimationTarget,
+): target is { ancestor: number } => {
+	return typeof target === "object" && target !== null && "ancestor" in target;
+};
+
+export function resolveScreenAnimationTarget({
+	target,
+	self,
+	ancestors,
+}: Params): DerivedValue<ScreenInterpolationProps> {
+	if (!target || target === "self") {
+		return self;
+	}
+
+	if (target === "parent") {
+		return ancestors[0] ?? self;
+	}
+
+	if (target === "root") {
+		return ancestors[ancestors.length - 1] ?? self;
+	}
+
+	if (!isAncestorTarget(target)) {
+		return self;
+	}
+
+	const depth = target.ancestor;
+	if (!Number.isInteger(depth) || depth < 1) {
+		return self;
+	}
+
+	return ancestors[depth - 1] ?? self;
+}

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

@@ -2,4 +2,7 @@ export {
 	ScreenAnimationProvider,
 	useScreenAnimationContext,
 } from "./animation.provider";
-export { useScreenAnimation } from "./use-screen-animation";
+export {
+	type ScreenAnimationTarget,
+	useScreenAnimation,
+} from "./use-screen-animation";

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

@@ -0,0 +1,5 @@
+export type ScreenAnimationTarget =
+	| "self"
+	| "parent"
+	| "root"
+	| { ancestor: number };

package/src/shared/providers/screen/animation/use-screen-animation.tsx

@@ -1,6 +1,19 @@
+import type { DerivedValue } from "react-native-reanimated";
+import type { ScreenInterpolationProps } from "../../../types/animation.types";
 import { useScreenAnimationContext } from "./animation.provider";
+import { resolveScreenAnimationTarget } from "./helpers/resolve-screen-animation-target";
+import type { ScreenAnimationTarget } from "./types";
 
-export function useScreenAnimation() {
-	const { screenAnimation } = useScreenAnimationContext();
-	return screenAnimation;
+export type { ScreenAnimationTarget } from "./types";
+
+export function useScreenAnimation(
+	target?: ScreenAnimationTarget,
+): DerivedValue<ScreenInterpolationProps> {
+	const { screenAnimation, ancestorScreenAnimations } =
+		useScreenAnimationContext();
+	return resolveScreenAnimationTarget({
+		target,
+		self: screenAnimation,
+		ancestors: ancestorScreenAnimations,
+	});
 }

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

@@ -5,12 +5,12 @@ import { StyleSheet } from "react-native";
 import { GestureHandlerRootView } from "react-native-gesture-handler";
 import { StackType } from "../../types/stack.types";
 import createProvider from "../../utils/create-provider";
-import { ViewportProvider } from "../viewport.provider";
 
 export interface StackCoreConfig {
 	TRANSITIONS_ALWAYS_ON?: boolean;
 	STACK_TYPE?: StackType;
 	DISABLE_NATIVE_SCREENS?: boolean;
+	DISABLE_NATIVE_SCREEN_CONTAINER?: boolean;
 }
 
 interface StackCoreProviderProps {
@@ -23,6 +23,7 @@ export interface StackCoreContextValue {
 		TRANSITIONS_ALWAYS_ON: boolean;
 		STACK_TYPE?: StackType;
 		DISABLE_NATIVE_SCREENS: boolean;
+		DISABLE_NATIVE_SCREEN_CONTAINER: boolean;
 	};
 }
 
@@ -34,18 +35,27 @@ const { StackCoreProvider: InternalStackCoreProvider, useStackCoreContext } =
 		const {
 			TRANSITIONS_ALWAYS_ON = false,
 			DISABLE_NATIVE_SCREENS = false,
+			DISABLE_NATIVE_SCREEN_CONTAINER = false,
 			STACK_TYPE = StackType.BLANK,
 		} = config;
 
 		const flags = useMemo(
-			() => ({ TRANSITIONS_ALWAYS_ON, STACK_TYPE, DISABLE_NATIVE_SCREENS }),
-			[TRANSITIONS_ALWAYS_ON, STACK_TYPE, DISABLE_NATIVE_SCREENS],
+			() => ({
+				TRANSITIONS_ALWAYS_ON,
+				STACK_TYPE,
+				DISABLE_NATIVE_SCREENS,
+				DISABLE_NATIVE_SCREEN_CONTAINER,
+			}),
+			[
+				TRANSITIONS_ALWAYS_ON,
+				STACK_TYPE,
+				DISABLE_NATIVE_SCREENS,
+				DISABLE_NATIVE_SCREEN_CONTAINER,
+			],
 		);
 
-		const value = useMemo(() => ({ flags }), [flags]);
-
 		return {
-			value,
+			value: { flags },
 			children: (
 				<GestureHandlerRootView
 					style={styles.container}
@@ -53,9 +63,7 @@ const { StackCoreProvider: InternalStackCoreProvider, useStackCoreContext } =
 						STACK_TYPE === StackType.COMPONENT ? "box-none" : undefined
 					}
 				>
-					<SafeAreaProviderCompat>
-						<ViewportProvider>{children}</ViewportProvider>
-					</SafeAreaProviderCompat>
+					<SafeAreaProviderCompat>{children}</SafeAreaProviderCompat>
 				</GestureHandlerRootView>
 			),
 		};
@@ -71,16 +79,21 @@ export function withStackCore<TProps extends object>(
 ): React.FC<TProps & StackCoreConfig> {
 	return function StackCoreWrapper({
 		DISABLE_NATIVE_SCREENS,
+		DISABLE_NATIVE_SCREEN_CONTAINER,
 		TRANSITIONS_ALWAYS_ON,
 		STACK_TYPE,
 		...props
 	}: TProps & StackCoreConfig) {
-		// User props first, then defaultConfig overrides (config takes priority)
+		// Start from defaults, then apply explicit overrides from the caller.
 		const config: StackCoreConfig = {
-			...(DISABLE_NATIVE_SCREENS !== undefined && { DISABLE_NATIVE_SCREENS }),
-			...(TRANSITIONS_ALWAYS_ON !== undefined && { TRANSITIONS_ALWAYS_ON }),
-			...(STACK_TYPE !== undefined && { STACK_TYPE }),
-			...defaultConfig,
+			TRANSITIONS_ALWAYS_ON:
+				TRANSITIONS_ALWAYS_ON ?? defaultConfig.TRANSITIONS_ALWAYS_ON,
+			STACK_TYPE: STACK_TYPE ?? defaultConfig.STACK_TYPE,
+			DISABLE_NATIVE_SCREENS:
+				DISABLE_NATIVE_SCREENS ?? defaultConfig.DISABLE_NATIVE_SCREENS,
+			DISABLE_NATIVE_SCREEN_CONTAINER:
+				DISABLE_NATIVE_SCREEN_CONTAINER ??
+				defaultConfig.DISABLE_NATIVE_SCREEN_CONTAINER,
 		};
 		return (
 			<InternalStackCoreProvider config={config}>

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

@@ -14,7 +14,7 @@ import type {
 	DirectStackProps,
 	DirectStackScene,
 } from "../../types/providers/direct-stack.types";
-import { isFloatOverlayVisible } from "../../utils/overlay/visibility";
+import { isOverlayVisible } from "../../utils/overlay/visibility";
 import { useStackCoreContext } from "./core.provider";
 import { useStackDerived } from "./helpers/use-stack-derived";
 
@@ -64,10 +64,7 @@ function useDirectStackValue(
 
 			if (!shouldShowFloatOverlay && descriptor) {
 				const options = descriptor.options;
-				if (
-					options?.enableTransitions === true &&
-					isFloatOverlayVisible(options)
-				) {
+				if (options?.enableTransitions === true && isOverlayVisible(options)) {
 					shouldShowFloatOverlay = true;
 				}
 			}

package/src/shared/providers/stack/helpers/use-processed-routes.ts

@@ -7,7 +7,7 @@ import type {
 	BaseStackDescriptor,
 	BaseStackScene,
 } from "../../../types/stack.types";
-import { isFloatOverlayVisible } from "../../../utils/overlay/visibility";
+import { isOverlayVisible } from "../../../utils/overlay/visibility";
 
 export interface ProcessedRoutes<
 	TDescriptor extends BaseStackDescriptor = BaseStackDescriptor,
@@ -52,7 +52,7 @@ export function useProcessedRoutes<
 			animationMaps[i] = AnimationStore.getRouteAnimations(route.key);
 
 			if (!shouldShowFloatOverlay) {
-				shouldShowFloatOverlay = isFloatOverlayVisible(options);
+				shouldShowFloatOverlay = isOverlayVisible(options);
 			}
 
 			if (!stopLimit) {

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

@@ -3,7 +3,7 @@ import {
 	makeMutable,
 	type SharedValue,
 } from "react-native-reanimated";
-import type { ScreenKey } from "../types/screen.types";
+import type { Layout, ScreenKey } from "../types/screen.types";
 
 export type AnimationStoreMap = {
 	progress: SharedValue<number>;
@@ -11,6 +11,10 @@ export type AnimationStoreMap = {
 	closing: SharedValue<number>;
 	entering: SharedValue<number>;
 	targetProgress: SharedValue<number>;
+	/** Resolved fraction (contentHeight / screenHeight) for the 'auto' snap point. -1 = not yet measured. */
+	autoSnapPoint: SharedValue<number>;
+	/** Intrinsic content layout measured from the screen container wrapper. */
+	contentLayout: SharedValue<Layout | null>;
 };
 
 const store: Record<ScreenKey, AnimationStoreMap> = {};
@@ -20,8 +24,10 @@ function createAnimationBag(): AnimationStoreMap {
 		progress: makeMutable(0),
 		closing: makeMutable(0),
 		animating: makeMutable(0),
-		entering: makeMutable(1),
+		entering: makeMutable(0),
 		targetProgress: makeMutable(1),
+		autoSnapPoint: makeMutable(-1),
+		contentLayout: makeMutable<Layout | null>(null),
 	};
 }
 
@@ -40,13 +46,20 @@ function peekRouteAnimations(
 	return store[routeKey];
 }
 
-function getRouteAnimation(
+function getRouteAnimation<K extends keyof AnimationStoreMap>(
 	routeKey: ScreenKey,
-	type: keyof AnimationStoreMap,
-): SharedValue<number> {
+	type: K,
+): AnimationStoreMap[K] {
 	return ensure(routeKey)[type];
 }
 
+function getAnimation<K extends keyof AnimationStoreMap>(
+	routeKey: ScreenKey,
+	type: K,
+): AnimationStoreMap[K] {
+	return getRouteAnimation(routeKey, type);
+}
+
 function getRouteAnimations(routeKey: ScreenKey): AnimationStoreMap {
 	return ensure(routeKey);
 }
@@ -59,11 +72,14 @@ function clear(routeKey: ScreenKey) {
 		cancelAnimation(bag.closing);
 		cancelAnimation(bag.entering);
 		cancelAnimation(bag.targetProgress);
+		cancelAnimation(bag.autoSnapPoint);
+		cancelAnimation(bag.contentLayout);
 	}
 	delete store[routeKey];
 }
 
 export const AnimationStore = {
+	getAnimation,
 	peekRouteAnimations,
 	getRouteAnimation,
 	getRouteAnimations,

package/src/shared/stores/bounds/internals/presence.ts

@@ -118,7 +118,9 @@ function setGroupActiveId(group: string, id: string) {
 	groups.modify(<T extends GroupsState>(state: T): T => {
 		"worklet";
 		const mutableState = state as GroupsState;
-		mutableState[group] = { activeId: id };
+		mutableState[group] = {
+			activeId: id,
+		};
 		return state;
 	});
 	debugStoreSizeLog(`setGroupActiveId(${group},${id})`);

package/src/shared/stores/bounds/internals/resolver.ts

@@ -1,3 +1,4 @@
+import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
 import { matchesScreenKey } from "../helpers/matching";
 import type {
 	ResolvedTransitionPair,
@@ -69,7 +70,11 @@ function findPendingLinkBySource(
 function getSnapshotBoundsByPriority(
 	tag: TagID,
 	keys: (ScreenKey | undefined)[],
-): { bounds: any; screenKey: ScreenKey } | null {
+): {
+	bounds: MeasuredDimensions;
+	styles: StyleProps;
+	screenKey: ScreenKey;
+} | null {
 	"worklet";
 	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i];
@@ -78,6 +83,7 @@ function getSnapshotBoundsByPriority(
 		if (!snapshot) continue;
 		return {
 			bounds: snapshot.bounds,
+			styles: snapshot.styles,
 			screenKey: key,
 		};
 	}
@@ -149,6 +155,8 @@ function resolveTransitionPair(
 
 	let sourceBounds = matchedLink?.source?.bounds ?? null;
 	let destinationBounds = matchedLink?.destination?.bounds ?? null;
+	let sourceStyles = matchedLink?.source?.styles ?? null;
+	let destinationStyles = matchedLink?.destination?.styles ?? null;
 	let sourceScreenKey = matchedLink?.source?.screenKey ?? null;
 	let destinationScreenKey = matchedLink?.destination?.screenKey ?? null;
 	let usedSnapshotSource = false;
@@ -174,6 +182,7 @@ function resolveTransitionPair(
 		const sourceSnapshot = getSnapshotBoundsByPriority(tag, sourceFallbackKeys);
 		if (sourceSnapshot) {
 			sourceBounds = sourceSnapshot.bounds;
+			sourceStyles = sourceSnapshot.styles;
 			sourceScreenKey = sourceSnapshot.screenKey;
 			usedSnapshotSource = true;
 		}
@@ -186,6 +195,7 @@ function resolveTransitionPair(
 		);
 		if (destinationSnapshot) {
 			destinationBounds = destinationSnapshot.bounds;
+			destinationStyles = destinationSnapshot.styles;
 			destinationScreenKey = destinationSnapshot.screenKey;
 			usedSnapshotDestination = true;
 		}
@@ -202,6 +212,8 @@ function resolveTransitionPair(
 	return {
 		sourceBounds,
 		destinationBounds,
+		sourceStyles,
+		destinationStyles,
 		sourceScreenKey,
 		destinationScreenKey,
 		usedPending,

package/src/shared/stores/bounds/types.ts

@@ -43,6 +43,8 @@ export type ResolveTransitionContext = {
 export type ResolvedTransitionPair = {
 	sourceBounds: MeasuredDimensions | null;
 	destinationBounds: MeasuredDimensions | null;
+	sourceStyles: StyleProps | null;
+	destinationStyles: StyleProps | null;
 	sourceScreenKey: ScreenKey | null;
 	destinationScreenKey: ScreenKey | null;
 	usedPending: boolean;

package/src/shared/types/animation.types.ts

@@ -10,17 +10,6 @@ import type { GestureValues } from "./gesture.types";
 import type { Layout } from "./screen.types";
 import type { BaseStackRoute } from "./stack.types";
 
-export interface OverlayInterpolationProps {
-	progress: number;
-	layouts: {
-		/**
-		 * The `width` and `height` of the screen container.
-		 */
-		screen: Layout;
-	};
-	insets: EdgeInsets;
-}
-
 export type ScreenTransitionState = {
 	/**
 	 * Animation progress for this screen.
@@ -42,11 +31,11 @@ export type ScreenTransitionState = {
 	closing: number;
 
 	/**
-	 * Whether this screen is in the process of entering.
-	 * - `0`: Screen is closing or inactive
-	 * - `1`: Screen is opening/entering
+	 * Whether this screen is actively in its opening phase.
+	 * - `0`: Screen is settled, inactive, or closing
+	 * - `1`: Screen is currently opening/entering
 	 *
-	 * Use this to trigger different animations when navigating back vs forward.
+	 * This flips back to `0` once the open animation finishes.
 	 */
 	entering: number;
 
@@ -114,6 +103,13 @@ export interface ScreenInterpolationProps {
 		 * The `width` and `height` of the screen container.
 		 */
 		screen: Layout;
+		/**
+		 * The intrinsic measured content wrapper layout when available.
+		 *
+		 * This is currently populated for the measured screen-container path used by
+		 * auto snap-point sizing. It is undefined until a real measurement exists.
+		 */
+		content?: Layout;
 	};
 
 	/**
@@ -169,18 +165,6 @@ export interface ScreenInterpolationProps {
 	 * When focused, this is the previous screen. When not focused, this is the current screen.
 	 */
 	inactive: ScreenTransitionState | undefined;
-
-	/**
-	 * Whether the active screen is currently transitioning (either being dragged or animating).
-	 * @deprecated Use `active.animating` instead.
-	 */
-	isActiveTransitioning: boolean;
-
-	/**
-	 * Whether the active screen is in the process of being dismissed/closed.
-	 * @deprecated Use `active.closing` instead.
-	 */
-	isDismissing: boolean;
 }
 
 export type ScreenStyleInterpolator = (
@@ -195,17 +179,11 @@ export type ScreenStyleInterpolator = (
  */
 export type AnimatedViewStyle = ViewStyle & TextStyle;
 
-/**
- * Explicit slot format with separate `style` and `props` buckets.
- *
- * - `style` is applied via `useAnimatedStyle` (transform, opacity, backgroundColor, etc.)
- * - `props` is applied via `useAnimatedProps` (component-specific props like BlurView intensity)
- */
-export type TransitionSlotExplicit = {
-	/** Animated styles applied via useAnimatedStyle. */
+type TransitionSlotDefinition = {
+	/** Animated styles applied via `useAnimatedStyle`. */
 	style?: AnimatedViewStyle;
-	/** Animated props applied via useAnimatedProps (e.g., BlurView intensity, SquircleView cornerRadius). */
-	props?: Record<string, any>;
+	/** Animated props applied via `useAnimatedProps`. */
+	props?: Record<string, unknown>;
 };
 
 /**
@@ -215,7 +193,7 @@ export type TransitionSlotExplicit = {
  * - **Shorthand**: Write styles directly — `{ opacity: 0.5, transform: [...] }`
  * - **Explicit**: Use `style` and/or `props` buckets — `{ style: { opacity: 0.5 }, props: { intensity: 80 } }`
  */
-export type TransitionSlotStyle = AnimatedViewStyle | TransitionSlotExplicit;
+export type TransitionSlotStyle = AnimatedViewStyle | TransitionSlotDefinition;
 
 /**
  * Internal normalized slot format used after the backward-compat shim.
@@ -223,7 +201,7 @@ export type TransitionSlotStyle = AnimatedViewStyle | TransitionSlotExplicit;
  */
 export type NormalizedTransitionSlotStyle = {
 	style?: StyleProps;
-	props?: Record<string, any>;
+	props?: Record<string, unknown>;
 };
 
 /**
@@ -242,10 +220,10 @@ export type NormalizedTransitionInterpolatedStyle = {
 };
 
 /**
- * Public new-format interpolator result with type-safe style autocomplete.
- * Uses `TransitionSlotStyle` (backed by `AnimatedViewStyle`) for full style autocomplete.
+ * The return type of `screenStyleInterpolator`.
+ * Uses the nested slot format, while still accepting deprecated flat keys.
  */
-export type NewTransitionInterpolatedStyle = {
+export type TransitionInterpolatedStyle = {
 	/** Animated style and props for the main screen content view. */
 	content?: TransitionSlotStyle;
 	/** Animated style and props for the backdrop layer between screens. */
@@ -254,27 +232,23 @@ export type NewTransitionInterpolatedStyle = {
 	surface?: TransitionSlotStyle;
 	/** Custom styles/props by id for Transition.View components. */
 	[id: string]: TransitionSlotStyle | undefined;
-};
-
-/**
- * @deprecated Use the nested format instead: `{ content: { style }, backdrop: { style } }`.
- * This flat format is auto-converted via a backward-compat shim.
- */
-export type LegacyTransitionInterpolatedStyle = {
+	/**
+	 * @deprecated Use `content` instead.
+	 * This flat format is auto-converted via a backward-compat shim.
+	 */
 	contentStyle?: AnimatedViewStyle;
+	/**
+	 * @deprecated Use `backdrop` instead.
+	 * This flat format is auto-converted via a backward-compat shim.
+	 */
 	backdropStyle?: AnimatedViewStyle;
+	/**
+	 * @deprecated Use `backdrop` instead.
+	 * This flat format is auto-converted via a backward-compat shim.
+	 */
 	overlayStyle?: AnimatedViewStyle;
-	[id: string]: AnimatedViewStyle | undefined;
 };
 
-/**
- * The return type of `screenStyleInterpolator`.
- * Accepts both the new nested format and the legacy flat format (auto-converted).
- */
-export type TransitionInterpolatedStyle =
-	| NewTransitionInterpolatedStyle
-	| LegacyTransitionInterpolatedStyle;
-
 /**
  * A Reanimated animation configuration object.
  */

package/src/shared/types/bounds.types.ts

@@ -1,8 +1,11 @@
 import type { MeasuredDimensions, StyleProps } from "react-native-reanimated";
 import type { Snapshot } from "../stores/bounds";
 import type {
+	BoundId,
+	BoundsAnchor,
 	BoundsOptions,
 	BoundsOptionsResult,
+	BoundsScaleMode,
 } from "../utils/bounds/types/options";
 import type { TransitionInterpolatedStyle } from "./animation.types";
 
@@ -25,16 +28,33 @@ export type BoundsLink = {
 	destination: BoundEntry | null;
 };
 
-export type BoundsStyleOptions = Omit<BoundsOptions, "id" | "group">;
-
-export type BoundsNavigationPreset = "zoom";
-
-export type BoundsNavigationOptions = BoundsStyleOptions & {
+export type BoundsNavigationZoomOptions = {
+	anchor?: BoundsAnchor;
+	scaleMode?: BoundsScaleMode;
+	target?: "bound" | "fullscreen" | MeasuredDimensions;
+	mask?: {
+		borderRadius?: number | "auto" | { from?: number; to?: number };
+		borderTopLeftRadius?: number | "auto" | { from?: number; to?: number };
+		borderTopRightRadius?: number | "auto" | { from?: number; to?: number };
+		borderBottomLeftRadius?: number | "auto" | { from?: number; to?: number };
+		borderBottomRightRadius?: number | "auto" | { from?: number; to?: number };
+		borderCurve?: "circular" | "continuous";
+		outset?:
+			| number
+			| { top?: number; right?: number; bottom?: number; left?: number };
+	};
+	motion?: {
+		dragResistance?: number;
+		dragDirectionalScaleMin?: number;
+	};
+	/**
+	 * @deprecated Use `mask.borderRadius` instead.
+	 */
 	maskBorderRadius?: number;
 };
 
 export type BoundsNavigationAccessor = {
-	zoom: () => TransitionInterpolatedStyle;
+	zoom: (options?: BoundsNavigationZoomOptions) => TransitionInterpolatedStyle;
 };
 
 type BoundsBoundNavigationAccessor = {
@@ -46,15 +66,15 @@ type BoundsCallResult<T extends BoundsOptions> = BoundsOptionsResult<T> &
 
 export type BoundsAccessor = {
 	<T extends BoundsOptions>(options: T): BoundsCallResult<T>;
-	getSnapshot: (id: string, key?: string) => Snapshot | null;
-	getLink: (id: string) => BoundsLink | null;
+	getSnapshot: (id: BoundId, key?: string) => Snapshot | null;
+	getLink: (id: BoundId) => BoundsLink | null;
 	interpolateStyle: (
-		id: string,
+		id: BoundId,
 		property: keyof StyleProps,
 		fallback?: number,
 	) => number;
 	interpolateBounds: (
-		id: string,
+		id: BoundId,
 		property: keyof MeasuredDimensions,
 		fallbackOrTargetKey?: number | string,
 		fallback?: number,

package/src/shared/types/index.ts

@@ -2,28 +2,18 @@ export { FALSE, TRUE } from "../constants";
 export type {
 	AnimatedViewStyle,
 	AnimationConfig,
-	LegacyTransitionInterpolatedStyle,
-	NewTransitionInterpolatedStyle,
-	NormalizedTransitionInterpolatedStyle,
-	NormalizedTransitionSlotStyle,
-	OverlayInterpolationProps,
 	ScreenInterpolationProps,
 	ScreenStyleInterpolator,
 	ScreenTransitionState,
 	TransitionInterpolatedStyle,
-	TransitionSlotExplicit,
 	TransitionSlotStyle,
 	TransitionSpec,
 } from "./animation.types";
 export type {
-	BoundEntry,
 	BoundsAccessor,
-	BoundsLink,
 	BoundsMethod,
 	BoundsNavigationAccessor,
-	BoundsNavigationOptions,
-	BoundsNavigationPreset,
-	BoundsStyleOptions,
+	BoundsNavigationZoomOptions,
 } from "./bounds.types";
 export type {
 	ActivationArea,
@@ -32,10 +22,7 @@ export type {
 	GestureValues,
 	SideActivation,
 } from "./gesture.types";
-export type {
-	OverlayMode,
-	OverlayProps,
-} from "./overlay.types";
+export type { OverlayProps } from "./overlay.types";
 export type {
 	Layout,
 	ScreenKey,