@momo-kits/native-kits 0.167.1-duo.8-debug → 0.167.1-duo.9

package/ios/{Application/Navigation/component → Navigation/Component}/SideBar.swift

@@ -2,22 +2,15 @@
 //  SideBar.swift
 //  MoMoUIKits
 //
-//  iPhone Duo: back and toolkit leave the header bar for a column in the side safe area,
-//  as the system bars do. Port of RN `SideBarButton.tsx` + `useSideBarItemStyle`.
+//  SwiftUI mirror of Compose's `navigation/component/SideBar.kt`. iPhone Duo: back and toolkit
+//  leave the header bar for a column in the side safe area, as the system bars do.
+//  Port of RN `SideBarButton.tsx` + `useSideBarItemStyle`.
 //
 
 import SwiftUI
 
 private let sideBarIconSize: CGFloat = 24
 
-/// Toolkit data when `headerRight` renders the kit toolkit; nil for a custom header right.
-func toolkitHeaderRight(_ headerRight: (() -> any View)?) -> (data: HeaderRightData?, tintColor: Color?)? {
-    guard let view = headerRight?() else { return nil }
-    if let toolkit = view as? HeaderRight { return (toolkit.headerRight, toolkit.tintColor) }
-    if let toolkit = view as? NavigationHeaderRight { return (toolkit.headerRight, toolkit.tintColor) }
-    return nil
-}
-
 /// The back button and toolkit column, placed in window coordinates over the side strip.
 struct HeaderSideBar: View {
     let sideBar: SideBarLayout
@@ -28,6 +21,8 @@ struct HeaderSideBar: View {
     let bottomInset: CGFloat
 
     @Environment(\.screenLayout) private var layout
+    @Environment(\.applicationEnvironment) private var environment
+    @Environment(\.duoBarCompression) private var compression
     @State private var columnHeight: CGFloat = 0
 
     private var isRight: Bool { sideBar.edge == .right }
@@ -37,12 +32,20 @@ struct HeaderSideBar: View {
         return max(min(sideBar.top, maxY), 0)
     }
 
+    /// Full height, so the tab bar compression decision follows this screen's toolkit.
+    private var fullHeight: CGFloat {
+        let toolkitHeight = toolkit.map {
+            Spacing.M + toolkitColumnHeight($0.data ?? HeaderRightData(), context: environment.applicationContext)
+        }
+        return DuoMetrics.controlSize + (toolkitHeight ?? 0)
+    }
+
     var body: some View {
         VStack(alignment: isRight ? .leading : .trailing, spacing: Spacing.M) {
             if let goBack {
                 SideBarButton(
                     icon: "arrow-back",
-                    tintColor: headerColor.tintIconColor,
+                    headerColor: headerColor,
                     accessibilityId: "btn_navigation_back",
                     action: goBack
                 )
@@ -51,11 +54,26 @@ struct HeaderSideBar: View {
                 Color.clear.frame(width: DuoMetrics.controlSize, height: DuoMetrics.controlSize)
             }
             if let toolkit {
-                ToolkitNavigationHeaderRight(
-                    headerRight: toolkit.data,
-                    tintColor: toolkit.tintColor ?? headerColor.tintIconColor,
-                    vertical: true
-                )
+                if compression.toolbarHidden {
+                    // an open tab rail takes this slot for a moment
+                    EmptyView()
+                } else if compression.toolbarCompressed {
+                    // HIG "Toolbar compressed": tools fold into one button, distinct from the useMore icon
+                    SideBarButton(
+                        icon: "navigation_menu",
+                        headerColor: headerColor,
+                        showBadge: toolkit.data?.showBadge ?? false,
+                        accessibilityId: "btn_navigation_toolbar",
+                        action: compression.expandToolbar
+                    )
+                } else {
+                    Toolkit(
+                        headerRight: toolkit.data ?? HeaderRightData(),
+                        tintColor: toolkit.tintColor,
+                        vertical: true
+                    )
+                    .environment(\.headerColor, headerColor)
+                }
             }
         }
         .padding(isRight ? .leading : .trailing, Spacing.M)
@@ -70,15 +88,17 @@ struct HeaderSideBar: View {
         .padding(.top, top)
         .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: isRight ? .topTrailing : .topLeading)
         .ignoresSafeArea()
+        .onAppear { compression.setToolbarHeight(fullHeight) }
+        .onChange(of: fullHeight) { compression.setToolbarHeight($0) }
     }
 }
 
 /// Dark glass under light icons (banner headers), light glass otherwise.
 private struct SideBarGlass<S: Shape>: ViewModifier {
-    let tintColor: Color?
+    let headerColor: HeaderColor
     let shape: S
 
-    private var isDark: Bool { tintColor == Colors.black01 || tintColor == .white }
+    private var isDark: Bool { headerColor.tintIconColor == Colors.black01 || headerColor.tintIconColor == .white }
 
     func body(content: Content) -> some View {
         if isDark {
@@ -99,31 +119,32 @@ private struct SideBarGlass<S: Shape>: ViewModifier {
 /// 48pt glass circle for a single side bar control.
 struct SideBarButton: View {
     let icon: String
-    var tintColor: Color?
+    let headerColor: HeaderColor
     var showBadge: Bool = false
     var disabled: Bool = false
     var accessibilityId: String?
     let action: () -> Void
 
     var body: some View {
-        SwiftUI.Button(action: { if !disabled { action() } }) {
-            Icon(source: icon, size: sideBarIconSize, color: tintColor ?? Colors.black17)
+        SwiftUI.Button(action: action) {
+            Icon(source: icon, size: sideBarIconSize, color: headerColor.tintIconColor)
                 .frame(width: DuoMetrics.controlSize, height: DuoMetrics.controlSize)
-                .modifier(SideBarGlass(tintColor: tintColor, shape: Circle()))
+                .modifier(SideBarGlass(headerColor: headerColor, shape: Circle()))
                 .overlay(alignment: .topTrailing) {
                     if showBadge {
                         BadgeDot(size: .small).offset(x: -Spacing.XXS, y: Spacing.XXS)
                     }
                 }
         }
-        .buttonStyle(.plain)
+        .buttonStyle(ActiveOpacityButtonStyle())
+        .disabled(disabled)
         .accessibilityIdentifier(accessibilityId ?? "")
     }
 }
 
 /// 48pt wide glass capsule grouping related controls, one item per 50pt.
 struct SideBarGroup<Content: View>: View {
-    var tintColor: Color?
+    let headerColor: HeaderColor
     let itemCount: Int
     @ViewBuilder let content: () -> Content
 
@@ -133,23 +154,23 @@ struct SideBarGroup<Content: View>: View {
                 width: DuoMetrics.controlSize,
                 height: itemCount > 1 ? DuoMetrics.itemPitch * CGFloat(itemCount) : DuoMetrics.controlSize
             )
-            .modifier(SideBarGlass(tintColor: tintColor, shape: RoundedRectangle(cornerRadius: Radius.XL)))
+            .modifier(SideBarGlass(headerColor: headerColor, shape: RoundedRectangle(cornerRadius: Radius.XL)))
     }
 }
 
 struct SideBarGroupItem: View {
     let icon: String
-    var tintColor: Color?
+    let headerColor: HeaderColor
     let accessibilityId: String
     let action: () -> Void
 
     var body: some View {
         SwiftUI.Button(action: action) {
-            Icon(source: icon, size: sideBarIconSize, color: tintColor ?? Colors.black17)
+            Icon(source: icon, size: sideBarIconSize, color: headerColor.tintIconColor)
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
                 .contentShape(Rectangle())
         }
-        .buttonStyle(.plain)
+        .buttonStyle(ActiveOpacityButtonStyle())
         .accessibilityIdentifier(accessibilityId)
     }
 }

package/ios/{Application/Navigation/Overplay → Navigation/Component}/SnackBar.swift

@@ -2,9 +2,8 @@
 //  SnackBar.swift
 //  MoMoUIKits
 //
-//  SwiftUI mirror of Compose's `SnackBar` (navigation/component/SnackBar.kt).
-//  A snack bar slides up from the bottom (just above the footer / home
-//  indicator), stays for `duration`, then slides back down and is removed.
+//  SwiftUI mirror of Compose's `navigation/component/SnackBar.kt`: slides up above the screen's
+//  footer (or the home indicator), stays for `duration`, then slides back down.
 //  `Navigator.showSnackBar(_:)` drives it through the overplay host.
 //
 
@@ -53,8 +52,8 @@ public struct SnackBar {
 @available(iOS 16.0, *)
 struct SnackBarView: View {
     let snackBar: SnackBar
-    /// Bottom inset so the bar sits above the footer / home indicator
-    /// (mirrors Compose's `footerHeight` offset).
+    /// Distance from the window bottom to the top of the screen's footer, or the navigation bar
+    /// inset without one (Compose's `footerHeight` offset).
     let bottomInset: CGFloat
 
     @EnvironmentObject private var navigator: Navigator
@@ -78,6 +77,7 @@ struct SnackBarView: View {
                 .padding(.bottom, bottomInset)
         }
         .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .ignoresSafeArea()
         .onAppear {
             guard !didAppear else { return }
             didAppear = true

package/ios/Navigation/HostBackGestureBridge.swift

@@ -0,0 +1,57 @@
+//
+//  HostBackGestureBridge.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/HostBackGestureBridge.kt`: the host owns the edge-pan
+//  recogniser and routes a back into the topmost kit stack. NavigationContainer attaches itself.
+//  The kit stack is a NavigationStack, so there is no seekable transition: the host only pops.
+//
+
+import Foundation
+
+@available(iOS 16.0, *)
+public final class HostBackGestureBridge {
+    public static let shared = HostBackGestureBridge()
+    private init() {}
+
+    // Weak: a container torn down while its cover is up never reports its disappearance.
+    private var navigators: [WeakNavigator] = []
+
+    /// Set while a bottom tab other than the first is selected; the host shows its floating arrow.
+    public var shouldUseFloatingArrowBack = false
+
+    public func attach(_ navigator: Navigator) {
+        navigators.removeAll { $0.value == nil }
+        guard !navigators.contains(where: { $0.value === navigator }) else { return }
+        navigators.append(WeakNavigator(value: navigator))
+    }
+
+    public func detach(_ navigator: Navigator) {
+        navigators.removeAll { $0.value == nil || $0.value === navigator }
+    }
+
+    /// Whether a kit stack is on screen at all.
+    public func checkCanPop() -> Bool { top() != nil }
+
+    /// Whether the top stack pops a screen itself; false means a back dismisses the mini app.
+    public func canPopInner() -> Bool { top()?.canPop() == true }
+
+    public func pop() { top()?.onBackSafe() }
+
+    @available(*, deprecated, renamed: "attach")
+    public func push(_ navigator: Navigator) { attach(navigator) }
+
+    @available(*, deprecated, renamed: "detach")
+    public func remove(_ navigator: Navigator) { detach(navigator) }
+
+    private func top() -> Navigator? { navigators.last { $0.value != nil }?.value }
+}
+
+@available(iOS 16.0, *)
+@available(*, deprecated, renamed: "HostBackGestureBridge")
+public typealias NavigatorManager = HostBackGestureBridge
+
+@available(iOS 16.0, *)
+private struct WeakNavigator {
+    weak var value: Navigator?
+}

package/ios/Navigation/Navigation.swift

@@ -0,0 +1,190 @@
+//
+//  Navigation.swift
+//  MoMoUIKits
+//
+//  SwiftUI mirror of Compose's `navigation/Navigation.kt`: a screen's `NavigationOptions` and the
+//  per-screen `Navigation` that updates them at runtime.
+//
+
+import SwiftUI
+
+/// Per-screen handle (Compose `LocalNavigation`). Read it inside a screen with
+/// `@EnvironmentObject var navigation: Navigation` and call `setOptions` to change the header,
+/// footer or back handling after the screen is shown.
+public final class Navigation: ObservableObject {
+    public let id: Int
+    public let bottomTabIndex: Int
+    @Published public private(set) var options: NavigationOptions
+
+    private weak var registry: DynamicScreenRegistry?
+    /// What the footer (or navigation bar) takes from the window bottom; lifts snack bars.
+    var bottomObstruction: CGFloat = 0
+
+    init(
+        id: Int = -1,
+        bottomTabIndex: Int = -1,
+        options: NavigationOptions?,
+        registry: DynamicScreenRegistry? = nil
+    ) {
+        self.id = id
+        self.bottomTabIndex = bottomTabIndex
+        self.options = options ?? NavigationOptions()
+        self.registry = registry
+        if id != -1 { registry?.bind(self) }
+    }
+
+    public func setOptions(_ options: NavigationOptions) {
+        update(options)
+    }
+
+    /// Changes only what the closure touches, like Compose's named-argument `setOptions`.
+    public func setOptions(_ transform: (inout NavigationOptions) -> Void) {
+        var updated = options
+        transform(&updated)
+        update(updated)
+    }
+
+    private func update(_ updated: NavigationOptions) {
+        options = updated
+        // back handling reads the registry copy
+        if id != -1 { registry?.setOptions(id: id, options: updated) }
+    }
+}
+
+public struct NavigationOptions {
+    public var screenName: String?
+    public var title: String
+    /// Rich header title (Compose `headerTitle`); `title` is used when nil.
+    public var headerTitle: HeaderTitle?
+    public var titlePosition: TitlePosition
+    public var headerType: HeaderType
+    /// Compose's `HeaderType.Default/Extended(useAnimated:)`: with `inputSearchProps`, the search
+    /// rises into the header on scroll.
+    public var useAnimated: Bool
+    /// Compose's `HeaderType.Transparent`; with `fullScreenContent` the content starts under it.
+    public var headerTransparent: Bool
+    public var fullScreenContent: Bool
+    public var hiddenBack: Bool
+    public var backgroundColor: Color?
+    public var tintColor: Color?
+    public var scrollable: Bool
+    /// Compose's `ScrollData.scrollToTopCallback`, fired on a status-bar tap.
+    public var scrollToTopCallback: (() -> Void)?
+    public var useAvoidKeyboard: Bool
+    /// Compose's `KeyboardOptions.keyboardShouldPersistTaps`: a tap anywhere hides the keyboard.
+    public var keyboardShouldPersistTaps: Bool
+    public var headerBackProps: HeaderBackProps?
+    /// Toolkit data for the default header right (Compose `HeaderRight.Toolkit`). Use `headerRight`
+    /// for a custom view and nil for none.
+    public var headerRightData: HeaderRightData?
+    public var headerRight: (() -> any View)?
+    public var footer: (() -> AnyView)?
+    public var footerTransparent: Bool
+    public var footerUseMargin: Bool
+    public var animatedHeader: AnimatedHeader?
+    public var layoutOffset: CGFloat
+    public var inputSearchProps: InputSearchProps?
+    public var fabProps: FabProps?
+    public var onBackHandler: (() -> Void)?
+
+    public init(
+        screenName: String? = nil,
+        title: String = "Stack",
+        headerTitle: HeaderTitle? = nil,
+        titlePosition: TitlePosition = .left,
+        headerType: HeaderType = .default,
+        useAnimated: Bool = false,
+        headerTransparent: Bool = false,
+        fullScreenContent: Bool = false,
+        hiddenBack: Bool = false,
+        backgroundColor: Color? = nil,
+        tintColor: Color? = Colors.black17,
+        scrollable: Bool = true,
+        scrollToTopCallback: (() -> Void)? = nil,
+        useAvoidKeyboard: Bool = true,
+        keyboardShouldPersistTaps: Bool = false,
+        headerBackProps: HeaderBackProps? = nil,
+        headerRightData: HeaderRightData? = nil,
+        headerRight: (() -> any View)? = { HeaderRight() },
+        footer: (() -> AnyView)? = nil,
+        footerTransparent: Bool = false,
+        footerUseMargin: Bool = true,
+        animatedHeader: AnimatedHeader? = nil,
+        layoutOffset: CGFloat = 56,
+        inputSearchProps: InputSearchProps? = nil,
+        fabProps: FabProps? = nil,
+        onBackHandler: (() -> Void)? = nil
+    ) {
+        self.screenName = screenName
+        self.title = title
+        self.headerTitle = headerTitle
+        self.titlePosition = titlePosition
+        self.headerType = headerType
+        self.useAnimated = useAnimated
+        self.headerTransparent = headerTransparent
+        self.fullScreenContent = fullScreenContent
+        self.hiddenBack = hiddenBack
+        self.backgroundColor = backgroundColor
+        self.tintColor = tintColor
+        self.scrollable = scrollable
+        self.scrollToTopCallback = scrollToTopCallback
+        self.useAvoidKeyboard = useAvoidKeyboard
+        self.keyboardShouldPersistTaps = keyboardShouldPersistTaps
+        self.headerBackProps = headerBackProps
+        self.headerRightData = headerRightData
+        self.headerRight = headerRight
+        self.footer = footer
+        self.footerTransparent = footerTransparent
+        self.footerUseMargin = footerUseMargin
+        self.animatedHeader = animatedHeader
+        self.layoutOffset = layoutOffset
+        self.inputSearchProps = inputSearchProps
+        self.fabProps = fabProps
+        self.onBackHandler = onBackHandler
+    }
+}
+
+extension NavigationOptions {
+    var resolvedHeaderRight: (() -> any View)? {
+        guard let headerRightData else { return headerRight }
+        return { HeaderRight(headerRight: headerRightData, tintColor: tintColor) }
+    }
+}
+
+/// `StackScreen` built from options, shared by stack screens and bottom-tab screens.
+struct OptionsStackScreen: View {
+    let options: NavigationOptions
+    let screenName: String
+    let goBack: (() -> Void)?
+    let content: () -> AnyView
+
+    var body: some View {
+        StackScreen(
+            backgroundColor: options.backgroundColor,
+            headerTransparent: options.headerTransparent,
+            fullScreenContent: options.fullScreenContent,
+            tintColor: options.tintColor ?? Colors.black17,
+            isBack: !options.hiddenBack,
+            headerType: options.headerType,
+            useAnimated: options.useAnimated,
+            title: options.title,
+            headerTitle: options.headerTitle,
+            titlePosition: options.titlePosition,
+            goBack: options.hiddenBack ? nil : goBack,
+            scrollable: options.scrollable,
+            scrollToTopCallback: options.scrollToTopCallback,
+            useAvoidKeyboard: options.useAvoidKeyboard,
+            keyboardShouldPersistTaps: options.keyboardShouldPersistTaps,
+            footer: options.footer,
+            footerTransparent: options.footerTransparent,
+            footerUseMargin: options.footerUseMargin,
+            headerRight: options.resolvedHeaderRight,
+            animatedHeader: options.animatedHeader,
+            layoutOffset: options.layoutOffset,
+            inputSearchProps: options.inputSearchProps,
+            fabProps: options.fabProps,
+            screenName: screenName,
+            content: content
+        )
+    }
+}

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

@@ -2,9 +2,9 @@
 //  NavigationContainer.swift
 //  MoMoUIKits
 //
-//  SwiftUI mirror of Compose's NavigationContainer.
-//  Wraps NavigationStack (iOS 16+), injects Navigator into the environment, and renders
-//  every registered screen inside `StackScreen` chrome built from its options.
+//  SwiftUI mirror of Compose's `navigation/NavigationContainer.kt`: wraps NavigationStack
+//  (iOS 16+), injects Navigator, theme, localize and font scale, and renders every registered
+//  screen inside `StackScreen` chrome built from its options.
 //
 
 import SwiftUI
@@ -15,14 +15,19 @@ public struct NavigationContainer<Initial: View>: View {
     @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,
@@ -36,6 +41,7 @@ public struct NavigationContainer<Initial: View>: View {
             options: options,
             composeApi: composeApi
         )
+        nav.maxApi = maxApi
         _navigator = StateObject(wrappedValue: nav)
         _applicationEnvironment = StateObject(
             wrappedValue: ApplicationEnvironment(
@@ -50,9 +56,20 @@ public struct NavigationContainer<Initial: View>: View {
         // 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 {
         withKitEnvironment(
             stack(path: $navigator.path, root: navigator.rootRoute)
@@ -76,10 +93,12 @@ public struct NavigationContainer<Initial: View>: View {
             if navigator.composeApi == nil {
                 navigator.composeApi = composeApi
             }
+            if navigator.maxApi == nil {
+                navigator.maxApi = maxApi
+            }
             setNavigator?(navigator)
-            // Register with the host swipe-back bridge (mirrors ComposeAppContainer's
-            // ComposeNavigatorManager.push). Idempotent, so a re-appear won't double-count.
-            NavigatorManager.shared.push(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
@@ -93,7 +112,7 @@ public struct NavigationContainer<Initial: View>: View {
         .onDisappear {
             // Our own cover hides the stack without leaving it; host back must still reach it.
             guard navigator.presented == nil else { return }
-            NavigatorManager.shared.remove(navigator)
+            HostBackGestureBridge.shared.detach(navigator)
         }
     }
 
@@ -132,6 +151,7 @@ public struct NavigationContainer<Initial: View>: View {
             .environmentObject(navigator)
             .environmentObject(applicationEnvironment)
             .environment(\.applicationEnvironment, applicationEnvironment)
+            .environment(\.appTheme, resolvedTheme)
             .momoLocalize(localize)
             .momoFontScale(context: applicationEnvironment.applicationContext)
     }
@@ -143,34 +163,24 @@ public struct NavigationContainer<Initial: View>: View {
 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 {
-        let options = screen.options ?? NavigationOptions()
-        StackScreen(
-            backgroundColor: options.backgroundColor,
-            headerTransparent: options.headerTransparent,
-            fullScreenContent: options.fullScreenContent,
-            tintColor: options.tintColor ?? Colors.black17,
-            isBack: !options.hiddenBack,
-            headerType: options.headerType,
-            useAnimated: options.useAnimated,
-            title: options.title,
-            headerTitle: options.headerTitle,
-            titlePosition: options.titlePosition,
-            goBack: options.hiddenBack ? nil : { navigator.onBackSafe() },
-            scrollable: options.scrollable,
-            scrollToTopCallback: options.scrollToTopCallback,
-            useAvoidKeyboard: options.useAvoidKeyboard,
-            keyboardShouldPersistTaps: options.keyboardShouldPersistTaps,
-            footer: options.footer,
-            headerRight: options.resolvedHeaderRight,
-            animatedHeader: options.animatedHeader,
-            layoutOffset: options.layoutOffset,
-            inputSearchProps: options.inputSearchProps,
-            fabProps: options.fabProps,
+        OptionsStackScreen(
+            options: navigation.options,
             screenName: screen.name,
-            content: { screen.content() }
+            goBack: { navigator.onBackSafe() },
+            content: screen.content
         )
+        .environmentObject(navigation)
         // Per screen, not around the NavigationStack: a state-driven reader there stops path pushes rendering.
         .momoScreenLayout()
     }
@@ -196,24 +206,19 @@ private struct OverplayHost: View {
             BottomSheetView(
                 header: item.header ?? .title(),
                 isSurface: item.isSurface,
-                barrierDismissible: item.barrierDismissible
+                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: safeAreaBottomInset() + Spacing.S)
+                SnackBarView(snackBar: snackBar, bottomInset: navigator.snackBarBottomInset())
                     .id(item.id)
             }
         }
     }
 }
-
-/// Bottom safe-area inset (home indicator), used to lift the snack bar.
-@available(iOS 16.0, *)
-private func safeAreaBottomInset() -> CGFloat {
-    UIApplication.shared.connectedScenes
-        .compactMap { ($0 as? UIWindowScene)?.keyWindow?.safeAreaInsets.bottom }
-        .first ?? 0
-}