Struct RouteFocusState 

pub struct RouteFocusState { /* private fields */ }

Remembers which element was focused per route and restores it on return.

Mount autofocus fires once per window, so route activation is what focuses incoming autofocus targets — never a background scan. Restore is otherwise fail-closed, with three record states and three restore behaviors:

• No saved information (never saved, forgotten, or saved with nothing owned): restore leaves focus untouched, except for genuinely orphaned focus (see below).
• Previously saved focus that is no longer eligible: the deterministic fallback clears focus, but only when current focus is itself orphaned — an invalid saved record never steals unrelated focus.
• Focus currently owned by another route: saves reject it (a route records only its own focus) and restores leave it alone while its owner stays mounted.
• No usable record at all: a vacant stage (no focus, or only orphaned focus) takes the route’s own autofocus target when it names one; valid focus is never displaced for a missing record.

Eligibility reuses the tree’s authoritative focus rule instead of a parallel predicate: the target must be live in the arena (detached elements fail here, including reused slots whose generation changed) and a member of [WidgetTree::focusable_elements], which already encodes enabled state, ExcludeFocus, and inactive subtrees (IndexedStack non-indexed children, descendants_are_focusable). Hidden-but-mounted subtrees (Visibility, Offstage) stay eligible by framework design — they retain focus — while ownership comes from the RouteFocusOwner oracle.

Route identity and element identity stay separate throughout: records are keyed by RouteId, targets are [ElementId] values validated against the live tree on every restore, never by index or name.

Dropping the state forgets all records; later restores are impossible, which is the teardown policy.

Implementations

impl RouteFocusState

pub fn new( owner_of: impl Fn(&WidgetTree, ElementId) -> Option<RouteId> + 'static, ) -> Self

Creates focus state attributing elements through owner_of.

pub fn save_focused(&mut self, runtime: &Runtime, route: RouteId)

Records the currently focused element as route’s focus. Call when route deactivates. Only focus owned by route is recorded: focus owned elsewhere (or by nothing) records no information rather than a foreign snapshot, so retained records never lie about ownership. Absent and rejected records restore identically (orphan sweep), so validation is record hygiene, not a second restore predicate.

pub fn restore_saved( &mut self, runtime: &mut Runtime, navigator: &Navigator, route: RouteId, )

Restores route’s saved focus into runtime. Call when route reactivates. A removed route restores nothing even with a leftover record, so cleanup never depends on the host having forgotten first.

pub fn forget(&mut self, route: RouteId)

Drops route’s record on permanent removal. A removed route never restores: without this call a stale record would outlive its route.

pub fn retain_mounted(&mut self, navigator: &Navigator)

Drops records for routes no longer mounted in navigator. Call after declarative reconciliation, which can remove routes without an explicit per-route removal call.