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

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

@@ -18,6 +18,7 @@ type Props = { children: ReactNode };
 export type ScreenSlotName =
 	| "overlay"
 	| "content"
+	| "surface"
 	| "backdrop"
 	| typeof NAVIGATION_MASK_CONTAINER_STYLE_ID
 	| typeof NAVIGATION_MASK_ELEMENT_STYLE_ID;
@@ -33,6 +34,7 @@ const createScreenSlotProvider = createProvider("ScreenSlot", {
 })<Props, ScreenSlotContextValue>;
 
 export const {
+	StoreProvider: ScreenSlotStoreProvider,
 	ScreenSlotProvider,
 	useOptionalScreenSlotStore,
 	useScreenSlotStore,

package/src/{factories/screen-topology → providers/screen/topology/helpers}/create-screen-topology.ts

@@ -3,28 +3,35 @@ import type {
 	ScreenRelationships,
 	ScreenTopology,
 	ScreenTopologyRegistration,
-} from "./types";
+} from "../types";
 
 type ScreenNode = {
+	registered: boolean;
+	navigatorKey: string | null;
 	parentScreenKey: string | null;
 	activeChildScreenKeys: string[];
+	transitionKey: string | null;
 };
 
 const EMPTY_RELATIONSHIPS: ScreenRelationships = {
 	parentScreenKey: null,
 	activeChildScreenKey: null,
+	activeChildNavigatorKey: null,
 };
 
 const areRelationshipsEqual = (
 	left: ScreenRelationships,
 	right: ScreenRelationships,
-): boolean =>
+) =>
 	left.parentScreenKey === right.parentScreenKey &&
-	left.activeChildScreenKey === right.activeChildScreenKey;
+	left.activeChildScreenKey === right.activeChildScreenKey &&
+	left.activeChildNavigatorKey === right.activeChildNavigatorKey;
 
 export const createScreenTopology = (): ScreenTopology => {
 	const nodes = new Map<string, ScreenNode>();
+	const screenKeyByTransitionKey = new Map<string, string>();
 	const listenersByScreenKey = new Map<string, Set<() => void>>();
+	const resolutionListeners = new Set<() => void>();
 	const relationshipCache = new Map<string, ScreenRelationships>();
 
 	const getNode = (screenKey: string) => nodes.get(screenKey);
@@ -33,8 +40,11 @@ export const createScreenTopology = (): ScreenTopology => {
 		if (existing) return existing;
 
 		const node: ScreenNode = {
+			registered: false,
+			navigatorKey: null,
 			parentScreenKey: null,
 			activeChildScreenKeys: [],
+			transitionKey: null,
 		};
 		nodes.set(screenKey, node);
 		return node;
@@ -44,6 +54,7 @@ export const createScreenTopology = (): ScreenTopology => {
 		const node = getNode(screenKey);
 		if (
 			node &&
+			!node.registered &&
 			!node.parentScreenKey &&
 			node.activeChildScreenKeys.length === 0
 		) {
@@ -53,27 +64,30 @@ export const createScreenTopology = (): ScreenTopology => {
 
 	const getParent = (screenKey: string) =>
 		getNode(screenKey)?.parentScreenKey ?? null;
-
 	const getActiveChild = (screenKey: string) => {
-		const activeChildScreenKeys = getNode(screenKey)?.activeChildScreenKeys;
-		return activeChildScreenKeys?.[activeChildScreenKeys.length - 1] ?? null;
+		const children = getNode(screenKey)?.activeChildScreenKeys;
+		return children?.[children.length - 1] ?? null;
 	};
 
 	const materializeRelationships = (screenKey: string): ScreenRelationships => {
 		const parentScreenKey = getParent(screenKey);
 		const activeChildScreenKey = getActiveChild(screenKey);
+		const activeChildNavigatorKey = activeChildScreenKey
+			? (getNode(activeChildScreenKey)?.navigatorKey ?? null)
+			: null;
 
-		if (!parentScreenKey && !activeChildScreenKey) {
-			return EMPTY_RELATIONSHIPS;
-		}
+		if (!parentScreenKey && !activeChildScreenKey) return EMPTY_RELATIONSHIPS;
 
-		return { parentScreenKey, activeChildScreenKey };
+		return {
+			parentScreenKey,
+			activeChildScreenKey,
+			activeChildNavigatorKey,
+		};
 	};
 
 	const getRelationships = (screenKey: string) => {
 		const cached = relationshipCache.get(screenKey);
 		if (cached) return cached;
-
 		const relationships = materializeRelationships(screenKey);
 		relationshipCache.set(screenKey, relationships);
 		return relationships;
@@ -93,83 +107,110 @@ export const createScreenTopology = (): ScreenTopology => {
 		}
 
 		for (const [screenKey, previous] of previousRelationships) {
-			const listeners = listenersByScreenKey.get(screenKey);
-			if (!listeners) continue;
-
 			const next = getRelationships(screenKey);
 			if (areRelationshipsEqual(previous, next)) {
 				relationshipCache.set(screenKey, previous);
 				continue;
 			}
-
-			for (const listener of listeners) listener();
+			for (const listener of listenersByScreenKey.get(screenKey) ?? []) {
+				listener();
+			}
 		}
+
+		for (const listener of resolutionListeners) listener();
 	};
 
 	const register = ({
 		screenKey,
+		navigatorKey,
 		parentScreenKey,
+		transitionKey,
 	}: ScreenTopologyRegistration) => {
+		const transitionKeyOwner = transitionKey
+			? screenKeyByTransitionKey.get(transitionKey)
+			: undefined;
+		if (transitionKeyOwner && transitionKeyOwner !== screenKey) {
+			throw new Error(
+				`Transition key "${transitionKey}" is already registered by screen "${transitionKeyOwner}".`,
+			);
+		}
+
 		mutate(new Set([screenKey]), () => {
-			ensureNode(screenKey).parentScreenKey = parentScreenKey ?? null;
+			const node = ensureNode(screenKey);
+			if (
+				node.transitionKey &&
+				node.transitionKey !== transitionKey &&
+				screenKeyByTransitionKey.get(node.transitionKey) === screenKey
+			) {
+				screenKeyByTransitionKey.delete(node.transitionKey);
+			}
+
+			node.registered = true;
+			node.navigatorKey = navigatorKey ?? null;
+			node.parentScreenKey = parentScreenKey ?? null;
+			node.transitionKey = transitionKey ?? null;
+			if (transitionKey) screenKeyByTransitionKey.set(transitionKey, screenKey);
 		});
 	};
 
 	const unregister = (screenKey: string) => {
 		const node = getNode(screenKey);
 		if (!node) return;
-
 		const affectedScreenKeys = new Set([screenKey]);
-		if (node.parentScreenKey) {
-			affectedScreenKeys.add(node.parentScreenKey);
-		}
+		if (node.parentScreenKey) affectedScreenKeys.add(node.parentScreenKey);
 
 		mutate(affectedScreenKeys, () => {
+			if (
+				node.transitionKey &&
+				screenKeyByTransitionKey.get(node.transitionKey) === screenKey
+			) {
+				screenKeyByTransitionKey.delete(node.transitionKey);
+			}
+
 			if (node.parentScreenKey) {
 				const parent = getNode(node.parentScreenKey);
 				if (parent) {
 					parent.activeChildScreenKeys = parent.activeChildScreenKeys.filter(
-						(activeScreenKey) => activeScreenKey !== screenKey,
+						(childScreenKey) => childScreenKey !== screenKey,
 					);
 				}
 				removeNodeIfEmpty(node.parentScreenKey);
 			}
-
 			nodes.delete(screenKey);
 		});
 	};
 
-	const activate = (registration: ActiveScreenRegistration) => {
-		if (getParent(registration.screenKey) !== registration.parentScreenKey) {
+	const activate = ({
+		screenKey,
+		parentScreenKey,
+	}: ActiveScreenRegistration) => {
+		if (getParent(screenKey) !== parentScreenKey) {
 			throw new Error(
 				"Screen topology can only activate a direct containment child.",
 			);
 		}
 
-		const affectedScreenKeys = new Set([registration.parentScreenKey]);
-		mutate(affectedScreenKeys, () => {
-			const parent = ensureNode(registration.parentScreenKey);
-			parent.activeChildScreenKeys = [
-				...parent.activeChildScreenKeys.filter(
-					(screenKey) => screenKey !== registration.screenKey,
-				),
-				registration.screenKey,
-			];
+		mutate(new Set([parentScreenKey]), () => {
+			const parent = ensureNode(parentScreenKey);
+			// A closing screen remains the active owner until it unmounts.
+			if (parent.activeChildScreenKeys.includes(screenKey)) return;
+			parent.activeChildScreenKeys.push(screenKey);
 		});
+	};
 
-		return () => {
-			const parent = getNode(registration.parentScreenKey);
-			if (!parent?.activeChildScreenKeys.includes(registration.screenKey)) {
-				return;
-			}
+	const resolve = (screenKey: string, depth: number) => {
+		if (!Number.isInteger(depth)) return null;
 
-			mutate(affectedScreenKeys, () => {
-				parent.activeChildScreenKeys = parent.activeChildScreenKeys.filter(
-					(screenKey) => screenKey !== registration.screenKey,
-				);
-				removeNodeIfEmpty(registration.parentScreenKey);
-			});
-		};
+		let resolvedScreenKey: string | null = screenKey;
+		for (let step = 0; step < Math.abs(depth); step += 1) {
+			resolvedScreenKey =
+				depth < 0
+					? getParent(resolvedScreenKey)
+					: getActiveChild(resolvedScreenKey);
+			if (!resolvedScreenKey) return null;
+		}
+
+		return getNode(resolvedScreenKey)?.registered ? resolvedScreenKey : null;
 	};
 
 	return {
@@ -177,22 +218,25 @@ export const createScreenTopology = (): ScreenTopology => {
 		unregister,
 		activate,
 		getRelationships,
+		resolve,
+		resolveTransitionKey: (key) => {
+			const screenKey = screenKeyByTransitionKey.get(key) ?? key;
+			return getNode(screenKey)?.registered ? screenKey : null;
+		},
 		subscribe: (screenKey, listener) => {
 			const listeners =
 				listenersByScreenKey.get(screenKey) ?? new Set<() => void>();
 			listeners.add(listener);
 			listenersByScreenKey.set(screenKey, listeners);
-
 			return () => {
 				listeners.delete(listener);
-				if (listeners.size === 0) {
-					listenersByScreenKey.delete(screenKey);
-					if (!getNode(screenKey)) {
-						relationshipCache.delete(screenKey);
-					}
-				}
+				if (listeners.size === 0) listenersByScreenKey.delete(screenKey);
 			};
 		},
+		subscribeResolution: (listener) => {
+			resolutionListeners.add(listener);
+			return () => resolutionListeners.delete(listener);
+		},
 	};
 };
 

package/src/providers/screen/topology/hooks/use-resolved-transition-key.ts

@@ -0,0 +1,29 @@
+import { useCallback, useSyncExternalStore } from "react";
+import type { ScreenTransitionTarget } from "../../../../types/animation.types";
+import { screenTopology } from "../helpers/create-screen-topology";
+
+export const useResolvedTransitionKey = (
+	screenKey: string | null,
+	target?: ScreenTransitionTarget,
+) => {
+	const depth = typeof target === "string" ? null : (target?.depth ?? 0);
+	const requiresResolution = typeof target === "string" || depth !== 0;
+	const subscribe = useCallback(
+		(listener: () => void) =>
+			requiresResolution
+				? screenTopology.subscribeResolution(listener)
+				: () => {},
+		[requiresResolution],
+	);
+	const getSnapshot = useCallback(
+		() =>
+			typeof target === "string"
+				? screenTopology.resolveTransitionKey(target)
+				: requiresResolution && screenKey
+					? screenTopology.resolve(screenKey, depth ?? 0)
+					: screenKey,
+		[depth, requiresResolution, screenKey, target],
+	);
+
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+};

package/src/{factories/screen-topology → providers/screen/topology/hooks}/use-screen-relationships.ts

@@ -1,5 +1,5 @@
 import { useCallback, useSyncExternalStore } from "react";
-import { screenTopology } from "./create-screen-topology";
+import { screenTopology } from "../helpers/create-screen-topology";
 
 export const useScreenRelationships = (screenKey: string) => {
 	const subscribe = useCallback(

package/src/providers/screen/topology/index.ts

@@ -0,0 +1,16 @@
+export {
+	createScreenTopology,
+	screenTopology,
+} from "./helpers/create-screen-topology";
+export { useResolvedTransitionKey } from "./hooks/use-resolved-transition-key";
+export { useScreenRelationships } from "./hooks/use-screen-relationships";
+export {
+	ScreenTopologyProvider,
+	useScreenTopologyStore,
+} from "./topology.provider";
+export type {
+	ActiveScreenRegistration,
+	ScreenRelationships,
+	ScreenTopology,
+	ScreenTopologyRegistration,
+} from "./types";

package/src/providers/screen/topology/topology.provider.tsx

@@ -0,0 +1,72 @@
+import { type ReactNode, useLayoutEffect, useMemo } from "react";
+import createProvider from "../../../utils/create-provider";
+import { useBlankStackStore } from "../../stack/blank-stack.provider";
+import { useDescriptorsStore } from "../descriptors";
+import { screenTopology } from "./helpers/create-screen-topology";
+
+type Props = {
+	children: ReactNode;
+};
+
+type ScreenTopologyContextValue = {
+	screenKey: string;
+};
+
+const {
+	ScreenTopologyProvider,
+	useOptionalScreenTopologyStore,
+	useScreenTopologyStore,
+} = createProvider("ScreenTopology")<Props, ScreenTopologyContextValue>(
+	({ children }) => {
+		const screenKey = useDescriptorsStore(
+			(store) => store.derivations.currentScreenKey,
+		);
+		const transitionKey = useDescriptorsStore(
+			(store) => store.options.transitionKey,
+		);
+		const parentScreenKey = useOptionalScreenTopologyStore(
+			(store) => store?.screenKey,
+		);
+		const navigatorKey = useBlankStackStore((store) => store.navigatorKey);
+		const isActiveScreen = useBlankStackStore((store) => {
+			const focusedScene = store.scenes[store.focusedIndex];
+			return (
+				focusedScene?.route.key === screenKey &&
+				focusedScene.activity === "active"
+			);
+		});
+		useLayoutEffect(() => {
+			screenTopology.register({
+				screenKey,
+				navigatorKey,
+				parentScreenKey,
+				transitionKey,
+			});
+		}, [screenKey, navigatorKey, parentScreenKey, transitionKey]);
+
+		useLayoutEffect(() => {
+			if (!isActiveScreen || !parentScreenKey) return;
+
+			screenTopology.activate({
+				screenKey,
+				parentScreenKey,
+			});
+		}, [isActiveScreen, parentScreenKey, screenKey]);
+
+		useLayoutEffect(
+			() => () => {
+				screenTopology.unregister(screenKey);
+			},
+			[screenKey],
+		);
+
+		const value = useMemo(() => ({ screenKey }), [screenKey]);
+
+		return {
+			value,
+			children,
+		};
+	},
+);
+
+export { ScreenTopologyProvider, useScreenTopologyStore };

package/src/{factories/screen-topology → providers/screen/topology}/types.ts

@@ -1,6 +1,8 @@
 export type ScreenTopologyRegistration = {
 	screenKey: string;
+	navigatorKey?: string;
 	parentScreenKey?: string;
+	transitionKey?: string;
 };
 
 export type ActiveScreenRegistration = {
@@ -11,12 +13,16 @@ export type ActiveScreenRegistration = {
 export type ScreenRelationships = Readonly<{
 	parentScreenKey: string | null;
 	activeChildScreenKey: string | null;
+	activeChildNavigatorKey: string | null;
 }>;
 
 export type ScreenTopology = {
 	register(registration: ScreenTopologyRegistration): void;
 	unregister(screenKey: string): void;
-	activate(registration: ActiveScreenRegistration): () => void;
+	activate(registration: ActiveScreenRegistration): void;
 	getRelationships(screenKey: string): ScreenRelationships;
+	resolve(screenKey: string, depth: number): string | null;
+	resolveTransitionKey(key: string): string | null;
 	subscribe(screenKey: string, listener: () => void): () => void;
+	subscribeResolution(listener: () => void): () => void;
 };

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

@@ -1,5 +1,5 @@
-import { useScreenRelationships } from "../../factories/screen-topology";
 import { useDescriptorsStore } from "./descriptors";
+import { useScreenRelationships } from "./topology";
 
 export const useCurrentScreenRelationships = () => {
 	const screenKey = useDescriptorsStore(

package/src/providers/stack/blank-stack-state/helpers/build-blank-stack-state.ts

@@ -1,5 +1,9 @@
 import type { BlankStackDescriptor } from "../../../../types/blank-stack.types";
-import type { BlankStackProviderProps } from "../../../../types/providers/blank-stack-provider.types";
+import type {
+	BlankStackDescriptorSource,
+	BlankStackDescriptorSources,
+	BlankStackProviderProps,
+} from "../../../../types/providers/blank-stack-provider.types";
 import type {
 	BaseStackScene,
 	StackSceneActivity,
@@ -9,6 +13,7 @@ import { resolveSceneNeighbors } from "./navigation/resolve-scene-neighbors";
 import {
 	areDescriptorSourcesEquivalent,
 	areDescriptorsEqual,
+	areRecordsShallowEqual,
 	areRouteChildStateMapsEqual,
 	getRouteChildState,
 	routeKeyListsAreEqual,
@@ -24,7 +29,7 @@ import type {
 type BuildBlankStackStateParams = {
 	props: BlankStackProviderProps;
 	routes: BlankStackRoutes;
-	descriptors: BlankStackDescriptors;
+	descriptors: BlankStackDescriptorSources;
 	closingRouteKeys: ReadonlySet<string>;
 	previousState?: LocalRoutesState;
 };
@@ -35,9 +40,9 @@ const resolveStableDescriptorSource = ({
 	previousState,
 }: {
 	routeKey: string;
-	sourceDescriptor: BlankStackDescriptor;
+	sourceDescriptor: BlankStackDescriptorSource;
 	previousState?: LocalRoutesState;
-}): BlankStackDescriptor => {
+}): BlankStackDescriptorSource => {
 	const previousSourceDescriptor = previousState?.sourceDescriptors[routeKey];
 
 	if (
@@ -125,6 +130,7 @@ const getSceneActivityWindow = ({
 };
 
 const buildBaseScenes = ({
+	props,
 	routes,
 	descriptors,
 	closingRouteKeys,
@@ -136,7 +142,7 @@ const buildBaseScenes = ({
 	const routeKeys: string[] = [];
 	const scenes: BaseStackScene<BlankStackDescriptor>[] = [];
 	const routeChildStates: Record<string, unknown> = {};
-	const sourceDescriptors: BlankStackDescriptors = {};
+	const sourceDescriptors: BlankStackDescriptorSources = {};
 	const blankStackDescriptors: BlankStackDescriptors = {};
 	let shouldShowFloatOverlay = false;
 
@@ -169,14 +175,29 @@ const buildBaseScenes = ({
 		});
 
 		const previousDescriptor = previousState?.descriptors[route.key];
+		const descriptorRoute =
+			previousDescriptor &&
+			childStateUnchanged &&
+			areRecordsShallowEqual(
+				previousDescriptor.route as unknown as Record<string, unknown>,
+				route as unknown as Record<string, unknown>,
+			)
+				? previousDescriptor.route
+				: route;
 		const descriptor =
 			previousDescriptor &&
 			childStateUnchanged &&
-			previousDescriptor.route === sourceDescriptor.route &&
-			previousDescriptor.navigation === sourceDescriptor.navigation &&
+			previousDescriptor.route === descriptorRoute &&
+			previousDescriptor.navigation === props.navigation &&
+			previousDescriptor.render === sourceDescriptor.render &&
 			previousDescriptor.options === sourceDescriptor.options
 				? previousDescriptor
-				: sourceDescriptor;
+				: ({
+						route: descriptorRoute,
+						navigation: props.navigation,
+						options: sourceDescriptor.options,
+						render: sourceDescriptor.render,
+					} as BlankStackDescriptor);
 
 		routeKeys.push(route.key);
 		routeChildStates[route.key] = routeChildState;
@@ -206,12 +227,10 @@ const buildBaseScenes = ({
 
 const withSceneRelationships = ({
 	scenes,
-	sourceDescriptors,
 	closingRouteKeys,
 	previousState,
 }: {
 	scenes: BaseStackScene<BlankStackDescriptor>[];
-	sourceDescriptors: BlankStackDescriptors;
 	closingRouteKeys: ReadonlySet<string>;
 	previousState?: LocalRoutesState;
 }): BaseStackScene<BlankStackDescriptor>[] => {
@@ -231,7 +250,7 @@ const withSceneRelationships = ({
 
 	const relationshipScenes = scenes.map((scene) => ({
 		route: scene.route,
-		descriptor: sourceDescriptors[scene.route.key] ?? scene.descriptor,
+		descriptor: scene.descriptor,
 	}));
 
 	const nextScenes = scenes.map((scene, sceneIndex) => {
@@ -296,7 +315,6 @@ export const buildBlankStackState = (
 
 	const scenes = withSceneRelationships({
 		scenes: baseScenes,
-		sourceDescriptors,
 		closingRouteKeys: params.closingRouteKeys,
 		previousState: params.previousState,
 	});
@@ -305,6 +323,7 @@ export const buildBlankStackState = (
 
 	return {
 		routes: params.routes,
+		navigation: params.props.navigation,
 		descriptors:
 			params.previousState &&
 			areDescriptorsEqual(

package/src/providers/stack/blank-stack-state/helpers/derive-blank-stack-state.ts

@@ -7,7 +7,7 @@ import {
 	areDescriptorsEqual,
 	areRouteChildStateMapsEqual,
 	getRouteChildStateMap,
-	routesHaveSameKeys,
+	routesAreShallowlyEqual,
 	setsAreEqual,
 } from "./state-equality";
 import type { BlankStackRoutes, LocalRoutesState } from "./types";
@@ -39,6 +39,7 @@ export const deriveBlankStackState = ({
 	const nextDescriptors = props.descriptors;
 	const nextRouteChildStates = getRouteChildStateMap(nextRoutesSnapshot);
 	const nextFocusedRouteKey = nextRoutesSnapshot[props.state.index]?.key;
+	const navigationUnchanged = current.navigation === props.navigation;
 	const focusedRouteUnchanged = current.focusedRouteKey === nextFocusedRouteKey;
 	const closingRouteKeysUnchanged = setsAreEqual(
 		current.closingRouteKeys,
@@ -50,6 +51,7 @@ export const deriveBlankStackState = ({
 	);
 
 	const alreadyAligned =
+		navigationUnchanged &&
 		focusedRouteUnchanged &&
 		closingRouteKeysUnchanged &&
 		routeChildStatesUnchanged &&
@@ -61,10 +63,11 @@ export const deriveBlankStackState = ({
 	}
 
 	const logicallyAligned =
+		navigationUnchanged &&
 		focusedRouteUnchanged &&
 		closingRouteKeysUnchanged &&
 		routeChildStatesUnchanged &&
-		routesHaveSameKeys(current.routes, nextRoutesSnapshot) &&
+		routesAreShallowlyEqual(current.routes, nextRoutesSnapshot) &&
 		areDescriptorSourceMapsEquivalent(
 			current.sourceDescriptors,
 			nextDescriptors,
@@ -92,7 +95,12 @@ export const deriveBlankStackState = ({
 		closingRouteKeys,
 	);
 
-	if (!routesChanged && !descriptorsChanged && !closingRouteKeysChanged) {
+	if (
+		navigationUnchanged &&
+		!routesChanged &&
+		!descriptorsChanged &&
+		!closingRouteKeysChanged
+	) {
 		return current;
 	}
 

package/src/providers/stack/blank-stack-state/helpers/reconcile-blank-stack-routes.ts

@@ -1,9 +1,9 @@
+import type { BlankStackDescriptorSources } from "../../../../types/providers/blank-stack-provider.types";
 import type { RouteWithKey } from "../../../../types/stack.types";
 import { composeDescriptors } from "./navigation/compose-descriptors";
 import { syncRoutesWithRemoved } from "./navigation/sync-routes-with-removed";
 import { routesHaveSameKeys } from "./state-equality";
 import type {
-	BlankStackDescriptors,
 	BlankStackRoutes,
 	LocalRoutesState,
 	ReconciledRoutes,
@@ -13,7 +13,7 @@ type ReconcileBlankStackRoutesParams = {
 	current: LocalRoutesState;
 	previousRoutesSnapshot: BlankStackRoutes;
 	nextRoutesSnapshot: BlankStackRoutes;
-	nextDescriptors: BlankStackDescriptors;
+	nextDescriptors: BlankStackDescriptorSources;
 	closingRouteKeys: Set<string>;
 };