iOS: tighter toolbar title reserve, pinned nav bar on scrollable surfaces, workspace-titled browser pill

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobileLeadingToolbarTitleWidth.swift

@@ -12,7 +12,10 @@ import CoreGraphics
 /// specific items in the bar. The title therefore must never claim space the
 /// trailing items actually render with. Callers report the measured content
 /// widths of the trailing toolbar items; the estimate constants only cover the
-/// frames before the first measurement arrives.
+/// frames before the first measurement arrives. As a backstop, callers also
+/// report when a trailing item's content left the bar (the system folded it
+/// into More); that ratchets `collapseRecoveryReserve` on for the rest of the
+/// view's lifetime so a collapse can never persist.
 struct MobileLeadingToolbarTitleWidth {
     let contentWidth: CGFloat
     let hasBackButton: Bool
@@ -28,15 +31,30 @@ struct MobileLeadingToolbarTitleWidth {
     /// How many trailing toolbar items are structurally visible right now;
     /// each carries its own glass capsule chrome around the measured content.
     let trailingItemCount: Int
+    /// True once a trailing item's content left the bar while structurally
+    /// present (the system collapsed it into the More menu): the reserves
+    /// undershot this device's real chrome, so give the space back.
+    let hadTrailingCollapse: Bool
 
     static let backButtonReserve: CGFloat = 44
     static let trailingReserveBase: CGFloat = 64
-    static let barMarginsAndSpacing: CGFloat = 84
+    /// Dogfood on a 402pt iPhone 17 measured ~22pt of dead gap between the
+    /// title pill and the trailing capsule under the original 84pt margin +
+    /// 24pt/item chrome reserves. Only part of that slack is returned to the
+    /// title (4pt here, 4pt per item below): larger-chrome devices proved
+    /// able to eat the full amount (a 30pt trim collapsed the trailing items
+    /// into More on an iPhone 17 Pro Max), and `collapseRecoveryReserve`
+    /// backstops the remainder.
+    static let barMarginsAndSpacing: CGFloat = 80
     /// Horizontal glass-capsule chrome around one trailing item's content.
-    static let trailingItemChrome: CGFloat = 24
+    static let trailingItemChrome: CGFloat = 20
     /// Safe content-width reserve for a structural item that has not reported
     /// geometry yet.
     static let unmeasuredTrailingItemReserve: CGFloat = 64
+    /// Added once a collapse was observed: more than the 12pt trimmed from
+    /// the estimate reserves, so the recovered layout is strictly roomier
+    /// than the original constants and the bar un-collapses.
+    static let collapseRecoveryReserve: CGFloat = 28
     static let unmeasuredFallback: CGFloat = 140
     static let floor: CGFloat = 96
 
@@ -46,20 +64,23 @@ struct MobileLeadingToolbarTitleWidth {
         hasTrailingCluster: Bool,
         measuredTrailingItemsWidth: CGFloat = 0,
         measuredTrailingItemCount: Int = 0,
-        trailingItemCount: Int = 0
+        trailingItemCount: Int = 0,
+        hadTrailingCollapse: Bool = false
     ) {
         self.contentWidth = contentWidth
         self.hasBackButton = hasBackButton
         self.hasTrailingCluster = hasTrailingCluster
         self.measuredTrailingItemsWidth = measuredTrailingItemsWidth
         self.measuredTrailingItemCount = measuredTrailingItemCount
         self.trailingItemCount = trailingItemCount
+        self.hadTrailingCollapse = hadTrailingCollapse
     }
 
     var cap: CGFloat {
         guard contentWidth > 0 else { return Self.unmeasuredFallback }
         let leading = hasBackButton ? Self.backButtonReserve : 0
-        return max(0, contentWidth - leading - trailingReserve - Self.barMarginsAndSpacing)
+        let recovery = hadTrailingCollapse ? Self.collapseRecoveryReserve : 0
+        return max(0, contentWidth - leading - trailingReserve - Self.barMarginsAndSpacing - recovery)
     }
 
     private var trailingReserve: CGFloat {

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobilePinnedNavigationBar.swift

@@ -0,0 +1,119 @@
+import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#endif
+
+extension View {
+    /// Keeps the navigation bar fully expanded over scrollable content.
+    ///
+    /// iOS 26 minimizes the navigation bar into a floating overflow pill when
+    /// the content under it scrolls (Safari-style), which hides the back
+    /// button, the workspace title, and the trailing controls behind a "…"
+    /// menu on the browser and chat surfaces. The SwiftUI opt-out
+    /// (`toolbarMinimizeBehavior(.never)`) does not exist in the iOS 26 SDK,
+    /// and UIKit's 26 SDK only exposes a minimize behavior for the tab bar.
+    /// The bar's scroll linkage does have a public control: the view
+    /// controller's top-edge content scroll view (iOS 15+), which UIKit
+    /// otherwise discovers automatically (the browser pane's web view).
+    /// Re-pointing that association at a static, never-scrolling stand-in
+    /// decouples the bar from the content, so it stays expanded exactly like
+    /// the terminal surface, where no system scroll view exists to discover.
+    ///
+    /// On iOS 27 the native opt-out is applied as well once an Xcode 27
+    /// toolchain builds this target.
+    @ViewBuilder
+    func mobilePinnedNavigationBar() -> some View {
+        #if canImport(UIKit)
+        #if compiler(>=6.4)
+        if #available(iOS 27.0, *) {
+            background(PinnedNavigationBarApplier())
+                .toolbarMinimizeBehavior(.never, for: .navigationBar)
+        } else {
+            background(PinnedNavigationBarApplier())
+        }
+        #else
+        background(PinnedNavigationBarApplier())
+        #endif
+        #else
+        self
+        #endif
+    }
+}
+
+#if canImport(UIKit)
+private struct PinnedNavigationBarApplier: UIViewRepresentable {
+    func makeUIView(context: Context) -> PinnedNavigationBarProbeView {
+        let view = PinnedNavigationBarProbeView()
+        view.isUserInteractionEnabled = false
+        view.backgroundColor = .clear
+        return view
+    }
+
+    func updateUIView(_ view: PinnedNavigationBarProbeView, context: Context) {
+        view.applyIfNeeded()
+    }
+
+    static func dismantleUIView(_ view: PinnedNavigationBarProbeView, coordinator: ()) {
+        view.clearAssociation()
+    }
+}
+
+final class PinnedNavigationBarProbeView: UIView {
+    /// The stand-in the bar tracks instead of the real content: zero content,
+    /// scrolling disabled, so the bar's scroll edge never moves.
+    private let anchorScrollView: UIScrollView = {
+        let scrollView = UIScrollView()
+        scrollView.isScrollEnabled = false
+        return scrollView
+    }()
+    /// The controller currently pointed at the stand-in, so teardown can
+    /// release the association instead of leaving the bar tracking a
+    /// deallocated probe's scroll view.
+    private weak var appliedTarget: UIViewController?
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        applyIfNeeded()
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        // Re-assert after layout passes: SwiftUI can re-derive the tracked
+        // scroll view for its own containers, and the association resets when
+        // the hosting controller re-parents during navigation transitions.
+        applyIfNeeded()
+    }
+
+    func applyIfNeeded() {
+        guard window != nil, let target = barOwningViewController() else { return }
+        if target.contentScrollView(for: .top) !== anchorScrollView {
+            target.setContentScrollView(anchorScrollView, for: .top)
+            appliedTarget = target
+        }
+    }
+
+    func clearAssociation() {
+        guard let target = appliedTarget,
+              target.contentScrollView(for: .top) === anchorScrollView
+        else { return }
+        target.setContentScrollView(nil, for: .top)
+        appliedTarget = nil
+    }
+
+    /// The pushed screen's view controller: the ancestor whose parent is the
+    /// navigation controller (its navigation item drives the bar). Fails
+    /// closed when no such ancestor exists (previews, sheets), rather than
+    /// re-pointing an unrelated controller's scroll edge.
+    private func barOwningViewController() -> UIViewController? {
+        var responder: UIResponder? = next
+        while let current = responder {
+            if let viewController = current as? UIViewController,
+               viewController.parent is UINavigationController {
+                return viewController
+            }
+            responder = current.next
+        }
+        return nil
+    }
+}
+#endif

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/TrailingToolbarItemMeasurement.swift

@@ -1,23 +1,143 @@
 import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#endif
+
+/// Live, reference-typed presence flags shared between probe islands. UIKit
+/// callbacks read and write these directly at event time; SwiftUI closure
+/// captures of value state would go stale between renders and misreport
+/// during navigation transitions.
+@MainActor
+final class WorkspaceBarPresence {
+    /// Whether the detail screen's content view is attached to a window.
+    /// False during whole-screen detachments (a deeper push, a pop, scene
+    /// teardown), when toolbar probes also detach for lifecycle reasons that
+    /// have nothing to do with the overflow More menu.
+    var detailContentAttached = false
+}
 
 extension View {
+    /// Tracks whether this view's content is attached to a UIKit window,
+    /// writing into the shared presence object in real time.
+    @ViewBuilder
+    func trackBarPresence(_ presence: WorkspaceBarPresence) -> some View {
+        #if canImport(UIKit)
+        background(ContentPresenceReader(presence: presence))
+        #else
+        self
+        #endif
+    }
+
     /// Reports this trailing toolbar item's rendered content width into the
-    /// shared measurement dictionary.
+    /// shared measurement dictionary, and optionally reports when the item's
+    /// content leaves the window while still structurally present.
     ///
     /// The leading title menu caps its width to the bar's remaining space so
-    /// the trailing items are never squeezed into the overflow More menu.
-    /// Deliberately no `onDisappear` cleanup: overflowing into More also
-    /// removes the bar content, so clearing on disappear would release the
-    /// reservation and make the collapse sticky. Callers that structurally
-    /// remove an item clear its key from the condition that removed it.
+    /// the trailing items are never squeezed into the More menu. Width
+    /// entries are deliberately never removed on disappear: overflowing into
+    /// More also removes the bar content, so clearing the width there would
+    /// release the reservation and make the collapse sticky. Callers that
+    /// structurally remove an item clear its key from the condition that
+    /// removed it.
+    ///
+    /// `onLeaveBar` is only wired for items that are always structurally
+    /// present, and the callback must gate on the screen's content still
+    /// being attached (`WorkspaceBarPresence`): a whole-screen detachment
+    /// (deeper push, pop) also detaches this probe and is indistinguishable
+    /// from a More-menu collapse at this level.
+    @ViewBuilder
     func measureTrailingToolbarItem(
         _ key: String,
-        into widths: Binding<[String: CGFloat]>
+        into widths: Binding<[String: CGFloat]>,
+        onLeaveBar: (@MainActor () -> Void)? = nil
     ) -> some View {
-        onGeometryChange(for: CGFloat.self) { proxy in
+        let measured = onGeometryChange(for: CGFloat.self) { proxy in
             proxy.size.width
         } action: { width in
             widths.wrappedValue[key] = width
         }
+        #if canImport(UIKit)
+        measured.background(BarPresenceReader(probeKey: key, onLeaveBar: onLeaveBar))
+        #else
+        measured
+        #endif
+    }
+}
+
+#if canImport(UIKit)
+private struct ContentPresenceReader: UIViewRepresentable {
+    let presence: WorkspaceBarPresence
+
+    func makeUIView(context: Context) -> ContentPresenceProbeView {
+        let view = ContentPresenceProbeView()
+        view.isUserInteractionEnabled = false
+        view.backgroundColor = .clear
+        view.presence = presence
+        return view
+    }
+
+    func updateUIView(_ view: ContentPresenceProbeView, context: Context) {
+        view.presence = presence
+    }
+}
+
+final class ContentPresenceProbeView: UIView {
+    var presence: WorkspaceBarPresence?
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        let attached = window != nil
+        MainActor.assumeIsolated {
+            presence?.detailContentAttached = attached
+        }
+    }
+}
+
+/// Bridges out of the SwiftUI hosting island to observe whether the item's
+/// content is attached to a UIKit window. Detaching after having been
+/// attached, while the screen's own content stays on a window, is the
+/// observable signature of the system moving the item into the overflow More
+/// menu; the caller supplies that content-presence gate.
+private struct BarPresenceReader: UIViewRepresentable {
+    let probeKey: String
+    let onLeaveBar: (@MainActor () -> Void)?
+
+    func makeUIView(context: Context) -> BarPresenceProbeView {
+        let view = BarPresenceProbeView()
+        view.isUserInteractionEnabled = false
+        view.backgroundColor = .clear
+        view.probeKey = probeKey
+        view.onLeaveBar = onLeaveBar
+        return view
+    }
+
+    func updateUIView(_ view: BarPresenceProbeView, context: Context) {
+        view.onLeaveBar = onLeaveBar
+    }
+}
+
+final class BarPresenceProbeView: UIView {
+    var probeKey = ""
+    var onLeaveBar: (@MainActor () -> Void)?
+    private var wasAttached = false
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        #if DEBUG
+        NSLog(
+            "cmux.toolbar.collapse probe key=%@ attached=%d",
+            probeKey, window == nil ? 0 : 1
+        )
+        #endif
+        if window != nil {
+            wasAttached = true
+            return
+        }
+        guard wasAttached else { return }
+        wasAttached = false
+        MainActor.assumeIsolated {
+            onLeaveBar?()
+        }
     }
 }
+#endif