react-native-screen-transitions 4.0.0 → 4.1.0-beta.0

package/src/adapters/with-screen-transitions/lifecycle/use-native-close-transition-intent.ts

@@ -0,0 +1,88 @@
+import { useLayoutEffect, useRef } from "react";
+import { resetStoresForScreen } from "../../../components/screen/lifecycle/hooks/helpers/reset-stores-for-screen";
+import { useNavigationHelpers } from "../../../hooks/navigation/use-navigation-helpers";
+import useStableCallback from "../../../hooks/use-stable-callback";
+import type { BaseDescriptor } from "../../../providers/screen/builder";
+import { useScreenRelationships } from "../../../providers/screen/builder/topology";
+import { useOptionalMotionStore } from "../../../providers/screen/motion";
+import {
+	dispatchCloseAction,
+	isCloseActionReplay,
+} from "../../../utils/navigation/close-action-replay";
+import type { AdapterDescriptorOptions } from "../options";
+import {
+	doesNavigatorOwnCloseAction,
+	shouldInterceptClose,
+} from "./close-interception-rules";
+
+export function useNativeCloseTransitionIntent(current: BaseDescriptor): {
+	completeClose: () => void;
+} {
+	const routeKey = current.route.key;
+	const { parentScreenKey } = useScreenRelationships();
+	const { dismissScreen, requestDismiss } = useNavigationHelpers();
+	const pendingActionRef = useRef<any>(null);
+
+	const nearestAncestorDismissing = useOptionalMotionStore(
+		parentScreenKey ?? null,
+		(store) => store.state.dismissing,
+	);
+
+	const completeClose = useStableCallback(() => {
+		const pendingAction = pendingActionRef.current;
+		pendingActionRef.current = null;
+
+		if (pendingAction) {
+			dispatchCloseAction(pendingAction, (action) => {
+				current.navigation.dispatch(action);
+			});
+		} else {
+			dismissScreen();
+		}
+
+		resetStoresForScreen(routeKey);
+	});
+
+	const handleBeforeRemove = useStableCallback((event: any) => {
+		if (isCloseActionReplay(event.data.action)) {
+			return;
+		}
+
+		const state = current.navigation.getState();
+		const routeIndex = state.routes.findIndex(
+			(route) => route.key === routeKey,
+		);
+		const action = event.data.action;
+		const ownsAction = doesNavigatorOwnCloseAction({
+			state,
+			action,
+		});
+		const shouldIntercept = shouldInterceptClose({
+			enabled:
+				(current.options as AdapterDescriptorOptions).enableTransitions ===
+				true,
+			ownsAction,
+			ancestorDismissing: !!nearestAncestorDismissing?.get(),
+			routeIndex,
+			focusedIndex: state.index,
+		});
+
+		if (!shouldIntercept) {
+			return;
+		}
+
+		pendingActionRef.current ??= event.data.action;
+		if (!requestDismiss()) {
+			pendingActionRef.current = null;
+			return;
+		}
+
+		event.preventDefault();
+	});
+
+	useLayoutEffect(() => {
+		return current.navigation.addListener?.("beforeRemove", handleBeforeRemove);
+	}, [current.navigation, handleBeforeRemove]);
+
+	return { completeClose };
+}

package/src/adapters/with-screen-transitions/stack-layout.tsx

@@ -1,16 +1,17 @@
 import type { NavigationState, Route } from "@react-navigation/native";
 import { useMemo } from "react";
+import { StyleSheet } from "react-native";
+import { GestureHandlerRootView } from "react-native-gesture-handler";
 import { Overlay } from "../../components/overlay";
-import { ScreenComposer } from "../../providers/screen/screen-composer";
+import { Screen } from "../../components/screen/screen";
 import { BlankStackStoreProvider } from "../../providers/stack/blank-stack.provider";
-import { StackCoreProvider } from "../../providers/stack/core.provider";
 import type { BaseStackDescriptor, BaseStackRoute } from "../../types";
-import { isOverlayVisible } from "../../utils/overlay/visibility";
 import {
 	ScreenTransitionsAdapterProvider,
 	type ScreenTransitionsAdapterScene,
 	useScreenTransitionsAdapterContext,
 } from "./context";
+import { NativeStackLifecycle } from "./lifecycle";
 import {
 	type AdapterDescriptorOptions,
 	resolveAdapterTransitionOptions,
@@ -109,9 +110,8 @@ function buildTransitionStackState({
 
 		if (
 			!shouldShowFloatOverlay &&
-			(normalizedDescriptor.options as AdapterDescriptorOptions)
-				.enableTransitions &&
-			isOverlayVisible(normalizedDescriptor.options)
+			normalizedDescriptor.options.overlay &&
+			normalizedDescriptor.options.overlayShown !== false
 		) {
 			shouldShowFloatOverlay = true;
 		}
@@ -182,9 +182,9 @@ export function ScreenTransitionsStackLayout(
 	props: ScreenTransitionsStackContentProps,
 ) {
 	return (
-		<StackCoreProvider config={{ TRANSITIONS_ALWAYS_ON: false }}>
+		<GestureHandlerRootView style={styles.container}>
 			<ScreenTransitionsStackContent {...props} />
-		</StackCoreProvider>
+		</GestureHandlerRootView>
 	);
 }
 
@@ -208,12 +208,10 @@ export function ScreenTransitionsScreenLayout({
 	const scene = scenes[sceneIndex];
 
 	return (
-		<ScreenComposer
-			previous={scene.previousDescriptor}
-			current={scene.descriptor}
-			next={scene.nextDescriptor}
-		>
+		<Screen routeKey={scene.route.key} lifecycle={NativeStackLifecycle}>
 			{children}
-		</ScreenComposer>
+		</Screen>
 	);
 }
+
+const styles = StyleSheet.create({ container: { flex: 1 } });

package/src/animation/snap-to.ts

@@ -1,7 +1,6 @@
 import { scheduleOnUI } from "react-native-worklets";
-import { AnimationStore } from "../stores/animation.store";
+import { getMotionStore } from "../providers/screen/motion";
 import type { HistoryEntry } from "../stores/history.store";
-import { SystemStore } from "../stores/system.store";
 import { animateToProgress } from "../utils/animation/animate-to-progress";
 import { resolveSnapTransitionSpec } from "../utils/animation/resolve-snap-transition-spec";
 import { logger } from "../utils/logger";
@@ -13,14 +12,13 @@ const getSortedSnapPoints = (
 	const snapPoints = descriptor.options?.snapPoints;
 	if (!snapPoints || snapPoints.length === 0) return null;
 
-	// Resolve 'auto' to the measured fraction stored in SystemStore
-	const autoVal = SystemStore.getValue(
+	// Resolve 'auto' to the measured fraction owned by Motion
+	const autoVal = getMotionStore(
 		descriptor.route.key,
-		"resolvedAutoSnapPoint",
-	).get();
+	).state.resolvedAutoSnapPoint.get();
 
 	const resolved = snapPoints
-		.map((p) => (p === "auto" ? autoVal : p))
+		.map((p) => (typeof p === "string" ? autoVal : p))
 		.filter((p): p is number => typeof p === "number" && p > 0);
 
 	return resolved.length > 0 ? resolved.sort((a, b) => a - b) : null;
@@ -44,15 +42,11 @@ export function snapDescriptorToIndex(
 	}
 
 	const targetProgress = sorted[index];
-	const animations = AnimationStore.getBag(descriptor.route.key);
-	const targetProgressValue = SystemStore.getValue(
-		descriptor.route.key,
-		"targetProgress",
-	);
-	const animationProgressValue = SystemStore.getValue(
-		descriptor.route.key,
-		"animationProgress",
-	);
+	const animations = getMotionStore(descriptor.route.key).state;
+	const {
+		targetProgress: targetProgressValue,
+		animationProgress: animationProgressValue,
+	} = animations;
 
 	scheduleOnUI(() => {
 		"worklet";

package/src/animation/transition-blocking.ts

@@ -1,5 +1,5 @@
+import { getMotionStore } from "../providers/screen/motion";
 import { HistoryStore } from "../stores/history.store";
-import { SystemStore } from "../stores/system.store";
 import type { ScreenKey } from "../types/screen.types";
 import { logger } from "../utils/logger";
 
@@ -52,7 +52,7 @@ export function blockTransition(routeKey?: ScreenKey): void {
 		return;
 	}
 
-	SystemStore.getBag(resolvedRouteKey).actions.blockLifecycleStart();
+	getMotionStore(resolvedRouteKey).state.actions.blockLifecycleStart();
 }
 
 /**
@@ -75,5 +75,5 @@ export function unblockTransition(routeKey?: ScreenKey): void {
 		return;
 	}
 
-	SystemStore.getBag(resolvedRouteKey).actions.unblockLifecycleStart();
+	getMotionStore(resolvedRouteKey).state.actions.unblockLifecycleStart();
 }

package/src/components/activity/variants/activity-screen.tsx

@@ -1,51 +1,62 @@
 import type * as React from "react";
-import { memo } from "react";
+import { memo, useState } from "react";
 import { StyleSheet, View, type ViewProps } from "react-native";
 import { useDerivedValue } from "react-native-reanimated";
 import { useSharedValueState } from "../../../hooks/reanimated/use-shared-value-state";
+import { useOptionalMotionStore } from "../../../providers/screen/motion";
 import { useBlankStackStore } from "../../../providers/stack/blank-stack.provider";
-import { AnimationStore } from "../../../stores/animation.store";
 import type { StackSceneActivity } from "../../../types/stack.types";
 import { ActivityView, type ActivityViewMode } from "../activity-view";
 import { DEFAULT_INACTIVE_BEHAVIOR, type InactiveBehavior } from "../helpers";
 
+// Let the content and backdrop layers decide whether to capture touches.
 const PointerEventsByActivity = {
-	active: "auto",
-	inert: "auto",
+	active: "box-none",
+	inert: "box-none",
 	inactive: "none",
 	closing: "none",
 } satisfies Record<StackSceneActivity, ViewProps["pointerEvents"]>;
 
 interface ActivityScreenProps {
 	children: React.ReactNode;
-	inactiveBehavior?: InactiveBehavior;
-	paintDriverRouteKey?: string;
-	hasNestedState?: boolean;
 	routeKey: string;
 }
 
 export const ActivityScreen = memo(function ActivityScreen({
 	children,
-	inactiveBehavior,
-	paintDriverRouteKey,
-	hasNestedState,
 	routeKey,
 }: ActivityScreenProps) {
 	const scene = useBlankStackStore((store) => store.scenesByKey[routeKey]);
-	const stackPaintDriverRouteKey = useBlankStackStore((store) =>
+	const paintDriverRouteKey = useBlankStackStore((store) =>
 		store.paintDriverRouteKeyByRouteKey.get(routeKey),
 	);
-	const stackInactiveBehavior = (
-		scene.descriptor.options as { inactiveBehavior?: InactiveBehavior }
-	).inactiveBehavior;
-	const resolvedInactiveBehavior =
-		inactiveBehavior ?? stackInactiveBehavior ?? DEFAULT_INACTIVE_BEHAVIOR;
-	const resolvedPaintDriverRouteKey =
-		paintDriverRouteKey ?? stackPaintDriverRouteKey;
-	const resolvedHasNestedState = hasNestedState ?? "state" in scene.route;
-	const paintDriverAnimations = resolvedPaintDriverRouteKey
-		? AnimationStore.getBag(resolvedPaintDriverRouteKey)
-		: undefined;
+	const inactiveBehavior =
+		(scene.descriptor.options as { inactiveBehavior?: InactiveBehavior })
+			.inactiveBehavior ?? DEFAULT_INACTIVE_BEHAVIOR;
+	const hasNestedState = "state" in scene.route;
+	const registeredPaintDriverProgress = useOptionalMotionStore(
+		paintDriverRouteKey ?? null,
+		(store) => store.state.transitionProgress,
+	);
+	const [paintDriver, setPaintDriver] = useState({
+		key: paintDriverRouteKey,
+		progress: registeredPaintDriverProgress,
+	});
+	// Activity disconnects the driver's provider when it pauses. Keep observing
+	// the same progress value so that pausing it doesn't wake older screens.
+	if (
+		paintDriver.key !== paintDriverRouteKey ||
+		(registeredPaintDriverProgress !== null &&
+			paintDriver.progress !== registeredPaintDriverProgress)
+	) {
+		setPaintDriver({
+			key: paintDriverRouteKey,
+			progress: registeredPaintDriverProgress,
+		});
+	}
+	const paintDriverProgress =
+		registeredPaintDriverProgress ??
+		(paintDriver.key === paintDriverRouteKey ? paintDriver.progress : null);
 
 	/**
 	 * Avoid hiding inactive content until the screen that exposes it has settled.
@@ -57,11 +68,11 @@ export const ActivityScreen = memo(function ActivityScreen({
 	const isPaintDriverSettled = useDerivedValue(() => {
 		"worklet";
 
-		if (!paintDriverAnimations) {
+		if (!paintDriverProgress) {
 			return false;
 		}
 
-		return paintDriverAnimations.transitionProgress.get() >= 1;
+		return paintDriverProgress.get() >= 1;
 	});
 
 	const isPaintDriverSettledOnJS = useSharedValueState(isPaintDriverSettled);
@@ -71,9 +82,9 @@ export const ActivityScreen = memo(function ActivityScreen({
 	let visible = scene.activity !== "inactive";
 
 	if (scene.activity === "inactive") {
-		if (resolvedInactiveBehavior === "keep" || !isPaintDriverSettledOnJS) {
+		if (inactiveBehavior === "keep" || !isPaintDriverSettledOnJS) {
 			visible = true;
-		} else if (resolvedInactiveBehavior === "pause") {
+		} else if (inactiveBehavior === "pause") {
 			activityViewMode = "paused";
 			visible = true;
 		} else {
@@ -83,9 +94,9 @@ export const ActivityScreen = memo(function ActivityScreen({
 	}
 
 	const shouldUnmount =
-		resolvedInactiveBehavior === "unmount" &&
+		inactiveBehavior === "unmount" &&
 		scene.activity === "inactive" &&
-		!resolvedHasNestedState &&
+		!hasNestedState &&
 		isPaintDriverSettledOnJS;
 
 	if (shouldUnmount) {

package/src/components/boundary/components/boundary-lifecycle.tsx

@@ -1,7 +1,7 @@
 import { memo } from "react";
 import type { View } from "react-native";
 import type { AnimatedRef } from "react-native-reanimated";
-import { useDescriptorsStore } from "../../../providers/screen/descriptors";
+import { useBuilderStore } from "../../../providers/screen/builder";
 import type { BoundTag } from "../../../stores/bounds/types";
 import { useBoundaryMeasurement } from "../hooks/use-boundary-measurement";
 import type {
@@ -32,7 +32,7 @@ export const BoundaryLifecycle = memo(function BoundaryLifecycle({
 	measuredRef,
 	style,
 }: BoundaryLifecycleProps) {
-	const hasConfiguredInterpolator = useDescriptorsStore(
+	const hasConfiguredInterpolator = useBuilderStore(
 		(s) => s.derivations.hasConfiguredInterpolator,
 	);
 

package/src/components/boundary/components/boundary-target.tsx

@@ -4,7 +4,7 @@ import Animated from "react-native-reanimated";
 import {
 	useComposedSlotStyles,
 	useSlotLayoutStyles,
-} from "../../../providers/screen/styles";
+} from "../../../providers/screen/orchestrator/styles";
 import { logger } from "../../../utils/logger";
 import {
 	BoundaryContentPortal,

package/src/components/boundary/hooks/lifecycles/use-initial-destination-measurement.ts

@@ -7,9 +7,9 @@ import {
 	withTiming,
 } from "react-native-reanimated";
 import { scheduleOnUI } from "react-native-worklets";
-import { useDescriptorsStore } from "../../../../providers/screen/descriptors";
+import { useBuilderStore } from "../../../../providers/screen/builder";
+import { useMotionStore } from "../../../../providers/screen/motion";
 import { useBlankStackStore } from "../../../../providers/stack/blank-stack.provider";
-import { AnimationStore } from "../../../../stores/animation.store";
 import {
 	createScreenPairKey,
 	getSourceScreenKeyFromPairKey,
@@ -21,7 +21,6 @@ import {
 import { getLink } from "../../../../stores/bounds/internals/links";
 import { pairs } from "../../../../stores/bounds/internals/state";
 import type { BoundTag } from "../../../../stores/bounds/types";
-import { SystemStore } from "../../../../stores/system.store";
 import { logger } from "../../../../utils/logger";
 import type { MeasureBoundary } from "../../types";
 import { getInitialDestinationMeasurementSignal } from "../../utils/destination-signals";
@@ -35,6 +34,7 @@ const HANDSHAKE_RETRY_DELAY_MS = 16;
  * so the open proceeds without that boundary.
  */
 const MAX_HANDSHAKE_RETRIES = 20;
+const EMPTY_SCENES: never[] = [];
 
 interface UseInitialDestinationMeasurementParams {
 	boundTag: BoundTag;
@@ -48,11 +48,11 @@ export const useInitialDestinationMeasurement = ({
 	measureBoundary,
 }: UseInitialDestinationMeasurementParams) => {
 	const { tag, linkKey, group } = boundTag;
-	const currentScreenKey = useDescriptorsStore(
+	const currentScreenKey = useBuilderStore(
 		(s) => s.derivations.currentScreenKey,
 	);
-	const nextScreenKey = useDescriptorsStore((s) => s.derivations.nextScreenKey);
-	const destinationPairKey = useDescriptorsStore(
+	const nextScreenKey = useBuilderStore((s) => s.derivations.nextScreenKey);
+	const destinationPairKey = useBuilderStore(
 		(s) => s.derivations.destinationPairKey,
 	);
 	const destinationEnabled = enabled && !nextScreenKey;
@@ -60,7 +60,9 @@ export const useInitialDestinationMeasurement = ({
 	const preferredSourceScreenKey = destinationPairKey
 		? getSourceScreenKeyFromPairKey(destinationPairKey)
 		: undefined;
-	const stackScenes = useBlankStackStore((store) => store.scenes);
+	const stackScenes = useBlankStackStore((store) =>
+		canReceiveDestination ? store.scenes : EMPTY_SCENES,
+	);
 	// A retained closing screen can still have registered boundaries, but it
 	// cannot own a new transition link.
 	const closingSourceScreenKeys = useMemo(
@@ -70,14 +72,11 @@ export const useInitialDestinationMeasurement = ({
 				.map((scene) => scene.route.key),
 		[stackScenes],
 	);
-	const progress = AnimationStore.getValue(
-		currentScreenKey,
-		"transitionProgress",
-	);
+	const progress = useMotionStore((store) => store.state.transitionProgress);
 
-	const {
-		actions: { blockLifecycleStart, unblockLifecycleStart },
-	} = SystemStore.getBag(currentScreenKey);
+	const { blockLifecycleStart, unblockLifecycleStart } = useMotionStore(
+		(store) => store.state.actions,
+	);
 
 	const isBlockingLifecycleStart = useSharedValue(0);
 	const retryToken = useSharedValue(0);

package/src/components/boundary/hooks/lifecycles/use-initial-source-measurement.ts

@@ -1,5 +1,5 @@
 import { useAnimatedReaction, useSharedValue } from "react-native-reanimated";
-import { useDescriptorsStore } from "../../../../providers/screen/descriptors";
+import { useBuilderStore } from "../../../../providers/screen/builder";
 import { getPairKeyForSource } from "../../../../stores/bounds/internals/links";
 import { pairs } from "../../../../stores/bounds/internals/state";
 import type { BoundTag } from "../../../../stores/bounds/types";
@@ -12,7 +12,7 @@ export const useInitialSourceMeasurement = (params: {
 	boundTag: BoundTag;
 }) => {
 	const { enabled, measureBoundary, boundTag } = params;
-	const currentScreenKey = useDescriptorsStore(
+	const currentScreenKey = useBuilderStore(
 		(s) => s.derivations.currentScreenKey,
 	);
 	const lastSourceCaptureSignal = useSharedValue<string | null>(null);

package/src/components/boundary/hooks/lifecycles/use-refresh-boundary.ts

@@ -1,6 +1,6 @@
 import { useAnimatedReaction } from "react-native-reanimated";
-import { useDescriptorsStore } from "../../../../providers/screen/descriptors";
-import { AnimationStore } from "../../../../stores/animation.store";
+import { useBuilderStore } from "../../../../providers/screen/builder";
+import { useOptionalMotionStore } from "../../../../providers/screen/motion";
 import {
 	getPairKeyForDestination,
 	getPairKeyForSource,
@@ -22,31 +22,34 @@ export const useRefreshBoundary = ({
 	measureBoundary,
 }: UseRefreshBoundaryParams) => {
 	const { linkKey, group } = boundTag;
-	const currentScreenKey = useDescriptorsStore(
+	const currentScreenKey = useBuilderStore(
 		(s) => s.derivations.currentScreenKey,
 	);
-	const nextScreenKey = useDescriptorsStore((s) => s.derivations.nextScreenKey);
+	const nextScreenKey = useBuilderStore((s) => s.derivations.nextScreenKey);
 	// Source-side boundaries refresh from the next screen's lifecycle pulse.
 	// Destination-side boundaries have no next screen, so they refresh from self.
 	const refreshScreenKey = nextScreenKey ?? currentScreenKey;
-	const refreshWillAnimate = AnimationStore.getValue(
+	const willAnimate = useOptionalMotionStore(
 		refreshScreenKey,
-		"willAnimate",
+		(store) => store.state.willAnimate,
 	);
-	const refreshSettled = AnimationStore.getValue(
+	const progressSettled = useOptionalMotionStore(
 		refreshScreenKey,
-		"progressSettled",
+		(store) => store.state.progressSettled,
+	);
+	const closing = useOptionalMotionStore(
+		refreshScreenKey,
+		(store) => store.state.closing,
 	);
-	const refreshClosing = AnimationStore.getValue(refreshScreenKey, "closing");
 
 	useAnimatedReaction(
 		() => {
 			"worklet";
 
-			if (!enabled) return null;
+			if (!enabled || !willAnimate || !progressSettled || !closing) return null;
 
-			const shouldRefresh = !!refreshWillAnimate.get();
-			const settled = !!refreshSettled.get();
+			const shouldRefresh = !!willAnimate.get();
+			const settled = !!progressSettled.get();
 			// A group's active member can change while the transition is settled
 			// (for example, paging a destination gallery). Let that member publish
 			// fresh bounds even though there is no willAnimate lifecycle pulse yet.
@@ -67,7 +70,7 @@ export const useRefreshBoundary = ({
 				group,
 				shouldRefresh,
 				settled,
-				closing: !!refreshClosing.get(),
+				closing: !!closing.get(),
 				linkState: pairs.get(),
 			});
 		},

package/src/components/boundary/hooks/use-measurer.ts

@@ -2,11 +2,14 @@ import { useCallback } from "react";
 import type { View } from "react-native";
 import { useWindowDimensions } from "react-native";
 import type { AnimatedRef, StyleProps } from "react-native-reanimated";
-import { applyMeasuredBoundsWrites } from "../../../providers/helpers/measured-bounds-writes";
-import { useScreenSlotStore } from "../../../providers/screen/styles";
+import { useMotionStore } from "../../../providers/screen/motion";
+import { setEntry } from "../../../stores/bounds/internals/entries";
+import {
+	setDestination,
+	setSource,
+} from "../../../stores/bounds/internals/links";
 import type { BoundTag } from "../../../stores/bounds/types";
 import { ScrollStore } from "../../../stores/scroll.store";
-import { SystemStore } from "../../../stores/system.store";
 import { getVisibilityBlockOffset } from "../../../utils/visibility-block-offset";
 import type { BoundaryLocalMeasurementValue, MeasureBoundary } from "../types";
 import {
@@ -42,13 +45,10 @@ export const useMeasurer = ({
 
 	const scrollState = ScrollStore.getValue(currentScreenKey, "coordination");
 	const scrollMetadata = ScrollStore.getValue(currentScreenKey, "metadata");
-	const pendingLifecycleStartBlockCount = SystemStore.getValue(
-		currentScreenKey,
-		"pendingLifecycleStartBlockCount",
-	);
-	const visibilityBlocked = useScreenSlotStore(
-		(store) => store.visibilityBlocked,
+	const pendingLifecycleStartBlockCount = useMotionStore(
+		(store) => store.state.pendingLifecycleStartBlockCount,
 	);
+	const isScreenReady = useMotionStore((store) => store.isScreenReady);
 
 	return useCallback(
 		(target) => {
@@ -64,7 +64,7 @@ export const useMeasurer = ({
 
 			const correctedMeasured = correctMeasuredBoundsForVisibilityGate({
 				measured,
-				visibilityBlocked: visibilityBlocked.get(),
+				isScreenReady: isScreenReady.get(),
 				visibilityBlockOffset: getVisibilityBlockOffset(viewportHeight),
 				viewportWidth,
 				viewportHeight,
@@ -103,17 +103,32 @@ export const useMeasurer = ({
 				scrollMetadata.get(),
 			);
 
-			applyMeasuredBoundsWrites({
-				entryTag: boundTag.tag,
-				linkId: boundTag.linkKey,
-				group: boundTag.group,
-				currentScreenKey,
-				measured: measuredWithScroll,
-				preparedStyles,
-				linkWrite: target,
-				handoff,
-				escapeClipping,
-			});
+			// Refresh the public bounds entry on every accepted measurement.
+			setEntry(boundTag.tag, currentScreenKey, { bounds: measuredWithScroll });
+
+			if (target.type === "source") {
+				setSource(
+					target.pairKey,
+					boundTag.linkKey,
+					currentScreenKey,
+					measuredWithScroll,
+					preparedStyles,
+					boundTag.group,
+					{ handoff, escapeClipping },
+				);
+			}
+
+			if (target.type === "destination") {
+				setDestination(
+					target.pairKey,
+					boundTag.linkKey,
+					currentScreenKey,
+					measuredWithScroll,
+					preparedStyles,
+					boundTag.group,
+					{ handoff },
+				);
+			}
 		},
 		[
 			enabled,
@@ -129,7 +144,7 @@ export const useMeasurer = ({
 			scrollState,
 			scrollMetadata,
 			pendingLifecycleStartBlockCount,
-			visibilityBlocked,
+			isScreenReady,
 		],
 	);
 };

package/src/components/boundary/portal/components/boundary-content-portal/helpers/active-handoff-receiver.ts

@@ -57,7 +57,7 @@ export const resolveHandoffAttachmentCandidate = ({
 	activeReceiverScreenKey,
 	attachedReceiverScreenKey,
 	hasActiveCloseFinished,
-	interpolatorReady,
+	isScreenReady,
 	pairChangedDuringClose = false,
 	pairDestinationScreenKey,
 	pairHasBoundaryLink,
@@ -67,7 +67,7 @@ export const resolveHandoffAttachmentCandidate = ({
 	activeReceiverScreenKey: string | null;
 	attachedReceiverScreenKey: string;
 	hasActiveCloseFinished: boolean;
-	interpolatorReady: boolean;
+	isScreenReady: boolean;
 	pairChangedDuringClose?: boolean;
 	pairDestinationScreenKey: string | null;
 	pairHasBoundaryLink?: boolean;
@@ -87,7 +87,7 @@ export const resolveHandoffAttachmentCandidate = ({
 
 	if (
 		activeReceiverClosing &&
-		interpolatorReady &&
+		isScreenReady &&
 		pairDestinationScreenKey &&
 		pairChangedDuringClose
 	) {
@@ -118,7 +118,7 @@ export const resolveHandoffAttachmentCandidate = ({
 	if (
 		activeReceiverClosing &&
 		attachedReceiverScreenKey !== activeReceiverScreenKey &&
-		interpolatorReady &&
+		isScreenReady &&
 		pairDestinationScreenKey
 	) {
 		return pairDestinationScreenKey;