@momo-kits/native-kits 0.167.1-duo.3 → 0.167.1-duo.4-debug

package/ios/Application/Navigation/HeaderUser.swift

@@ -10,7 +10,6 @@
 
 import SwiftUI
 
-@available(iOS 16.0, *)
 public struct HeaderUserView: View {
     private let data: HeaderUserData
 
@@ -20,11 +19,8 @@ public struct HeaderUserView: View {
 
     private let avatarSize: CGFloat = Spacing.XXL // 32
 
-    @Environment(\.screenLayout) private var layout
-
-    // back button and toolkit share the bar unless the iPhone Duo side bar holds them
     private var maxWidth: CGFloat {
-        layout.sideBar != nil ? layout.contentWidth - Spacing.M * 2 : layout.width - 172
+        UIScreen.main.bounds.width - 172
     }
 
     public var body: some View {
@@ -108,7 +104,6 @@ public struct HeaderUserView: View {
 
 /// Mirrors Compose's `AvatarGroup`: lays out 1..4 avatars in a fixed collage,
 /// falls back to initials when empty, and shows a "+n" overflow tile beyond 4.
-@available(iOS 16.0, *)
 private struct AvatarGroup: View {
     let urls: [String]
     let title: String
@@ -190,7 +185,6 @@ private struct AvatarGroup: View {
     }
 }
 
-@available(iOS 16.0, *)
 private struct InitialsAvatar: View {
     let name: String
     let size: CGFloat

package/ios/Application/Navigation/NavigationContainer.swift

@@ -3,9 +3,8 @@
 //  MoMoUIKits
 //
 //  SwiftUI mirror of Compose's NavigationContainer.
-//  Wraps NavigationStack, injects Navigator into the environment, and renders
-//  every registered screen inside `Screen(options)` chrome — same auto-wrap
-//  behavior as Compose's StackScreen.
+//  Wraps NavigationStack (iOS 16+), injects Navigator into the environment, and renders
+//  every registered screen inside `StackScreen` chrome built from its options.
 //
 
 import SwiftUI
@@ -55,41 +54,23 @@ public struct NavigationContainer<Initial: View>: View {
     }
 
     public var body: some View {
-        NavigationStack(path: $navigator.path) {
-            screenView(for: navigator.rootRoute)
-                .navigationDestination(for: DynamicScreenRoute.self) { route in
-                    screenView(for: route)
-                }
-        }
-        .environmentObject(navigator)
-        .environmentObject(applicationEnvironment)
-        .environment(\.applicationEnvironment, applicationEnvironment)
-        // AI-GENERATED START: route Localize + font-scale injection through the observing modifiers
-        .momoLocalize(localize)
-        .momoFontScale(context: applicationEnvironment.applicationContext)
-        // AI-GENERATED END: route Localize + font-scale injection through the observing modifiers
-        .fullScreenCover(item: $navigator.presented) { route in
-            screenView(forDialog: route)
-                .environmentObject(navigator)
-                .environmentObject(applicationEnvironment)
-                .environment(\.applicationEnvironment, applicationEnvironment)
-                // AI-GENERATED START: route Localize + font-scale injection through the observing modifiers
-                .momoLocalize(localize)
-                .momoFontScale(context: applicationEnvironment.applicationContext)
-                // AI-GENERATED END: route Localize + font-scale injection through the observing modifiers
-        }
-        .overlay {
-            if let item = navigator.overplay {
-                OverplayHost(item: item)
-                    .environmentObject(navigator)
-                    .environmentObject(applicationEnvironment)
-                    .environment(\.applicationEnvironment, applicationEnvironment)
-                    // AI-GENERATED START: route Localize + font-scale injection through the observing modifiers
-                    .momoLocalize(localize)
-                    .momoFontScale(context: applicationEnvironment.applicationContext)
-                    // AI-GENERATED END: route Localize + font-scale injection through the observing modifiers
-                    .momoScreenLayout()
-            }
+        withKitEnvironment(
+            stack(path: $navigator.path, root: navigator.rootRoute)
+                .overlay { overplayLayer(presentedId: nil) }
+        )
+        .fullScreenCover(item: Binding(
+            get: { navigator.coverRoute },
+            // A close that bypasses the navigator (e.g. `dismiss()`) still tears the flow down.
+            // SwiftUI also writes nil after a navigator-driven close; by then a new screen may
+            // already be queued, so only a cover that is still showing counts.
+            set: { if $0 == nil, navigator.coverRoute != nil { navigator.dismiss() } }
+        )) { route in
+            withKitEnvironment(
+                stack(path: $navigator.presentedPath, root: DynamicScreenRoute(id: route.id))
+                    .overlay { overplayLayer(presentedId: route.id) }
+            )
+            .onAppear { navigator.coverDidAppear() }
+            .onDisappear { navigator.coverDidDisappear() }
         }
         .onAppear {
             if navigator.composeApi == nil {
@@ -110,10 +91,23 @@ public struct NavigationContainer<Initial: View>: View {
             // AI-GENERATED END: demote the MaxApi language pull to a seed of last resort
         }
         .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)
         }
     }
 
+    private func stack(path: Binding<[DynamicScreenRoute]>, root: DynamicScreenRoute) -> some View {
+        NavigationStack(path: path) {
+            screenView(for: root)
+                // A reset swaps the root in place; without the id it would inherit the old root's state.
+                .id(root.id)
+                .navigationDestination(for: DynamicScreenRoute.self) { route in
+                    screenView(for: route)
+                }
+        }
+    }
+
     @ViewBuilder
     private func screenView(for route: DynamicScreenRoute) -> some View {
         if let screen = navigator.registry.getScreen(id: route.id) {
@@ -124,14 +118,22 @@ public struct NavigationContainer<Initial: View>: View {
         }
     }
 
+    /// Each context draws only the overplays shown over it, so one never re-mounts elsewhere.
     @ViewBuilder
-    private func screenView(forDialog route: DynamicDialogRoute) -> some View {
-        if let screen = navigator.registry.getScreen(id: route.id) {
-            ScreenHost(screen: screen, navigator: navigator)
-        } else {
-            EmptyView()
+    private func overplayLayer(presentedId: Int?) -> some View {
+        if let item = navigator.overplay, item.presentedId == presentedId {
+            OverplayHost(item: item)
         }
     }
+
+    private func withKitEnvironment<Content: View>(_ content: Content) -> some View {
+        content
+            .environmentObject(navigator)
+            .environmentObject(applicationEnvironment)
+            .environment(\.applicationEnvironment, applicationEnvironment)
+            .momoLocalize(localize)
+            .momoFontScale(context: applicationEnvironment.applicationContext)
+    }
 }
 
 // MARK: - ScreenHost
@@ -168,8 +170,6 @@ private struct ScreenHost: View {
             screenName: screen.name,
             content: { screen.content() }
         )
-        // Per screen, not around the NavigationStack: a state-driven reader there stops path pushes rendering.
-        .momoScreenLayout()
     }
 }
 

package/ios/Application/Navigation/Navigator.swift

@@ -3,8 +3,8 @@
 //  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.
+//  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
@@ -83,6 +83,9 @@ public struct OverplayItem: Identifiable {
     public var header: BottomSheetHeader? = nil
     // Snack-bar payload (mirrors Compose's SnackBar value).
     public var snackBar: SnackBar? = nil
+    /// The presented screen it was shown over, nil for the main stack. Like Compose's overplay
+    /// root id, it pins the item to that context instead of following later presents/dismisses.
+    public internal(set) var presentedId: Int? = nil
 }
 
 // MARK: - Navigator
@@ -92,11 +95,24 @@ 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) }
+        didSet { disposeScreens(droppedFrom: oldValue, keeping: path) }
+    }
+    @Published public var presented: DynamicDialogRoute? {
+        didSet { syncCover() }
+    }
+    /// Screens pushed while a screen is presented. Compose's dialog route is a plain back-stack
+    /// entry, so later pushes stack on top of it; the cover hosts its own stack for the same result.
+    @Published public var presentedPath: [DynamicScreenRoute] = [] {
+        didSet { disposeScreens(droppedFrom: oldValue, keeping: presentedPath) }
     }
-    @Published public var presented: DynamicDialogRoute?
     @Published public var overplay: OverplayItem?
 
+    /// What the cover shows. It trails `presented` while the previous cover is still sliding out:
+    /// SwiftUI can drop a presentation issued during another one's dismissal.
+    @Published private(set) var coverRoute: DynamicDialogRoute?
+    private var coverOnScreen = false
+    private var presentationGeneration = 0
+
     /// Owned per-Navigator (mirrors Compose's `remember { DynamicScreenRegistry() }` +
     /// disposal): screens registered by this navigator are released via ARC when the
     /// navigator itself deallocates, instead of accumulating in a process-wide singleton.
@@ -108,7 +124,7 @@ public final class Navigator: ObservableObject {
     /// actually removed via `finishOverplayDismiss`.
     private var overplayDismissHandler: (() -> Void)?
 
-    public private(set) var rootRoute: DynamicScreenRoute
+    @Published public private(set) var rootRoute: DynamicScreenRoute
     public var composeApi: KitComposeApi?
 
     public init(
@@ -133,7 +149,7 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        path.append(route)
+        appendToActiveStack(route)
     }
 
     public func push<V: View>(
@@ -146,12 +162,11 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        path.append(route)
+        appendToActiveStack(route)
     }
 
     public func replace<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
-        guard !path.isEmpty else { return }
-        path.removeLast()
+        guard removeLastFromActiveStack() else { return }
         push(content, options: options)
     }
 
@@ -160,13 +175,37 @@ public final class Navigator: ObservableObject {
         @ViewBuilder _ content: @escaping () -> V,
         options: NavigationOptions? = nil
     ) {
-        guard !path.isEmpty else { return }
-        path.removeLast()
+        guard removeLastFromActiveStack() else { return }
         push(screenName: screenName, content, options: options)
     }
 
+    /// The presented flow while one is up, the main stack otherwise.
+    private func appendToActiveStack(_ route: DynamicScreenRoute) {
+        if presented != nil {
+            presentedPath.append(route)
+        } else {
+            path.append(route)
+        }
+    }
+
+    private func removeLastFromActiveStack() -> Bool {
+        if presented != nil {
+            // Compose pops the dialog route itself, so the replacement lands on the main stack.
+            if presentedPath.isEmpty {
+                clearPresented()
+            } else {
+                presentedPath.removeLast()
+            }
+        } else {
+            guard !path.isEmpty else { return false }
+            path.removeLast()
+        }
+        return true
+    }
+
     public func reset<V: View>(@ViewBuilder _ content: @escaping () -> V, options: NavigationOptions? = nil) {
         let previousRoot = rootRoute.id
+        clearPresented()
         path.removeAll()
         let route = registry.register(
             screenName: options?.screenName ?? "",
@@ -183,6 +222,7 @@ public final class Navigator: ObservableObject {
         options: NavigationOptions? = nil
     ) {
         let previousRoot = rootRoute.id
+        clearPresented()
         path.removeAll()
         let route = registry.register(
             screenName: screenName,
@@ -241,9 +281,11 @@ public final class Navigator: ObservableObject {
     @discardableResult
     private func popScreen() -> Bool {
         if presented != nil {
-            let dismissedId = presented?.id
-            presented = nil
-            if let id = dismissedId { disposeScreens([id]) }
+            if presentedPath.isEmpty {
+                clearPresented()
+            } else {
+                presentedPath.removeLast()
+            }
             return true
         } else if !path.isEmpty {
             path.removeLast()
@@ -254,15 +296,20 @@ public final class Navigator: ObservableObject {
         }
     }
 
+    /// Empties both stacks; a presented screen stays up on its own root.
     public func popToRoot() {
+        presentedPath.removeAll()
         path.removeAll()
     }
 
     /// The entry a back action applies to — mirrors Compose's `currentScreen()`
-    /// (`navController.currentBackStackEntry`): a presented screen sits on top of
+    /// (`navController.currentBackStackEntry`): the presented flow sits on top of
     /// the stack, otherwise it is the last pushed screen, otherwise the root.
     private func currentScreen() -> DynamicScreen? {
-        registry.getScreen(id: presented?.id ?? path.last?.id ?? rootRoute.id)
+        if let presented {
+            return registry.getScreen(id: presentedPath.last?.id ?? presented.id)
+        }
+        return registry.getScreen(id: path.last?.id ?? rootRoute.id)
     }
 
     public func onBackSafe(callback: (() -> Void)? = nil) {
@@ -318,7 +365,7 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        presented = DynamicDialogRoute(id: route.id)
+        presentScreen(route)
     }
 
     public func present<V: View>(
@@ -331,14 +378,54 @@ public final class Navigator: ObservableObject {
             content: { AnyView(content()) },
             options: options
         )
-        presented = DynamicDialogRoute(id: route.id)
+        presentScreen(route)
     }
 
     public func dismiss() {
-        if let id = presented?.id {
-            registry.unregister(id: id)
+        clearPresented()
+    }
+
+    /// One cover per container: presenting from a presented flow stacks onto that flow, the way
+    /// Compose stacks a second dialog route.
+    private func presentScreen(_ route: DynamicScreenRoute) {
+        if presented != nil {
+            presentedPath.append(route)
+        } else {
+            presentationGeneration += 1
+            presentedPath = []
+            presented = DynamicDialogRoute(id: route.id)
         }
+    }
+
+    /// The cover keeps rendering its stack while it slides out, so the flow is torn down only
+    /// once the exit animation is over.
+    private func clearPresented() {
+        guard let id = presented?.id else { return }
         presented = nil
+        let generation = presentationGeneration
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.presentedDisposeDelay) { [weak self] in
+            guard let self, self.presentationGeneration == generation else { return }
+            self.presentedPath.removeAll()
+        }
+        disposeScreens([id], after: Self.presentedDisposeDelay)
+    }
+
+    private func syncCover() {
+        if presented == nil {
+            coverRoute = nil
+        } else if !coverOnScreen || coverRoute != nil {
+            coverRoute = presented
+        }
+    }
+
+    /// Reported by the container from the cover's appear / disappear.
+    func coverDidAppear() {
+        coverOnScreen = true
+    }
+
+    func coverDidDisappear() {
+        coverOnScreen = false
+        syncCover()
     }
 
     // MARK: Overplay
@@ -353,7 +440,8 @@ public final class Navigator: ObservableObject {
             type: .modal,
             content: { AnyView(content()) },
             barrierDismissible: barrierDismissible,
-            onDismiss: onDismiss
+            onDismiss: onDismiss,
+            presentedId: presented?.id
         )
     }
 
@@ -371,7 +459,8 @@ public final class Navigator: ObservableObject {
             barrierDismissible: barrierDismissible,
             onDismiss: onDismiss,
             isSurface: isSurface,
-            header: header
+            header: header,
+            presentedId: presented?.id
         )
     }
 
@@ -383,7 +472,8 @@ public final class Navigator: ObservableObject {
             content: { AnyView(EmptyView()) },
             barrierDismissible: false,
             onDismiss: onDismiss,
-            snackBar: snackBar
+            snackBar: snackBar,
+            presentedId: presented?.id
         )
     }
 
@@ -429,20 +519,23 @@ 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) })
+    /// A full-screen cover slides out slower than a stack pop.
+    private static let presentedDisposeDelay: TimeInterval = 0.6
+
+    private func disposeScreens(droppedFrom previous: [DynamicScreenRoute], keeping current: [DynamicScreenRoute]) {
+        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.
-    private func disposeScreens(_ ids: [Int]) {
+    private func disposeScreens(_ ids: [Int], after delay: TimeInterval = Navigator.screenDisposeDelay) {
         guard !ids.isEmpty else { return }
-        DispatchQueue.main.asyncAfter(deadline: .now() + Self.screenDisposeDelay) { [weak self] in
+        DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
             guard let self else { return }
-            var live = Set(self.path.map(\.id))
+            var live = Set(self.path.map(\.id)).union(self.presentedPath.map(\.id))
             live.insert(self.rootRoute.id)
             if let presented = self.presented { live.insert(presented.id) }
             for id in ids where !live.contains(id) {

package/ios/Application/Navigation/NavigatorManager.swift

@@ -5,18 +5,25 @@ public final class NavigatorManager {
     public static let shared = NavigatorManager()
     private init() {}
 
-    private var navigators: [Navigator] = []
+    // Weak: a container torn down while its cover is up never reports its disappearance.
+    private var navigators: [WeakNavigator] = []
 
     public func push(_ navigator: Navigator) {
-        guard !navigators.contains(where: { $0 === navigator }) else { return }
-        navigators.append(navigator)
+        navigators.removeAll { $0.value == nil }
+        guard !navigators.contains(where: { $0.value === navigator }) else { return }
+        navigators.append(WeakNavigator(value: navigator))
     }
 
     public func remove(_ navigator: Navigator) {
-        navigators.removeAll { $0 === navigator }
+        navigators.removeAll { $0.value == nil || $0.value === navigator }
     }
 
-    public func checkCanPop() -> Bool { !navigators.isEmpty }
+    public func checkCanPop() -> Bool { navigators.contains { $0.value != nil } }
 
-    public func pop() { navigators.last?.onBackSafe() }
+    public func pop() { navigators.last { $0.value != nil }?.value?.onBackSafe() }
+}
+
+@available(iOS 16.0, *)
+private struct WeakNavigator {
+    weak var value: Navigator?
 }

package/ios/Application/Navigation/Overplay/BottomSheet.swift

@@ -45,7 +45,6 @@ struct BottomSheetView<Content: View>: View {
     @EnvironmentObject private var navigator: Navigator
     @Environment(\.appTheme) private var theme
     @Environment(\.applicationEnvironment) private var appEnv
-    @Environment(\.screenLayout) private var layout
 
     /// Vertical translation of the sheet; starts off-screen and animates to 0.
     @State private var sheetOffset: CGFloat = UIScreen.main.bounds.height
@@ -67,36 +66,7 @@ struct BottomSheetView<Content: View>: View {
     /// steady-state (fully open) scrim peaks at 0.6, matching ModalScreen's peak.
     private let maxDynamicAlpha: CGFloat = 0.3
 
-    // UIScreen stays on the outer display on iPhone Duo, even when unfolded
-    private var screenHeight: CGFloat { isDuo ? layout.height : UIScreen.main.bounds.height }
-
-    private var isDuo: Bool { layout.isDuoDevice }
-    // iPhone Duo inner display: center the sheet instead of spanning the width
-    private var isDuoCentered: Bool { isDuo && layout.width >= 600 }
-
-    /// Keeps the portrait width in landscape, like system sheets.
-    private var duoCenteredWidth: CGFloat {
-        min(
-            min(layout.width, layout.height) - Spacing.L * 2,
-            layout.width - max(layout.insets.leading, layout.insets.trailing, Spacing.L) * 2
-        )
-    }
-
-    /// Landscape side buttons span the full height, so the content is inset; in portrait the
-    /// side status bar only covers the top corner.
-    private var sideInsetLeading: CGFloat {
-        isDuo && !isDuoCentered && layout.width > layout.height ? layout.insets.leading : 0
-    }
-
-    private var sideInsetTrailing: CGFloat {
-        isDuo && !isDuoCentered && layout.width > layout.height ? layout.insets.trailing : 0
-    }
-
-    /// The keyboard filler is part of the sheet, so capping the sheet shrinks the content by it.
-    private var duoMaxHeight: CGFloat? {
-        guard isDuo else { return nil }
-        return layout.height - max(layout.duoTopInset, Spacing.XL)
-    }
+    private var screenHeight: CGFloat { UIScreen.main.bounds.height }
     private var bottomInset: CGFloat { safeAreaBottomInset() }
     /// While the keyboard is up, it already covers the home-indicator area, so it
     /// replaces (rather than adds to) the usual bottom-inset filler.
@@ -140,7 +110,7 @@ struct BottomSheetView<Content: View>: View {
         .onReceive(NotificationCenter.default.publisher(for: UIResponder.keyboardWillChangeFrameNotification)) { notification in
             guard let endFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect else { return }
             withAnimation(.easeOut(duration: 0.25)) {
-                keyboardHeight = screenHeight - endFrame.origin.y
+                keyboardHeight = UIScreen.main.bounds.height - endFrame.origin.y
             }
         }
         .onAppear {
@@ -168,8 +138,6 @@ struct BottomSheetView<Content: View>: View {
                 headerView
                     .frame(height: 56)
                     .padding(.horizontal, Spacing.M)
-                    .padding(.leading, sideInsetLeading)
-                    .padding(.trailing, sideInsetTrailing)
             }
             .frame(maxWidth: .infinity)
             .frame(height: 72)
@@ -181,17 +149,12 @@ struct BottomSheetView<Content: View>: View {
                 .frame(height: 1)
 
             content()
-                .padding(.leading, sideInsetLeading)
-                .padding(.trailing, sideInsetTrailing)
-                // a tall sheet on iPhone Duo keeps its header and gives the content what is left
-                .layoutPriority(-1)
 
             backgroundColor
                 .frame(height: effectiveBottomInset)
         }
-        .frame(maxWidth: isDuoCentered ? duoCenteredWidth : .infinity)
-        .frame(maxHeight: duoMaxHeight, alignment: .bottom)
-        .clipped()
+        .frame(maxWidth: .infinity)
+        .frame(alignment: .bottom)
         .background(
             GeometryReader { geo in
                 Color.clear.onAppear { sheetHeight = geo.size.height }

package/ios/Application/Navigation/Overplay/ModalScreen.swift

@@ -16,7 +16,6 @@ struct ModalScreen<Content: View>: View {
 
     @EnvironmentObject private var navigator: Navigator
     @Environment(\.applicationEnvironment) private var appEnv
-    @Environment(\.screenLayout) private var layout
 
     @State private var scrimOpacity: CGFloat = 0
     @State private var contentScale: CGFloat = 0.8
@@ -36,11 +35,8 @@ struct ModalScreen<Content: View>: View {
             content()
                 .scaleEffect(contentScale)
                 .opacity(contentOpacity)
-                // iPhone Duo: center below the side status bar and above the home indicator
-                .padding(.top, layout.isDuoDevice ? layout.duoTopInset : 0)
-                .padding(.bottom, layout.isDuoDevice ? layout.insets.bottom : 0)
         }
-        // Full screen like RN's Modal, so asymmetric landscape insets don't shift the content sideways.
+        // Center on the full screen like Compose; landscape safe areas are asymmetric (camera on one side).
         .frame(maxWidth: .infinity, maxHeight: .infinity)
         .ignoresSafeArea(.container)
         .onAppear {

package/ios/Application/Navigation/component/Header.swift

@@ -60,11 +60,7 @@ public struct NavigationHeader: View {
         self.titleOpacity = titleOpacity
     }
 
-    @Environment(\.screenLayout) private var layout
-
     private var isAnimated: Bool { animatedHeader != nil }
-    /// iPhone Duo side bar holds back and the toolkit; a custom header right stays in the bar.
-    private var useSideBar: Bool { layout.sideBar != nil }
     private var isSurface: Bool { animatedHeader?.isSurface ?? true }
 
     private var headerColor: HeaderColor {
@@ -83,7 +79,7 @@ public struct NavigationHeader: View {
         if headerType != .none {
             ZStack {
                 HStack(spacing: 0) {
-                    if let goBack, !useSideBar {
+                    if let goBack {
                         BackButton(color: headerColor, onBack: goBack)
                         Spacer().frame(width: Spacing.S)
                     }
@@ -95,7 +91,7 @@ public struct NavigationHeader: View {
                             .frame(maxWidth: .infinity, alignment: .leading)
                     }
 
-                    if let headerRight, !(useSideBar && toolkitHeaderRight(headerRight) != nil) {
+                    if let headerRight {
                         AnyView(headerRight())
                             .background(
                                 GeometryReader { geo in
@@ -111,10 +107,8 @@ public struct NavigationHeader: View {
                         .padding(.horizontal, Spacing.M)
                 }
             }
-            .frame(height: layout.headerBarHeight)
+            .frame(height: HEADER_HEIGHT)
             .overlay(alignment: .bottom) { VerticalShadow(opacity: opacity) }
-            // status bar off the top edge: the row spans the whole header from the window top
-            .padding(.top, min(layout.headerStatusBarHeight - layout.insets.top, 0))
         }
     }
 
@@ -125,9 +119,7 @@ public struct NavigationHeader: View {
         if let inputSearchProps {
             InputSearch(props: inputSearchProps)
         } else if case let .user(userData)? = headerTitle {
-            if #available(iOS 16.0, *) {
-                HeaderUserView(userData)
-            }
+            HeaderUserView(userData)
         } else {
             MomoText(
                 headerTitle?.defaultTitle ?? title,

package/ios/Application/Navigation/component/HeaderBackground.swift

@@ -43,11 +43,10 @@ public struct NavigationHeaderBackground: View {
         )
     }
 
-    @Environment(\.screenLayout) private var layout
-
     public var body: some View {
+        let statusBarHeight = safeAreaTopInset()
         let opacity = max(0, 1 - scrollState / CGFloat(HEADER_HEIGHT))
-        let minHeight = fullScreenContent ? 0 : layout.headerHeight
+        let minHeight = fullScreenContent ? 0 : statusBarHeight + HEADER_HEIGHT
         let maxHeight: CGFloat = 154
         let backgroundColor = headerTransparent ? Color.clear : Colors.black01
         let topColor = opacity == 0 ? backgroundColor : Color(hex: 0xFDCADE)

package/ios/Application/Navigation/component/NavigationFooter.swift

@@ -69,7 +69,7 @@ public struct NavigationFooter: View {
             .padding(.bottom, Self.bottomPadding)
             // Compose paints the surface all the way to the bottom of the screen; the
             // footer's own frame stops at the safe area, so only the fill bleeds down.
-            .background(theme.colors.background.surface.ignoresSafeArea(.container, edges: [.bottom, .horizontal]))
+            .background(theme.colors.background.surface.ignoresSafeArea(.container, edges: .bottom))
             .overlay(alignment: .top) { shadow }
             .offset(y: Self.verticalOffset(keyboardSize: keyboardSize))
         }