react-native-screen-transitions 3.9.0 → 3.11.0

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

@@ -7,8 +7,8 @@ import {
 } from "../../hooks/navigation/use-stack";
 import { ScreenComposer } from "../../providers/screen/screen-composer";
 import {
-	useStackCoreContext,
-	withStackCore,
+	StackCoreProvider,
+	useStackCoreStore,
 } from "../../providers/stack/core.provider";
 import type { BaseStackDescriptor, BaseStackRoute } from "../../types";
 import { StackType } from "../../types/stack.types";
@@ -102,6 +102,12 @@ function buildTransitionStackState({
 		}
 
 		scenes.push({
+			activity:
+				sceneIndex === state.index
+					? "active"
+					: sceneIndex === state.index - 1
+						? "inert"
+						: "inactive",
 			route,
 			descriptor: normalizedDescriptor,
 			previousDescriptor,
@@ -137,7 +143,7 @@ function ScreenTransitionsStackContent({
 	layout,
 	layoutArgs,
 }: ScreenTransitionsStackContentProps) {
-	const { flags } = useStackCoreContext();
+	const flags = useStackCoreStore((store) => store.flags);
 	const transitionState = useMemo(
 		() =>
 			buildTransitionStackState({
@@ -183,10 +189,17 @@ function ScreenTransitionsStackContent({
 	);
 }
 
-export const ScreenTransitionsStackLayout = withStackCore(
-	{ TRANSITIONS_ALWAYS_ON: false, STACK_TYPE: StackType.NATIVE },
-	ScreenTransitionsStackContent,
-);
+export function ScreenTransitionsStackLayout(
+	props: ScreenTransitionsStackContentProps,
+) {
+	return (
+		<StackCoreProvider
+			config={{ TRANSITIONS_ALWAYS_ON: false, STACK_TYPE: StackType.NATIVE }}
+		>
+			<ScreenTransitionsStackContent {...props} />
+		</StackCoreProvider>
+	);
+}
 
 export function ScreenTransitionsScreenLayout({
 	screenLayout,

package/src/shared/animation/snap-to.ts

@@ -49,6 +49,10 @@ export function snapDescriptorToIndex(
 		descriptor.route.key,
 		"targetProgress",
 	);
+	const animationProgressValue = SystemStore.getValue(
+		descriptor.route.key,
+		"animationProgress",
+	);
 
 	runOnUI(() => {
 		"worklet";
@@ -56,8 +60,10 @@ export function snapDescriptorToIndex(
 
 		animateToProgress({
 			target: targetProgress,
+			markEntering: false,
 			animations,
 			targetProgress: targetProgressValue,
+			animationProgress: animationProgressValue,
 			spec: resolveSnapTransitionSpec(
 				descriptor.options.transitionSpec,
 				targetProgress < currentProgress ? "collapse" : "expand",

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

@@ -6,6 +6,7 @@ import { Screen } from "react-native-screens";
 import { IS_WEB } from "../../../constants";
 import { useStack } from "../../../hooks/navigation/use-stack";
 import { useSharedValueState } from "../../../hooks/reanimated/use-shared-value-state";
+import { useBlankStackStore } from "../../../providers/stack/blank-stack.provider";
 import { AnimationStore } from "../../../stores/animation.store";
 import type { StackSceneActivity } from "../../../types/stack.types";
 import { DEFAULT_INACTIVE_BEHAVIOR, type InactiveBehavior } from "../helpers";
@@ -26,23 +27,55 @@ const PointerEventsByActivity = {
 } satisfies Record<StackSceneActivity, ViewProps["pointerEvents"]>;
 
 interface ActivityScreenProps {
-	activity: StackSceneActivity;
+	activity?: StackSceneActivity;
 	children: React.ReactNode;
 	inactiveBehavior?: InactiveBehavior;
 	paintDriverRouteKey?: string;
 	hasNestedState?: boolean;
+	routeKey?: string;
 }
 
 export const ActivityScreen = memo(function ActivityScreen({
 	activity,
 	children,
-	inactiveBehavior = DEFAULT_INACTIVE_BEHAVIOR,
+	inactiveBehavior,
 	paintDriverRouteKey,
 	hasNestedState,
+	routeKey,
 }: ActivityScreenProps) {
+	const stackActivity = useBlankStackStore((store) =>
+		routeKey ? store?.scenesByKey[routeKey]?.activity : undefined,
+	);
+	const stackInactiveBehavior = useBlankStackStore((store) =>
+		routeKey
+			? (
+					store?.scenesByKey[routeKey]?.descriptor.options as
+						| { inactiveBehavior?: InactiveBehavior }
+						| undefined
+				)?.inactiveBehavior
+			: undefined,
+	);
+	const stackRoute = useBlankStackStore((store) =>
+		routeKey ? store?.scenesByKey[routeKey]?.route : undefined,
+	);
+	const stackPaintDriverRouteKey = useBlankStackStore((store) => {
+		if (!routeKey || !store) {
+			return undefined;
+		}
+
+		const routeIndex = store.routeKeys.indexOf(routeKey);
+		return store.routeKeys[routeIndex + 2];
+	});
+	const resolvedActivity = activity ?? stackActivity ?? "active";
+	const resolvedInactiveBehavior =
+		inactiveBehavior ?? stackInactiveBehavior ?? DEFAULT_INACTIVE_BEHAVIOR;
+	const resolvedPaintDriverRouteKey =
+		paintDriverRouteKey ?? stackPaintDriverRouteKey;
+	const resolvedHasNestedState =
+		hasNestedState ?? (stackRoute ? "state" in stackRoute : false);
 	const nativeScreenDisabled = useStack((s) => s.flags.DISABLE_NATIVE_SCREENS);
-	const paintDriverAnimations = paintDriverRouteKey
-		? AnimationStore.getBag(paintDriverRouteKey)
+	const paintDriverAnimations = resolvedPaintDriverRouteKey
+		? AnimationStore.getBag(resolvedPaintDriverRouteKey)
 		: undefined;
 
 	/**
@@ -64,14 +97,14 @@ export const ActivityScreen = memo(function ActivityScreen({
 
 	const isPaintDriverSettledOnJS = useSharedValueState(isPaintDriverSettled);
 
-	let activityState: ActivityState = ActivityStateByActivity[activity];
+	let activityState: ActivityState = ActivityStateByActivity[resolvedActivity];
 	let shouldFreeze = false;
-	let visible = activity !== "inactive";
+	let visible = resolvedActivity !== "inactive";
 
 	const shouldWaitForPaintDriver = !isPaintDriverSettledOnJS;
 
-	if (activity === "inactive") {
-		if (inactiveBehavior === "keep") {
+	if (resolvedActivity === "inactive") {
+		if (resolvedInactiveBehavior === "keep") {
 			activityState = 1;
 			visible = true;
 		} else if (shouldWaitForPaintDriver) {
@@ -79,7 +112,7 @@ export const ActivityScreen = memo(function ActivityScreen({
 			// a blank frame during the transition.
 			activityState = 1;
 			visible = true;
-		} else if (inactiveBehavior === "pause") {
+		} else if (resolvedInactiveBehavior === "pause") {
 			activityState = 1;
 			shouldFreeze = true;
 			visible = true;
@@ -93,12 +126,12 @@ export const ActivityScreen = memo(function ActivityScreen({
 	}
 
 	const shouldUnmount =
-		inactiveBehavior === "unmount" &&
-		activity === "inactive" &&
-		!hasNestedState &&
+		resolvedInactiveBehavior === "unmount" &&
+		resolvedActivity === "inactive" &&
+		!resolvedHasNestedState &&
 		isPaintDriverSettledOnJS;
 
-	const pointerEvents = PointerEventsByActivity[activity];
+	const pointerEvents = PointerEventsByActivity[resolvedActivity];
 
 	if (shouldUnmount) {
 		return null;

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

@@ -1,19 +1,20 @@
 import type React from "react";
-import { memo, useMemo } from "react";
-import type { View } from "react-native";
-import Animated, { useAnimatedRef } from "react-native-reanimated";
+import { memo, useLayoutEffect } from "react";
+import Animated from "react-native-reanimated";
 import {
 	useComposedSlotStyles,
 	useSlotLayoutStyles,
 } from "../../../providers/screen/styles";
-import { prepareStyleForBounds } from "../../../utils/bounds/helpers/styles/styles";
-import { useRegisterTarget } from "../hooks/use-register-target";
+import { logger } from "../../../utils/logger";
 import {
 	BoundaryContentPortal,
 	BoundaryContentPortalHost,
 } from "../portal/components/boundary-content-portal";
 import { BoundaryPortal } from "../portal/components/boundary-portal";
-import { useBoundaryRootContext } from "../providers/boundary-root.provider";
+import {
+	TARGET_OUTSIDE_ROOT_WARNING,
+	useBoundaryRootStore,
+} from "../providers/boundary-root.provider";
 
 type BoundaryTargetProps = Omit<
 	React.ComponentProps<typeof Animated.View>,
@@ -22,19 +23,26 @@ type BoundaryTargetProps = Omit<
 	children?: React.ReactNode;
 };
 
-export const BoundaryTarget = memo(function BoundaryTarget(
-	props: BoundaryTargetProps,
-) {
-	const { children, pointerEvents, style, ...rest } = props;
-	const targetAnimatedRef = useAnimatedRef<View>();
-	const targetEscapePlaceholderRef = useAnimatedRef<View>();
-	const rootContext = useBoundaryRootContext();
+export const BOUNDARY_TARGET_ACTIVE_PROP = "__boundaryTargetActive" as const;
+type InternalBoundaryTargetProps = BoundaryTargetProps & {
+	[BOUNDARY_TARGET_ACTIVE_PROP]?: boolean;
+};
+
+const BoundaryTargetInner = (props: InternalBoundaryTargetProps) => {
+	const {
+		[BOUNDARY_TARGET_ACTIVE_PROP]: active,
+		children,
+		pointerEvents,
+		style,
+		...rest
+	} = props;
+	const rootContext = useBoundaryRootStore();
 	const boundaryId = rootContext?.boundTag.tag;
-	const isActiveTarget = rootContext?.activeTargetRef === targetAnimatedRef;
+	const isActiveTarget = active === true && rootContext !== null;
 	const portalRuntime = rootContext?.portalRuntime;
 	const handoffEnabled = isActiveTarget && rootContext?.handoffEnabled === true;
 	const shouldEscapeTargetToScreenHost =
-		portalRuntime?.escapeClipping === true && boundaryId !== undefined;
+		isActiveTarget && portalRuntime?.escapeClipping === true;
 
 	const shouldApplyAssociatedStyleInline =
 		isActiveTarget && portalRuntime?.escapeClipping !== true;
@@ -46,24 +54,26 @@ export const BoundaryTarget = memo(function BoundaryTarget(
 		style,
 	);
 	const portalLayoutStyle = useSlotLayoutStyles(rootContext?.boundTag.tag);
-	const preparedStyles = useMemo(() => prepareStyleForBounds(style), [style]);
-
-	const measurementRef = shouldEscapeTargetToScreenHost
-		? targetEscapePlaceholderRef
-		: targetAnimatedRef;
+	const measurementRef = isActiveTarget
+		? rootContext.measurementRef
+		: undefined;
 
-	useRegisterTarget({ preparedStyles, measurementRef, targetAnimatedRef });
+	useLayoutEffect(() => {
+		if (__DEV__ && rootContext === null) {
+			logger.warn(TARGET_OUTSIDE_ROOT_WARNING);
+		}
+	}, [rootContext]);
 
 	return (
 		<BoundaryPortal
 			boundaryId={boundaryId ?? ""}
 			enabled={shouldEscapeTargetToScreenHost}
-			placeholderRef={targetEscapePlaceholderRef}
+			placeholderRef={measurementRef}
 		>
 			<Animated.View
 				{...rest}
 				pointerEvents={pointerEvents}
-				ref={targetAnimatedRef}
+				ref={shouldEscapeTargetToScreenHost ? undefined : measurementRef}
 				style={[
 					style,
 					shouldApplyAssociatedStyleInline ? associatedTargetStyles : undefined,
@@ -86,4 +96,8 @@ export const BoundaryTarget = memo(function BoundaryTarget(
 			</Animated.View>
 		</BoundaryPortal>
 	);
-});
+};
+
+export const BoundaryTarget = memo(
+	BoundaryTargetInner,
+) as React.NamedExoticComponent<BoundaryTargetProps>;

package/src/shared/components/boundary/create-boundary-component.tsx

@@ -1,9 +1,20 @@
-import { type ComponentType, forwardRef, memo } from "react";
+import {
+	type ComponentType,
+	cloneElement,
+	forwardRef,
+	memo,
+	useMemo,
+} from "react";
 import Animated from "react-native-reanimated";
+import {
+	BOUNDARY_TARGET_ACTIVE_PROP,
+	BoundaryTarget,
+} from "./components/boundary-target";
 import { BoundaryContentPortalHost } from "./portal/components/boundary-content-portal";
 import { BoundaryPortal } from "./portal/components/boundary-portal";
 import { BoundaryRootProvider } from "./providers/boundary-root.provider";
 import type { BoundaryComponentProps } from "./types";
+import { resolveBoundaryTarget } from "./utils/resolve-boundary-target";
 
 interface CreateBoundaryComponentOptions {
 	alreadyAnimated?: boolean;
@@ -36,6 +47,18 @@ export function createBoundaryComponent<P extends object>(
 			children,
 			...rest
 		} = props as any;
+		const targetResolution = useMemo(() => {
+			return resolveBoundaryTarget(children, {
+				isTarget: (element) => element.type === BoundaryTarget,
+				mapTarget: (element, selected) =>
+					cloneElement(element, {
+						[BOUNDARY_TARGET_ACTIVE_PROP]: selected,
+					} as any),
+			});
+		}, [children]);
+		const targetStyle = (
+			targetResolution.target?.props as { style?: unknown } | undefined
+		)?.style;
 
 		return (
 			<BoundaryRootProvider
@@ -45,14 +68,17 @@ export function createBoundaryComponent<P extends object>(
 				forwardedRef={forwardedRef}
 				group={group}
 				handoff={handoff}
+				hasTarget={targetResolution.target !== null}
 				id={id}
 				style={style}
+				targetCount={targetResolution.targetCount}
+				targetStyle={targetStyle}
 			>
 				{(root) => (
 					<BoundaryPortal
 						boundaryId={root.boundTag.tag}
 						enabled={root.shouldRenderBoundaryRootThroughPortal}
-						placeholderRef={root.rootEscapePlaceholderRef}
+						placeholderRef={root.measurementRef}
 					>
 						<AnimatedComponent
 							{...rest}
@@ -65,7 +91,7 @@ export function createBoundaryComponent<P extends object>(
 								enabled={root.shouldRenderHandoffHost}
 								screenKey={root.currentScreenKey}
 							>
-								{children}
+								{targetResolution.children}
 							</BoundaryContentPortalHost>
 						</AnimatedComponent>
 					</BoundaryPortal>

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

@@ -19,7 +19,9 @@ import { logger } from "../../../../utils/logger";
 import type { MeasureBoundary } from "../../types";
 import { getInitialDestinationMeasurementSignal } from "../../utils/destination-signals";
 
-const HANDSHAKE_RETRY_DELAY_MS = 100;
+// A missed layout should be retried on the next frame. The previous 100 ms
+// interval made each ordinary Android layout miss visibly delay navigation.
+const HANDSHAKE_RETRY_DELAY_MS = 16;
 /**
  * A destination whose initial handshake never completes must not hold the
  * transition gate forever. After this budget, release the block with a warning
@@ -122,25 +124,32 @@ export const useInitialDestinationMeasurement = ({
 	useAnimatedReaction(
 		() => {
 			"worklet";
+
+			if (
+				!destinationEnabled ||
+				!initialDestinationPairKey ||
+				isBlockingLifecycleStart.get() <= 0
+			) {
+				return null;
+			}
+
+			if (progress.get() > 0) {
+				return null;
+			}
+
 			const retryTick = retryToken.get();
-			const isWaitingForOpenToStart = progress.get() <= 0;
-			const sourceScreenKey = initialDestinationPairKey
-				? getSourceScreenKeyFromPairKey(initialDestinationPairKey)
-				: undefined;
+			const sourceScreenKey = getSourceScreenKeyFromPairKey(
+				initialDestinationPairKey,
+			);
 			const signal = getInitialDestinationMeasurementSignal({
-				enabled:
-					destinationEnabled &&
-					isWaitingForOpenToStart &&
-					isBlockingLifecycleStart.get() > 0,
+				enabled: destinationEnabled,
 				destinationPairKey,
 				ancestorDestinationPairKey,
 				linkId: linkKey,
 				group,
 				destinationPresent: getEntry(tag, currentScreenKey) !== null,
-				sourcePresent:
-					sourceScreenKey !== undefined &&
-					getEntry(tag, sourceScreenKey) !== null,
-				linkState: initialDestinationPairKey ? pairs.get() : undefined,
+				sourcePresent: getEntry(tag, sourceScreenKey) !== null,
+				linkState: pairs.get(),
 			});
 
 			return [
@@ -149,8 +158,13 @@ export const useInitialDestinationMeasurement = ({
 				retryTick,
 			] as const;
 		},
-		([measurePairKey, action, retryTick], previous) => {
+		(next, previous) => {
 			"worklet";
+			if (!next) {
+				return;
+			}
+
+			const [measurePairKey, action, retryTick] = next;
 			if (!measurePairKey || !action) {
 				return;
 			}

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

@@ -37,19 +37,16 @@ export const useRefreshBoundary = ({
 		"willAnimate",
 	);
 	const refreshClosing = AnimationStore.getValue(refreshScreenKey, "closing");
-	const refreshEntering = AnimationStore.getValue(refreshScreenKey, "entering");
-	const refreshAnimating = AnimationStore.getValue(
-		refreshScreenKey,
-		"progressAnimating",
-	);
-	const refreshProgress = AnimationStore.getValue(
-		refreshScreenKey,
-		"transitionProgress",
-	);
 
 	useAnimatedReaction(
 		() => {
 			"worklet";
+
+			const shouldRefresh = enabled && !!refreshWillAnimate.get();
+			if (!shouldRefresh) {
+				return null;
+			}
+
 			return getRefreshBoundarySignal({
 				enabled,
 				currentScreenKey,
@@ -59,11 +56,8 @@ export const useRefreshBoundary = ({
 				nextScreenKey,
 				linkId: linkKey,
 				group,
-				shouldRefresh: !!refreshWillAnimate.get(),
+				shouldRefresh,
 				closing: !!refreshClosing.get(),
-				entering: !!refreshEntering.get(),
-				animating: !!refreshAnimating.get(),
-				progress: refreshProgress.get(),
 				linkState: pairs.get(),
 			});
 		},

package/src/shared/components/boundary/hooks/use-boundary-measurement.ts

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
 import type { View } from "react-native";
-import type { AnimatedRef, StyleProps } from "react-native-reanimated";
+import type { AnimatedRef } from "react-native-reanimated";
 import type { BoundTag } from "../../../stores/bounds/types";
 import { prepareStyleForBounds } from "../../../utils/bounds/helpers/styles/styles";
 import type { BoundaryConfigProps } from "../types";
@@ -19,9 +19,8 @@ interface UseBoundaryMeasurementParams {
 	currentScreenKey: string;
 	/** Surface to measure: a nested target's placeholder, else the root. */
 	measuredRef: AnimatedRef<View>;
-	/** Root's own style; ignored when a nested target supplies its own. */
+	/** Style belonging to the selected measurement surface. */
 	style?: unknown;
-	targetPreparedStyles?: StyleProps;
 	handoff: boolean;
 	escapeClipping: boolean;
 	config: BoundaryConfigProps;
@@ -39,7 +38,6 @@ export const useBoundaryMeasurement = ({
 	currentScreenKey,
 	measuredRef,
 	style,
-	targetPreparedStyles,
 	handoff,
 	escapeClipping,
 	config,
@@ -50,11 +48,7 @@ export const useBoundaryMeasurement = ({
 		[anchor, scaleMode, target, method],
 	);
 
-	const rootPreparedStyles = useMemo(
-		() => prepareStyleForBounds(style),
-		[style],
-	);
-	const preparedStyles = targetPreparedStyles ?? rootPreparedStyles;
+	const preparedStyles = useMemo(() => prepareStyleForBounds(style), [style]);
 
 	const measureBoundary = useMeasurer({
 		enabled,

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

@@ -1,13 +1,8 @@
 import { useCallback } from "react";
 import type { View } from "react-native";
 import { useWindowDimensions } from "react-native";
-import {
-	type AnimatedRef,
-	measure,
-	type StyleProps,
-} from "react-native-reanimated";
+import type { AnimatedRef, StyleProps } from "react-native-reanimated";
 import { applyMeasuredBoundsWrites } from "../../../providers/helpers/measured-bounds-writes";
-import { useOriginContext } from "../../../providers/screen/origin.provider";
 import { useScreenSlots } from "../../../providers/screen/styles";
 import type { BoundTag } from "../../../stores/bounds/types";
 import { ScrollStore } from "../../../stores/scroll.store";
@@ -16,9 +11,9 @@ import { getVisibilityBlockOffset } from "../../../utils/visibility-block-offset
 import type { MeasureBoundary } from "../types";
 import {
 	attachScrollSnapshotToMeasuredBounds,
+	correctMeasuredBoundsForVisibilityGate,
 	isMeasurementInViewport,
 	measureWithOverscrollAwareness,
-	normalizeMeasuredBoundsWithVisibilityGate,
 } from "../utils/measured-bounds";
 
 interface UseMeasurerParams {
@@ -49,7 +44,6 @@ export const useMeasurer = ({
 		currentScreenKey,
 		"pendingLifecycleStartBlockCount",
 	);
-	const { originRef } = useOriginContext();
 	const { visibilityBlocked } = useScreenSlots();
 
 	return useCallback(
@@ -61,14 +55,12 @@ export const useMeasurer = ({
 				measuredAnimatedRef,
 				scrollState.get(),
 			);
-			const measuredOrigin = measure(originRef);
 
-			if (!measured || !measuredOrigin) return;
+			if (!measured) return;
 
-			const normalizedMeasured = normalizeMeasuredBoundsWithVisibilityGate({
+			const correctedMeasured = correctMeasuredBoundsForVisibilityGate({
 				measured,
-				origin: measuredOrigin,
-				visibilityBlocked: escapeClipping && visibilityBlocked.get(),
+				visibilityBlocked: visibilityBlocked.get(),
 				visibilityBlockOffset: getVisibilityBlockOffset(viewportHeight),
 				viewportWidth,
 				viewportHeight,
@@ -88,7 +80,7 @@ export const useMeasurer = ({
 				target.type !== "destination" ||
 				!shouldGuardDestinationViewport ||
 				isMeasurementInViewport(
-					normalizedMeasured,
+					correctedMeasured,
 					viewportWidth,
 					viewportHeight,
 				);
@@ -96,7 +88,7 @@ export const useMeasurer = ({
 			if (!viewportAllowsDestinationWrite) return;
 
 			const measuredWithScroll = attachScrollSnapshotToMeasuredBounds(
-				normalizedMeasured,
+				correctedMeasured,
 				scrollMetadata.get(),
 			);
 
@@ -125,7 +117,6 @@ export const useMeasurer = ({
 			scrollState,
 			scrollMetadata,
 			pendingLifecycleStartBlockCount,
-			originRef,
 			visibilityBlocked,
 		],
 	);

package/src/shared/components/boundary/index.tsx

@@ -1,10 +1,6 @@
 import { forwardRef } from "react";
-import {
-	Pressable,
-	type PressableProps,
-	View,
-	type ViewProps,
-} from "react-native";
+import { View, type ViewProps } from "react-native";
+import { Pressable, type PressableProps } from "react-native-gesture-handler";
 import { BoundaryTarget } from "./components/boundary-target";
 import { createBoundaryComponent } from "./create-boundary-component";
 import { Host } from "./portal";
@@ -52,12 +48,12 @@ type BoundaryRootComponent = typeof BoundaryRoot;
  *
  * Use:
  * - `Boundary` for passive and pressable shared elements.
- * - `Boundary.Target` to measure a nested descendant instead of the root.
+ * - `Boundary.Target` as a direct child to measure it instead of the root.
  * - `Boundary.Host` to make clipping-escape host placement explicit.
  */
 export interface BoundaryComponent extends BoundaryRootComponent {
 	/**
-	 * Optional nested measurement override inside a boundary root.
+	 * Optional direct-child measurement override inside a boundary root.
 	 */
 	Target: typeof BoundaryTarget;
 	/**