@momo-kits/native-kits 0.167.1-duo.2-debug → 0.167.1-duo.20-debug

package/ios/Navigation/NavigationContainer.swift

@@ -0,0 +1,194 @@
+//
+//  NavigationContainer.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/NavigationContainer.kt`: hosts the kit stack
+//  (`StackHost`, the NavHost counterpart), injects Navigator, theme, localize and font scale, and
+//  renders every registered screen inside `StackScreen` chrome built from its options.
+//
+
+import SwiftUI
+
+public struct NavigationContainer<Initial: View>: View {
+    @StateObject private var navigator: Navigator
+    @StateObject private var applicationEnvironment: ApplicationEnvironment
+    @StateObject private var localize: Localize
+
+    @Environment(\.appTheme) private var parentTheme
+
+    private let setNavigator: ((Navigator) -> Void)?
+    private let composeApi: KitComposeApi?
+    private let maxApi: MaxApi?
+    private let initialTheme: Theme?
+
+    /// `initialTheme` nil keeps the theme the host already put in the environment.
+    public init(
+        initialScreenName: String = "",
+        @ViewBuilder initialScreen: @escaping () -> Initial,
+        options: NavigationOptions? = nil,
+        initialTheme: Theme? = nil,
+        applicationContext: MiniAppContext? = nil,
+        composeApi: KitComposeApi? = nil,
+        config: KitConfig? = nil,
+        maxApi: MaxApi? = nil,
+        localize: Localize? = nil,
+        setNavigator: ((Navigator) -> Void)? = nil
+    ) {
+        let nav = Navigator(
+            initialScreenName: initialScreenName.isEmpty ? (options?.screenName ?? "") : initialScreenName,
+            initialContent: { AnyView(initialScreen()) },
+            options: options,
+            composeApi: composeApi
+        )
+        nav.maxApi = maxApi
+        _navigator = StateObject(wrappedValue: nav)
+        _applicationEnvironment = StateObject(
+            wrappedValue: ApplicationEnvironment(
+                applicationContext: applicationContext,
+                composeApi: composeApi,
+                config: config,
+                maxApi: maxApi
+            )
+        )
+        // AI-GENERATED START: default to the app-language-observing shared Localize
+        _localize = StateObject(wrappedValue: localize ?? Localize.shared)
+        // AI-GENERATED END: default to the app-language-observing shared Localize
+        self.composeApi = composeApi
+        self.maxApi = maxApi
+        self.initialTheme = initialTheme
+        self.setNavigator = setNavigator
+    }
+
+    /// RN parity: the theme's own header image wins; config `headerBar` is only the fallback.
+    private var resolvedTheme: Theme {
+        let theme = initialTheme ?? parentTheme
+        guard !theme.assets.isHeaderImage,
+              let headerBar = applicationEnvironment.config?.headerBar, !headerBar.isEmpty else {
+            return theme
+        }
+        return theme.copy(assets: ThemeAssets(headerBackground: headerBar))
+    }
+
+    public var body: some View {
+        StackHost(
+            navigator: navigator,
+            entries: navigator.entries,
+            screen: { [navigator] entry in
+                guard let screen = navigator.registry.getScreen(id: entry.id) else { return AnyView(EmptyView()) }
+                return AnyView(ScreenHost(screen: screen, navigator: navigator))
+            },
+            decorate: { AnyView(withKitEnvironment($0)) }
+        )
+        // edge to edge: each screen's hosting controller takes the safe area and keyboard itself
+        .ignoresSafeArea()
+        .onAppear {
+            if navigator.composeApi == nil {
+                navigator.composeApi = composeApi
+            }
+            if navigator.maxApi == nil {
+                navigator.maxApi = maxApi
+            }
+            setNavigator?(navigator)
+            // Idempotent, so a re-appear won't double-count.
+            HostBackGestureBridge.shared.attach(navigator)
+            // AI-GENERATED START: demote the MaxApi language pull to a seed of last resort
+            // Only a seed: a Localize with a language source already tracks the host in both
+            // directions, so asking maxApi would just race it. `changeLanguage` normalizes the
+            // raw response and hops to main itself.
+            guard !localize.observesAppLanguage else { return }
+            maxApi?.getLanguage { data in
+                localize.changeLanguage(data?["response"] as? String)
+            }
+            // AI-GENERATED END: demote the MaxApi language pull to a seed of last resort
+        }
+        .onDisappear {
+            HostBackGestureBridge.shared.detach(navigator)
+        }
+    }
+
+    private func withKitEnvironment<Content: View>(_ content: Content) -> some View {
+        content
+            .environmentObject(navigator)
+            .environmentObject(applicationEnvironment)
+            .environment(\.applicationEnvironment, applicationEnvironment)
+            .environment(\.appTheme, resolvedTheme)
+            .momoLocalize(localize)
+            .momoFontScale(context: applicationEnvironment.applicationContext)
+    }
+}
+
+// MARK: - ScreenHost
+
+private struct ScreenHost: View {
+    let screen: DynamicScreen
+    let navigator: Navigator
+    @StateObject private var navigation: Navigation
+
+    init(screen: DynamicScreen, navigator: Navigator) {
+        self.screen = screen
+        self.navigator = navigator
+        _navigation = StateObject(
+            wrappedValue: Navigation(id: screen.id, options: screen.options, registry: navigator.registry)
+        )
+    }
+
+    var body: some View {
+        OptionsStackScreen(
+            options: navigation.options,
+            screenName: screen.name,
+            goBack: { navigator.onBackSafe() },
+            content: screen.content
+        )
+        // Compose draws the overplay inside the screen it was shown over, under its LocalNavigation.
+        .overlay { OverplayLayer(screenId: screen.id) }
+        .environmentObject(navigation)
+        .momoScreenLayout()
+    }
+}
+
+private struct OverplayLayer: View {
+    let screenId: Int
+    @EnvironmentObject private var navigator: Navigator
+
+    var body: some View {
+        if let item = navigator.overplay, item.screenId == screenId {
+            OverplayHost(item: item)
+        }
+    }
+}
+
+// MARK: - Overplay host
+
+private struct OverplayHost: View {
+    let item: OverplayItem
+    @EnvironmentObject var navigator: Navigator
+
+    var body: some View {
+        // Each component self-animates on appear and drives its own exit through
+        // the Navigator before the item is removed (mirrors Compose's overplay).
+        switch item.type {
+        case .modal:
+            ModalScreen(barrierDismissible: item.barrierDismissible) {
+                item.content()
+            }
+            .id(item.id)
+        case .bottomSheet:
+            BottomSheetView(
+                header: item.header ?? .title(),
+                isSurface: item.isSurface,
+                barrierDismissible: item.barrierDismissible,
+                draggable: item.draggable,
+                useBottomInset: item.useBottomInset,
+                footer: item.footer
+            ) {
+                item.content()
+            }
+            .id(item.id)
+        case .snackBar:
+            if let snackBar = item.snackBar {
+                SnackBarView(snackBar: snackBar, bottomInset: navigator.snackBarBottomInset())
+                    .id(item.id)
+            }
+        }
+    }
+}

package/ios/{Application/Navigation → Navigation}/Navigator.swift

@@ -2,9 +2,9 @@
 //  Navigator.swift
 //  MoMoUIKits
 //
-//  SwiftUI mirror of Compose's Navigator + DynamicScreenRegistry.
-//  Screens are registered by Int id; the NavigationStack path stores routes
-//  by id and looks up content from the registry on render.
+//  SwiftUI mirror of Compose's `navigation/Navigator.kt`: Navigator, DynamicScreenRegistry and
+//  the overplay model. Screens are registered by Int id; the stack paths store routes by id and
+//  content is looked up from the registry on render.
 //
 
 import SwiftUI
@@ -31,6 +31,7 @@ public struct DynamicScreen {
 
 public final class DynamicScreenRegistry {
     private var screens: [Int: DynamicScreen] = [:]
+    private var navigations: [Int: WeakNavigation] = [:]
     private var idCounter: Int = 1
 
     public init() {}
@@ -49,12 +50,20 @@ public final class DynamicScreenRegistry {
 
     public func unregister(id: Int) {
         screens.removeValue(forKey: id)
+        navigations.removeValue(forKey: id)
     }
 
     public func unregisterAll() {
         screens.removeAll()
+        navigations.removeAll()
     }
 
+    func bind(_ navigation: Navigation) {
+        navigations[navigation.id] = WeakNavigation(value: navigation)
+    }
+
+    func navigation(id: Int) -> Navigation? { navigations[id]?.value }
+
     public func getScreen(id: Int) -> DynamicScreen? { screens[id] }
 
     public func latest() -> DynamicScreen? {
@@ -66,6 +75,10 @@ public final class DynamicScreenRegistry {
     }
 }
 
+private struct WeakNavigation {
+    weak var value: Navigation?
+}
+
 // MARK: - Overplay
 
 public enum OverplayType {
@@ -81,20 +94,34 @@ public struct OverplayItem: Identifiable {
     // Bottom-sheet params (mirrors Compose's OverplayComponentParams.BottomSheet).
     public var isSurface: Bool = false
     public var header: BottomSheetHeader? = nil
+    public var draggable: Bool = true
+    public var useBottomInset: Bool = true
+    public var footer: (() -> AnyView)? = nil
     // Snack-bar payload (mirrors Compose's SnackBar value).
     public var snackBar: SnackBar? = nil
+    /// The screen it was shown over (Compose's overplay root id): it renders inside that screen,
+    /// so a later push slides over it instead of re-mounting it on the new top.
+    public internal(set) var screenId: Int? = nil
+}
+
+// MARK: - Stack
+
+/// One back-stack entry, root first. A presented screen is an entry like any other (Compose's
+/// `DynamicDialogRoute` in the same NavHost): it rises instead of sliding in, and later pushes
+/// stack on top of it.
+struct StackEntry: Hashable, Identifiable {
+    let id: Int
+    let isDialog: Bool
 }
 
 // MARK: - Navigator
 
-@available(iOS 16.0, *)
 public final class Navigator: ObservableObject {
-    @Published public var path: [DynamicScreenRoute] = [] {
-        // Disposal hangs off the path so every route that leaves the stack — pop,
-        // replace, reset — is released the same way, after its exit transition.
-        didSet { disposeScreens(droppedFrom: oldValue) }
+    @Published private(set) var entries: [StackEntry] = [] {
+        // Disposal hangs off the stack so every entry that leaves it — pop, replace, reset,
+        // dismiss — is released the same way, after its exit transition.
+        didSet { disposeScreens(droppedFrom: oldValue, keeping: entries) }
     }
-    @Published public var presented: DynamicDialogRoute?
     @Published public var overplay: OverplayItem?
 
     /// Owned per-Navigator (mirrors Compose's `remember { DynamicScreenRegistry() }` +
@@ -108,8 +135,20 @@ public final class Navigator: ObservableObject {
     /// actually removed via `finishOverplayDismiss`.
     private var overplayDismissHandler: (() -> Void)?
 
-    public private(set) var rootRoute: DynamicScreenRoute
+    public var rootRoute: DynamicScreenRoute { DynamicScreenRoute(id: entries[0].id) }
     public var composeApi: KitComposeApi?
+    /// Host dismiss fallback when there is no `composeApi` (Compose's `maxApi.dismiss`).
+    public var maxApi: MaxApi?
+
+    /// Set by a bottom tab off its first tab: back on the screen hosting the tabs returns to the
+    /// first tab (Compose `tabBackHandler`). Keyed by that screen, so a screen pushed or presented
+    /// over the tabs still pops normally.
+    var tabBackHandler: (screenId: Int, handler: () -> Void)?
+
+    /// The container's stack view, which plays (and lets the host gesture scrub) the transitions.
+    weak var stackController: StackController?
+    private var isSeekingBack = false
+    private var swipeHaptic = SwipeBackHaptic()
 
     public init(
         initialScreenName: String = "",
@@ -118,22 +157,18 @@ public final class Navigator: ObservableObject {
         composeApi: KitComposeApi? = nil
     ) {
         self.composeApi = composeApi
-        self.rootRoute = registry.register(
+        let root = registry.register(
             screenName: initialScreenName,
             content: initialContent,
             options: options
         )
+        entries = [StackEntry(id: root.id, isDialog: false)]
     }
 
     // MARK: Stack
 
     public func push<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let route = registry.register(
-            screenName: options?.screenName ?? "",
-            content: { AnyView(content()) },
-            options: options
-        )
-        path.append(route)
+        push(screenName: options?.screenName ?? "", content, options: options)
     }
 
     public func push<V: View>(
@@ -141,40 +176,26 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let route = registry.register(
-            screenName: screenName,
-            content: { AnyView(content()) },
-            options: options
-        )
-        path.append(route)
+        entries.append(register(screenName, content, options, isDialog: false))
     }
 
     public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        guard !path.isEmpty else { return }
-        path.removeLast()
-        push(content, options: options)
+        replace(screenName: options?.screenName ?? "", content, options: options)
     }
 
+    /// Compose pops the top entry (a presented one included) and navigates, so the replacement
+    /// always lands as a pushed screen; on the root it becomes the new root.
     public func replace<V: View>(
         screenName: String,
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        guard !path.isEmpty else { return }
-        path.removeLast()
-        push(screenName: screenName, content, options: options)
+        let entry = register(screenName, content, options, isDialog: false)
+        entries = Array(entries.dropLast()) + [entry]
     }
 
     public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let previousRoot = rootRoute.id
-        path.removeAll()
-        let route = registry.register(
-            screenName: options?.screenName ?? "",
-            content: { AnyView(content()) },
-            options: options
-        )
-        rootRoute = route
-        disposeScreens([previousRoot])
+        reset(screenName: options?.screenName ?? "", content, options: options)
     }
 
     public func reset<V: View>(
@@ -182,15 +203,21 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let previousRoot = rootRoute.id
-        path.removeAll()
+        entries = [register(screenName, content, options, isDialog: false)]
+    }
+
+    private func register<V: View>(
+        _ screenName: String,
+        _ content: @escaping () -> V,
+        _ options: NavigationOptions?,
+        isDialog: Bool
+    ) -> StackEntry {
         let route = registry.register(
             screenName: screenName,
             content: { AnyView(content()) },
             options: options
         )
-        rootRoute = route
-        disposeScreens([previousRoot])
+        return StackEntry(id: route.id, isDialog: isDialog)
     }
 
     public func pop(_ count: Int = 1, callback: (() -> Void)? = nil) {
@@ -236,43 +263,57 @@ public final class Navigator: ObservableObject {
         }
     }
 
-    /// Pops the topmost presented screen or stack entry. Returns `false` (and requests
-    /// a host dismiss) when there is nothing left to pop.
+    /// Pops the top entry. Returns `false` (and requests a host dismiss) on the root.
     @discardableResult
     private func popScreen() -> Bool {
-        if presented != nil {
-            let dismissedId = presented?.id
-            presented = nil
-            if let id = dismissedId { disposeScreens([id]) }
-            return true
-        } else if !path.isEmpty {
-            path.removeLast()
-            return true
-        } else {
-            composeApi?.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+        guard canPop() else {
+            requestHostDismiss()
             return false
         }
+        entries.removeLast()
+        return true
+    }
+
+    private func requestHostDismiss() {
+        if let composeApi {
+            composeApi.requestCallback(funcName: "dismiss", params: nil, onResponse: nil)
+        } else {
+            maxApi?.dismiss(completion: nil)
+        }
+    }
+
+    /// Whether there is a screen to go back to (Compose's `canPop`); at the root a back
+    /// dismisses the mini app instead.
+    public func canPop() -> Bool {
+        entries.count > 1
     }
 
+    /// Back to the root of the active flow: the topmost presented screen while one is up,
+    /// the stack root otherwise.
     public func popToRoot() {
-        path.removeAll()
+        let root = entries.lastIndex(where: \.isDialog) ?? 0
+        entries = Array(entries[...root])
     }
 
-    /// The entry a back action applies to — mirrors Compose's `currentScreen()`
-    /// (`navController.currentBackStackEntry`): a presented screen sits on top of
-    /// the stack, otherwise it is the last pushed screen, otherwise the root.
+    /// The entry a back action applies to — Compose's `currentScreen()`
+    /// (`navController.currentBackStackEntry`).
     private func currentScreen() -> DynamicScreen? {
-        registry.getScreen(id: presented?.id ?? path.last?.id ?? rootRoute.id)
+        entries.last.flatMap { registry.getScreen(id: $0.id) }
     }
 
     public func onBackSafe(callback: (() -> Void)? = nil) {
         let latest = currentScreen()
+        if let tabBackHandler, tabBackHandler.screenId == -1 || tabBackHandler.screenId == latest?.id {
+            tabBackHandler.handler()
+            return
+        }
         if let onBack = latest?.options?.onBackHandler {
             onBack()
             return
         }
         if let preventBack = latest?.options?.headerBackProps?.preventBack {
-            showModal {
+            // stored in `overplay`, so a strong self would cycle until the popup closes
+            showModal { [weak self] in
                 PopupNotify(
                     props: PopupNotifyProps(
                         image: preventBack.image,
@@ -281,7 +322,7 @@ public final class Navigator: ObservableObject {
                         error: preventBack.error,
                         primary: PopupAction(
                             title: preventBack.primary?.title ?? "",
-                            onPress: { [weak self] in
+                            onPress: {
                                 preventBack.primary?.onPress?()
                                 // Close the popup, then leave the screen (matches Compose's pop(2)).
                                 self?.pop(2, callback: callback)
@@ -290,14 +331,14 @@ public final class Navigator: ObservableObject {
                         secondary: preventBack.secondary.map { secondary in
                             PopupAction(
                                 title: secondary.title,
-                                onPress: { [weak self] in
+                                onPress: {
                                     secondary.onPress?()
                                     self?.hideOverplay()
                                 }
                             )
                         },
                         buttonDirection: preventBack.buttonDirection,
-                        onIconClose: { [weak self] in
+                        onIconClose: {
                             preventBack.onIconClose?()
                             self?.hideOverplay()
                         },
@@ -313,12 +354,7 @@ public final class Navigator: ObservableObject {
     // MARK: Modal-style screen (vertical slide)
 
     public func present<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        let route = registry.register(
-            screenName: options?.screenName ?? "",
-            content: { AnyView(content()) },
-            options: options
-        )
-        presented = DynamicDialogRoute(id: route.id)
+        present(screenName: options?.screenName ?? "", content, options: options)
     }
 
     public func present<V: View>(
@@ -326,19 +362,55 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        let route = registry.register(
-            screenName: screenName,
-            content: { AnyView(content()) },
-            options: options
-        )
-        presented = DynamicDialogRoute(id: route.id)
+        entries.append(register(screenName, content, options, isDialog: true))
     }
 
+    /// Closes the topmost presented screen together with everything pushed over it.
     public func dismiss() {
-        if let id = presented?.id {
-            registry.unregister(id: id)
+        guard let presented = entries.lastIndex(where: \.isDialog) else { return }
+        entries = Array(entries[..<presented])
+    }
+
+    // MARK: Host back gesture (Compose's HostBackTarget)
+
+    /// Only a plain pop is scrubbed. A back the screen handles itself — tab back, custom
+    /// handler, prevent-back popup, an open overplay — or one closing a presented screen
+    /// waits for the release and goes through `onBackSafe`, as RN turns the gesture off there.
+    private var canSeekBack: Bool {
+        guard canPop(), overplay == nil, let top = entries.last, !top.isDialog else { return false }
+        if let tabBackHandler, tabBackHandler.screenId == -1 || tabBackHandler.screenId == top.id {
+            return false
         }
-        presented = nil
+        let options = registry.getScreen(id: top.id)?.options
+        return options?.onBackHandler == nil && options?.headerBackProps?.preventBack == nil
+    }
+
+    func backStarted() {
+        swipeHaptic.reset()
+        isSeekingBack = canSeekBack && stackController?.beginBackSeek() == true
+    }
+
+    func backProgressed(_ progress: CGFloat) {
+        guard isSeekingBack, let stackController else { return }
+        stackController.seekBack(to: progress)
+        swipeHaptic.update(travelled: progress * stackController.view.bounds.width, maxApi: maxApi)
+    }
+
+    func backCompleted() {
+        let wasSeeking = isSeekingBack
+        isSeekingBack = false
+        // A seek cut short by a programmatic change falls back to a regular back.
+        guard wasSeeking, stackController?.finishBackSeek() == true else {
+            onBackSafe()
+            return
+        }
+        entries.removeLast()
+    }
+
+    func backCancelled() {
+        guard isSeekingBack else { return }
+        isSeekingBack = false
+        stackController?.cancelBackSeek()
     }
 
     // MARK: Overplay
@@ -353,7 +425,8 @@ public final class Navigator: ObservableObject {
             type: .modal,
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
-            onDismiss: onDismiss
+            onDismiss: onDismiss,
+            screenId: entries.last?.id
         )
     }
 
@@ -362,7 +435,10 @@ public final class Navigator: ObservableObject {
         isSurface: Bool = false,
         barrierDismissible: Bool = true,
         header: BottomSheetHeader? = nil,
-        onDismiss: (() -> Void)? = nil
+        onDismiss: (() -> Void)? = nil,
+        draggable: Bool = true,
+        useBottomInset: Bool = true,
+        footer: (() -> AnyView)? = nil
     ) {
         overplayDismissHandler = nil
         overplay = OverplayItem(
@@ -371,7 +447,11 @@ public final class Navigator: ObservableObject {
             barrierDismissible: barrierDismissible,
             onDismiss: onDismiss,
             isSurface: isSurface,
-            header: header
+            header: header,
+            draggable: draggable,
+            useBottomInset: useBottomInset,
+            footer: footer,
+            screenId: entries.last?.id
         )
     }
 
@@ -383,7 +463,8 @@ public final class Navigator: ObservableObject {
             content: { AnyView(EmptyView()) },
             barrierDismissible: false,
             onDismiss: onDismiss,
-            snackBar: snackBar
+            snackBar: snackBar,
+            screenId: entries.last?.id
         )
     }
 
@@ -419,6 +500,14 @@ public final class Navigator: ObservableObject {
         if overplay?.type == .snackBar { hideOverplay() }
     }
 
+    /// Room the current screen's footer (or navigation bar) takes from the window bottom.
+    func snackBarBottomInset() -> CGFloat {
+        guard let id = currentScreen()?.id, let navigation = registry.navigation(id: id) else {
+            return NavigationFooter.navigationBarInset
+        }
+        return navigation.bottomObstruction
+    }
+
     // MARK: Screen disposal
 
     /// Matches the `delay(300)` Compose waits in `dismissScreen` before unregistering,
@@ -429,22 +518,19 @@ public final class Navigator: ObservableObject {
     /// after the component has taken itself down.
     private static let overplayDismissDelay: TimeInterval = 0.3
 
-    private func disposeScreens(droppedFrom previous: [DynamicScreenRoute]) {
-        let live = Set(path.map(\.id))
-        disposeScreens(previous.map(\.id).filter { !live.contains($0) })
+    private func disposeScreens(droppedFrom previous: [StackEntry], keeping current: [StackEntry]) {
+        let kept = Set(current.map(\.id))
+        disposeScreens(previous.map(\.id).filter { !kept.contains($0) })
     }
 
     /// Screens are released only once the pop transition has played out: the outgoing
-    /// view is still on screen while it animates and the registry is what renders it —
-    /// dropping it right away blanks the screen mid-transition. Liveness is re-checked
-    /// when the timer fires, so a route pushed back before then keeps its screen.
+    /// view is still on screen while it animates. Liveness is re-checked when the timer
+    /// fires, so an entry back on the stack by then keeps its screen.
     private func disposeScreens(_ ids: [Int]) {
         guard !ids.isEmpty else { return }
         DispatchQueue.main.asyncAfter(deadline: .now() + Self.screenDisposeDelay) { [weak self] in
             guard let self else { return }
-            var live = Set(self.path.map(\.id))
-            live.insert(self.rootRoute.id)
-            if let presented = self.presented { live.insert(presented.id) }
+            let live = Set(self.entries.map(\.id))
             for id in ids where !live.contains(id) {
                 self.registry.unregister(id: id)
             }