@swiftbrowser/native 0.18.2 → 0.19.0

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Navigation.swift

@@ -7,9 +7,10 @@ import SwiftUI
 /// `navstack`: the children are `navscreen`s, bottom to top. The protocol
 /// expresses push and pop purely as children appearing and disappearing;
 /// natively the path is derived from them. A native pop (the back button, an
-/// edge swipe) sends `tap` with the popped screen's id, as the protocol says,
-/// and the app removes the child in the same call, so the next read of the
-/// path already agrees with the screen.
+/// edge swipe) sends `tap` with the popped screen's id, as the protocol says
+/// (PopTap.swift: at once for a button, once the finger lets go for a
+/// swipe), and the app removes the child, so the next read of the path
+/// agrees with the screen.
 struct NavigationStackElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
@@ -29,9 +30,10 @@ struct NavigationStackElement: View {
         let path = Binding<[Int]>(
             get: { node?.children.filter { $0.kind == "navscreen" }.dropFirst().map(\.id) ?? [] },
             set: { next in
-                // Only pops come from here (pushes come from the app).
+                // Only pops come from here (pushes come from the app; a
+                // cancelled swipe puts its id back, which the getter kept).
                 for id in pushed where !next.contains(id) {
-                    app?.dispatch(.tap(id))
+                    PopTap.send(id, app: app)
                 }
             }
         )
@@ -43,10 +45,14 @@ struct NavigationStackElement: View {
                     }
                 }
                 .navigationDestination(for: Int.self) { id in
-                    if let screen = node?.children.first(where: { $0.id == id }) {
+                    // A screen the app has popped already (on the tap a back
+                    // swipe or button sent, before the pop's transition has
+                    // run) is still drawn as it was, from the tree's record
+                    // of it, so the pop slides it away rather than dropping
+                    // its content in one frame.
+                    if let screen = node?.children.first(where: { $0.id == id }) ?? app?.tree.poppedScreen(id) {
                         NavigationScreenElement(node: screen)
                     } else {
-                        // Popped by the app already; SwiftUI is on its way out.
                         Color.clear
                     }
                 }
@@ -106,6 +112,16 @@ struct NavigationSplitElement: View {
 struct NavigationScreenElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
+    /// The bar's items as the push began, shown until it settles (`held`
+    /// below): iOS sizes an item's glass as a push starts and lays it out
+    /// again only once the push ends, so an item that changes meanwhile (an
+    /// Edit button arriving with the rows) would sit clipped in the old shape
+    /// until then. Held, the change shows after the push, laid out whole.
+    @State private var held: [ToolbarSnapshot]?
+    @State private var settled = false
+
+    /// How long a push takes, with a margin.
+    private static let pushSettles: Duration = .milliseconds(600)
 
     var body: some View {
         let props = NavScreenProps(props: node.props)
@@ -122,10 +138,22 @@ struct NavigationScreenElement: View {
         let content = ZStack {
             ForEach(node.children(except: ["toolbar", "searchfield"])) { ElementView(node: $0) }
         }
+        let live = toolbars.map(ToolbarSnapshot.init)
+        let shown = props.depth > 0 && !settled ? (held ?? live) : live
         let titled = content
             .modifier(KeyboardBarInset(toolbars: keyboardToolbars))
             .navigationTitle(props.title)
-            .toolbar { ScreenToolbar(toolbars: toolbars) }
+            .toolbar { ScreenToolbar(toolbars: shown) }
+            .onAppear {
+                // A pushed screen, appearing: its bar as it is now, until the push has settled.
+                guard props.depth > 0, !settled, held == nil else { return }
+                held = live
+                Task { @MainActor in
+                    try? await Task.sleep(for: Self.pushSettles)
+                    settled = true
+                    held = nil
+                }
+            }
         let searched: AnyView = {
             guard let search else { return AnyView(titled) }
             let searchProps = SearchFieldProps(props: search.props)
@@ -135,8 +163,13 @@ struct NavigationScreenElement: View {
             ))
         }()
         #if os(iOS) || canImport(FoundationBridge)
+        // `.toolbar(.hidden, for:)` and `.statusBarHidden`: SwiftUI hides the
+        // bars (animated in an animated commit); `.automatic` leaves a shown one as it is.
         let modeTitled = searched
             .navigationBarTitleDisplayMode(props.displayMode == "inline" ? .inline : props.displayMode == "large" ? .large : .automatic)
+            .toolbar(props.navigationBarHidden ? .hidden : .automatic, for: .navigationBar)
+            .toolbar(props.bottomBarHidden ? .hidden : .automatic, for: .bottomBar)
+            .statusBarHidden(props.statusBarHidden)
         #if canImport(FoundationBridge)
         modeTitled // the shim has no `navigationBarBackButtonHidden` (nor does the protocol carry it)
         #else
@@ -188,8 +221,19 @@ struct NavigationScreenElement: View {
 /// group (and share the bar's glass) as the app's do. A toolbar content
 /// builder takes no loop, so the elements go in by index, eight to a chunk
 /// and the rest in the next.
+/// A `toolbar` element with the items it had at one moment (`NavigationScreenElement.held`), or has now.
+struct ToolbarSnapshot {
+    let node: ElementNode
+    let items: [ElementNode]
+
+    init(node: ElementNode) {
+        self.node = node
+        self.items = node.children
+    }
+}
+
 struct ScreenToolbar: ToolbarContent {
-    let toolbars: [ElementNode]
+    let toolbars: [ToolbarSnapshot]
     var from = 0
 
     var body: some ToolbarContent {
@@ -209,7 +253,7 @@ struct ScreenToolbar: ToolbarContent {
     @ToolbarContentBuilder
     private func item(_ offset: Int) -> some ToolbarContent {
         if from + offset < toolbars.count {
-            ToolbarElement(node: toolbars[from + offset])
+            ToolbarElement(toolbar: toolbars[from + offset])
         }
     }
 }
@@ -221,9 +265,10 @@ struct ScreenToolbar: ToolbarContent {
 /// `ToolbarItem` iOS 26 shows only the first), without the bar's shared
 /// glass when `sharedBackground` is `hidden` (iOS 26).
 struct ToolbarElement: ToolbarContent {
-    let node: ElementNode
+    let toolbar: ToolbarSnapshot
 
     var body: some ToolbarContent {
+        let node = toolbar.node
         let props = ToolbarProps(props: node.props)
         let placement = NavigationScreenElement.placement(props.placement)
         if let spacer = props.spacer {
@@ -234,12 +279,12 @@ struct ToolbarElement: ToolbarContent {
             }
         } else if props.sharedBackground == "hidden" {
             if #available(iOS 26, macOS 26, *) {
-                ToolbarItemGroup(placement: placement) { ChildrenView(node: node) }.sharedBackgroundVisibility(.hidden)
+                ToolbarItemGroup(placement: placement) { ForEach(toolbar.items) { ElementView(node: $0) } }.sharedBackgroundVisibility(.hidden)
             } else {
-                ToolbarItemGroup(placement: placement) { ChildrenView(node: node) }
+                ToolbarItemGroup(placement: placement) { ForEach(toolbar.items) { ElementView(node: $0) } }
             }
         } else {
-            ToolbarItemGroup(placement: placement) { ChildrenView(node: node) }
+            ToolbarItemGroup(placement: placement) { ForEach(toolbar.items) { ElementView(node: $0) } }
         }
     }
 }
@@ -250,6 +295,10 @@ struct ToolbarElement: ToolbarContent {
 struct NavigationLinkElement: View {
     let node: ElementNode
     @Environment(\.nativeApp) private var app
+    @Environment(\.listSelectsRows) private var listSelects
+    #if os(iOS) || canImport(FoundationBridge)
+    @Environment(\.editMode) private var editMode
+    #endif
 
     /// The wrappers a row's link may sit in and still be the row (the web
     /// engine's transparent kinds): any other kind between it and the list
@@ -267,12 +316,21 @@ struct NavigationLinkElement: View {
         return false
     }
 
+    /// Whether the list around is in edit mode with a selection: a link row
+    /// is then selected by its tap (the row's `tag`, ListRowElement), not
+    /// followed, as iOS selects a `NavigationLink` row then.
+    private var selecting: Bool {
+        #if os(iOS) || canImport(FoundationBridge)
+        listSelects && editMode?.wrappedValue.isEditing == true
+        #else
+        false
+        #endif
+    }
+
     var body: some View {
         let props = NavLinkProps(props: node.props)
         let inList = Self.isListRow(node)
-        Button {
-            app?.dispatch(.tap(node.id))
-        } label: {
+        let label = Group {
             if inList {
                 // The disclosure chevron in the trailing 22 points, as measured
                 // against iOS's row: 13 pt semibold, 2 in from the content's edge
@@ -291,9 +349,12 @@ struct NavigationLinkElement: View {
                 ChildrenView(node: node)
             }
         }
-        .buttonStyle(.plain)
-        .foregroundStyle(inList || props.plain ? AnyShapeStyle(HierarchicalShapeStyle.primary) : AnyShapeStyle(TintShapeStyle()))
-        .listRowBackground(props.selected ? Color.accentColor.opacity(0.15) : nil)
+        let tappable: AnyView = inList && selecting
+            ? AnyView(label)
+            : AnyView(Button { app?.dispatch(.tap(node.id)) } label: { label }.buttonStyle(.plain))
+        tappable
+            .foregroundStyle(inList || props.plain ? AnyShapeStyle(HierarchicalShapeStyle.primary) : AnyShapeStyle(TintShapeStyle()))
+            .listRowBackground(props.selected ? Color.accentColor.opacity(0.15) : nil)
     }
 }
 

package/swift/Sources/SwiftBrowserNative/Views/Kinds/PinchTracker.swift

@@ -0,0 +1,200 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftUI
+
+/// A pinch taken from the fingers themselves (iOS 18's `SpatialEventGesture`,
+/// Views/Kinds/More.swift), as the web renderer takes one from two pointers
+/// (Web/src/pinch.ts): the scale is the distance between the first two
+/// fingers over their distance when the second came down, the rotation the
+/// turn of the line between them (unwrapped past a half turn), the location
+/// their midpoint. The pinch begins the moment the scale has moved
+/// `minimumScaleDelta` or the angle `minimumAngleDelta` (with no minimum, on
+/// the first move), where SwiftUI's `MagnifyGesture` waits for the system's
+/// recognizer to make up its mind, a good way into the spread. A third
+/// finger waits; lifting one of the pair hands the pinch to it, the scale
+/// unbroken, and lifting the last two ends it. A report that leaves a finger
+/// out keeps it where it was. A reference, so a move redraws nothing.
+final class PinchTracker {
+    struct Report: Equatable {
+        var phase: String
+        var scale: Double
+        /// Degrees.
+        var rotation: Double
+        var scaleVelocity: Double
+        var rotationVelocity: Double
+        var startLocation: CGPoint
+        var location: CGPoint
+    }
+
+    /// The window the velocities are taken over, as the web renderer's.
+    static let velocityWindow: TimeInterval = 0.1
+
+    let magnify: Bool
+    let rotate: Bool
+    let minimumScaleDelta: Double
+    /// Degrees.
+    let minimumAngleDelta: Double
+
+    private struct Base {
+        var a: AnyHashable
+        var b: AnyHashable
+        var distance: Double
+        var angle: Double
+        var midpoint: CGPoint
+    }
+
+    /// A finger on the element: where it was last reported.
+    struct Finger: Equatable {
+        var id: AnyHashable
+        var location: CGPoint
+        /// `active`, or `ended` / `cancelled` as the system reported it.
+        var active: Bool
+    }
+
+    private var base: Base?
+    /// The fingers down, in order of arrival, at their last reported location.
+    private var fingers: [(id: AnyHashable, location: CGPoint)] = []
+    private var began = false
+    private var scale = 1.0
+    private var rotation = 0.0
+    private var lastAngle = 0.0
+    private var location = CGPoint.zero
+    private var samples: [(t: TimeInterval, scale: Double, rotation: Double)] = []
+    private var reported: Report?
+
+    init(magnify: Bool, rotate: Bool, minimumScaleDelta: Double, minimumAngleDelta: Double) {
+        self.magnify = magnify
+        self.rotate = rotate
+        self.minimumScaleDelta = max(0, minimumScaleDelta)
+        self.minimumAngleDelta = max(0, minimumAngleDelta)
+    }
+
+    /// Whether two fingers are being followed (a pinch, begun or not).
+    var tracking: Bool { base != nil }
+
+    /// Takes the fingers now down (in the element's coordinates) at `time`;
+    /// what to send, or nil when there is nothing to say yet.
+    func update(active: [(id: AnyHashable, location: CGPoint)], cancelled: Bool, at time: TimeInterval) -> Report? {
+        update(fingers: active.map { Finger(id: $0.id, location: $0.location, active: true) }, cancelled: cancelled, at: time)
+    }
+
+    /// Takes the fingers the system reported at `time`: a finger it reports
+    /// as ended or cancelled has lifted, one it leaves out is where it was
+    /// (a report need not name every finger). What to send, or nil when
+    /// there is nothing to say yet.
+    func update(fingers reports: [Finger], cancelled: Bool, at time: TimeInterval) -> Report? {
+        for finger in reports {
+            if !finger.active {
+                fingers.removeAll { $0.id == finger.id }
+            } else if let index = fingers.firstIndex(where: { $0.id == finger.id }) {
+                fingers[index].location = finger.location
+            } else {
+                fingers.append((finger.id, finger.location))
+            }
+        }
+        guard let base else {
+            guard fingers.count >= 2 else { return nil }
+            let a = fingers[0]
+            let b = fingers[1]
+            let distance = max(Self.distance(a.location, b.location), 1)
+            let angle = Self.angle(a.location, b.location)
+            let midpoint = Self.midpoint(a.location, b.location)
+            self.base = Base(a: a.id, b: b.id, distance: distance, angle: angle, midpoint: midpoint)
+            scale = 1
+            rotation = 0
+            lastAngle = angle
+            location = midpoint
+            samples = [(time, 1, 0)]
+            return nil
+        }
+        var a = fingers.first { $0.id == base.a }?.location
+        var b = fingers.first { $0.id == base.b }?.location
+        if a == nil || b == nil {
+            // A finger of the pair lifted. With two fingers still down (the
+            // system gave one a new identity, or a third was waiting) the
+            // pinch carries on from where it is, its scale unbroken.
+            guard fingers.count >= 2 else { return end(cancelled: cancelled) }
+            let next = (fingers[0], fingers[1])
+            let distance = Self.distance(next.0.location, next.1.location)
+            let angle = Self.angle(next.0.location, next.1.location)
+            self.base = Base(a: next.0.id, b: next.1.id, distance: max(distance / max(scale, 0.0001), 1), angle: base.angle, midpoint: base.midpoint)
+            lastAngle = angle
+            a = next.0.location
+            b = next.1.location
+        }
+        guard let a, let b, let base = self.base else { return nil }
+        scale = Self.distance(a, b) / base.distance
+        let angle = Self.angle(a, b)
+        var delta = angle - lastAngle
+        if delta > 180 { delta -= 360 } else if delta <= -180 { delta += 360 }
+        rotation += delta
+        lastAngle = angle
+        location = Self.midpoint(a, b)
+        samples.append((time, scale, rotation))
+        while samples.count > 2, let first = samples.first, time - first.t > Self.velocityWindow { samples.removeFirst() }
+        if !began {
+            let scaled = magnify && abs(scale - 1) >= minimumScaleDelta
+            let turned = rotate && abs(rotation) >= minimumAngleDelta
+            guard scaled || turned else { return nil }
+            began = true
+            return report("began")
+        }
+        let previous = reported
+        let next = report("changed")
+        if let previous, previous.scale == next.scale, previous.rotation == next.rotation, previous.location == next.location { return nil }
+        return next
+    }
+
+    /// Every finger up (or the gesture cancelled): the end of a pinch that began.
+    func end(cancelled: Bool) -> Report? {
+        defer {
+            base = nil
+            fingers = []
+            began = false
+            samples = []
+            reported = nil
+        }
+        guard began else { return nil }
+        return report(cancelled ? "cancelled" : "ended")
+    }
+
+    private func report(_ phase: String) -> Report {
+        let first = samples.first
+        let last = samples.last
+        let dt = first.map { f in (last?.t ?? f.t) - f.t } ?? 0
+        let scaleVelocity = first != nil && last != nil && dt > 0 ? (last!.scale - first!.scale) / dt : 0
+        let rotationVelocity = first != nil && last != nil && dt > 0 ? (last!.rotation - first!.rotation) / dt : 0
+        let out = Report(
+            phase: phase,
+            scale: Self.round(scale, 4),
+            rotation: Self.round(rotation, 2),
+            scaleVelocity: Self.round(scaleVelocity, 4),
+            rotationVelocity: Self.round(rotationVelocity, 2),
+            startLocation: base?.midpoint ?? .zero,
+            location: location
+        )
+        reported = out
+        return out
+    }
+
+    private static func distance(_ a: CGPoint, _ b: CGPoint) -> Double {
+        let dx = Double(b.x - a.x)
+        let dy = Double(b.y - a.y)
+        return (dx * dx + dy * dy).squareRoot()
+    }
+
+    /// Degrees, as `atan2` gives them (counterclockwise on screen is negative, as the web's).
+    private static func angle(_ a: CGPoint, _ b: CGPoint) -> Double {
+        atan2(Double(b.y - a.y), Double(b.x - a.x)) * 180 / .pi
+    }
+
+    private static func midpoint(_ a: CGPoint, _ b: CGPoint) -> CGPoint {
+        CGPoint(x: (a.x + b.x) / 2, y: (a.y + b.y) / 2)
+    }
+
+    private static func round(_ value: Double, _ places: Int) -> Double {
+        let factor = pow(10.0, Double(places))
+        return (value * factor).rounded() / factor
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Views/Kinds/PopTap.swift

@@ -0,0 +1,100 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftUI
+#if os(iOS) && !canImport(FoundationBridge)
+import UIKit
+#endif
+
+/// The `tap` a native pop sends with the popped screen's id (Navigation.swift),
+/// timed to the pop. For a back button or a programmatic pop it goes at once:
+/// the app removes the screen inside SwiftUI's set of the path, and the stack
+/// keeps drawing it from the tree's record through the transition
+/// (`OpTree.poppedScreen`). For an interactive pop (the edge swipe) SwiftUI
+/// sets the path the moment the swipe begins, before anyone knows whether
+/// it will go through; the tap waits until the finger has let go and the pop
+/// is finishing, and a cancelled swipe sends none. Sent at the swipe's start,
+/// the app's removal left the screen drawn from the record with its title
+/// gone while the finger was still down, and a cancelled swipe showing a
+/// screen the app no longer had.
+enum PopTap {
+    @MainActor
+    static func send(_ id: Int, app: NativeApp?) {
+        #if os(iOS) && !canImport(FoundationBridge)
+        if let coordinator = interactivePop() {
+            send(id, during: CoordinatorTransition(coordinator: coordinator)) { app?.dispatch(.tap($0)) }
+            return
+        }
+        #endif
+        app?.dispatch(.tap(id))
+    }
+
+    /// The tap through the pop's transition: at once unless a finger drives
+    /// it, else when the finger lets go, and only when the pop goes through.
+    @MainActor
+    static func send(_ id: Int, during transition: any PopTransition, dispatch: @escaping @MainActor (Int) -> Void) {
+        guard transition.isInteractive else {
+            dispatch(id)
+            return
+        }
+        transition.whenInteractionEnds { cancelled in
+            if !cancelled { dispatch(id) }
+        }
+    }
+
+    #if os(iOS) && !canImport(FoundationBridge)
+    /// The transition of a navigation controller in the app's windows that a finger is driving, if any.
+    @MainActor
+    private static func interactivePop() -> (any UIViewControllerTransitionCoordinator)? {
+        let windows = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.flatMap(\.windows)
+        for window in windows {
+            for nav in navigationControllers(in: window) {
+                if let coordinator = nav.transitionCoordinator, coordinator.isInteractive { return coordinator }
+            }
+        }
+        return nil
+    }
+
+    /// The navigation controllers behind the views in `window`, by their responder chains.
+    @MainActor
+    static func navigationControllers(in window: UIWindow) -> [UINavigationController] {
+        var found: [UINavigationController] = []
+        func visit(_ view: UIView) {
+            var responder: UIResponder? = view.next
+            while let r = responder {
+                if let nav = r as? UINavigationController, !found.contains(where: { $0 === nav }) { found.append(nav) }
+                responder = r.next
+            }
+            for subview in view.subviews { visit(subview) }
+        }
+        visit(window)
+        return found
+    }
+    #endif
+}
+
+/// A pop's transition as `PopTap` reads it: whether a finger drives it, and
+/// word of the finger letting go (UIKit's transition coordinator, or a test's).
+@MainActor
+protocol PopTransition {
+    var isInteractive: Bool { get }
+    /// Calls `handler` once the interactive part ends, with whether the pop was cancelled.
+    func whenInteractionEnds(_ handler: @escaping @MainActor (_ cancelled: Bool) -> Void)
+}
+
+#if os(iOS) && !canImport(FoundationBridge)
+/// UIKit's transition coordinator as a `PopTransition`.
+@MainActor
+struct CoordinatorTransition: PopTransition {
+    let coordinator: any UIViewControllerTransitionCoordinator
+
+    var isInteractive: Bool { coordinator.isInteractive }
+
+    func whenInteractionEnds(_ handler: @escaping @MainActor (_ cancelled: Bool) -> Void) {
+        coordinator.notifyWhenInteractionChanges { context in
+            let cancelled = context.isCancelled
+            MainActor.assumeIsolated { handler(cancelled) }
+        }
+    }
+}
+#endif
+#endif

package/swift/Sources/SwiftBrowserNative/Views/Kinds/Stacks.swift

@@ -204,6 +204,7 @@ struct ScrollViewElement: View {
             let scroll = ScrollView(axes, showsIndicators: props.showsIndicators) {
                 ChildrenView(node: node)
             }
+            .scrollDismissesKeyboard(props.dismissesKeyboard == "interactively" ? .interactively : props.dismissesKeyboard == "immediately" ? .immediately : .automatic)
             let anchored = anchored(AnyView(scroll), props: props)
             let refreshed: AnyView = props.refreshable ? AnyView(anchored.refreshable { app?.dispatch(.refresh(node.id)) }) : anchored
             let snapped: AnyView = props.snap == "paging" ? AnyView(refreshed.scrollTargetBehavior(.paging))
@@ -382,7 +383,7 @@ struct ScrollViewElement: View {
         var order: [Int: Int] = [:]
         func visit(_ element: ElementNode) {
             for child in element.children {
-                if child.kind == "scrollview" || child.kind == "list" { continue }
+                guard child.kind != "scrollview", child.kind != "list" else { continue }
                 if child.kind == "styled", child.style.scrollID { order[child.id] = order.count }
                 visit(child)
             }
@@ -404,7 +405,7 @@ struct ScrollViewElement: View {
         var best: ScrollRequest?
         func visit(_ element: ElementNode) {
             for child in element.children {
-                if child.kind == "scrollview" || child.kind == "list" { continue }
+                guard child.kind != "scrollview", child.kind != "list" else { continue }
                 if child.kind == "styled", let request = child.style.scrollTo, best == nil || request.serial > best!.serial {
                     best = ScrollRequest(serial: request.serial, id: child.id, anchor: request.anchor.map(UnitPoint.init(spec:)), axes: request.axes)
                 }

package/swift/Sources/SwiftBrowserNative/Views/StyleModifier.swift

@@ -53,6 +53,10 @@ extension View {
         if let tint = style.tint { view = AnyView(view.tint(Color(spec: tint))) }
         // `.scrollDisabled`: the scroll views and text editors below (a text editor then as tall as its lines).
         if let disabled = style.raw.bool("scrollDisabled") { view = AnyView(view.scrollDisabled(disabled)) }
+        // `.textSelection(.enabled)`: the text below can be selected.
+        if let selectable = style.raw.bool("textSelection") {
+            view = selectable ? AnyView(view.textSelection(.enabled)) : AnyView(view.textSelection(.disabled))
+        }
         // `labelIcon` marks a `Label`'s icon; HStackElement draws the label as one.
         if let alignment = style.raw.string("gridColumnAlignment") { view = AnyView(view.gridColumnAlignment(HorizontalAlignment(name: alignment))) }
 

package/swift/Sources/SwiftBrowserProtocol/Props.swift

@@ -132,6 +132,8 @@ public struct ScrollViewProps: Equatable, Sendable {
     public var scrollOffset: ScrollOffsetSpec?
     /// `.defaultScrollAnchor(_:)`: where the content starts, and where it stays as it grows.
     public var defaultScrollAnchor: UnitPointSpec?
+    /// `.scrollDismissesKeyboard(_:)`: `immediately` or `interactively`; nil leaves the keyboard be.
+    public var dismissesKeyboard: String?
     public init(props: JSONObject) {
         axes = props.string("axes") ?? "vertical"
         showsIndicators = props.bool("showsIndicators") ?? true
@@ -142,6 +144,7 @@ public struct ScrollViewProps: Equatable, Sendable {
         reportsGeometry = props.bool("reportsGeometry") ?? false
         scrollOffset = ScrollOffsetSpec(json: props.value("scrollOffset"))
         defaultScrollAnchor = UnitPointSpec(json: props.value("defaultScrollAnchor"))
+        dismissesKeyboard = props.bool("dismissesKeyboard") == true ? "immediately" : props.string("dismissesKeyboard")
     }
 }
 
@@ -183,9 +186,22 @@ public struct ListProps: Equatable, Sendable {
 public struct SectionProps: Equatable, Sendable {
     public var header: String?
     public var footer: String?
+    /// `Section(isExpanded:)`: the section collapses (in a sidebar-style list); a `tap` toggles it.
+    public var collapsible: Bool
+    public var expanded: Bool
     public init(props: JSONObject) {
         header = props.string("header")
         footer = props.string("footer")
+        collapsible = props.bool("collapsible") ?? false
+        expanded = props.bool("expanded") ?? true
+    }
+}
+
+/// `disclosuregroup`: open or not; its children are the label (first) and the content; a `tap` toggles it.
+public struct DisclosureGroupProps: Equatable, Sendable {
+    public var expanded: Bool
+    public init(props: JSONObject) {
+        expanded = props.bool("expanded") ?? false
     }
 }
 
@@ -284,12 +300,19 @@ public struct NavScreenProps: Equatable, Sendable {
     public var depth: Int
     public var toolbarRole: String?
     public var backButtonHidden: Bool
+    /// `.toolbar(.hidden, for: .navigationBar)` / `.bottomBar`, and `.statusBarHidden()`.
+    public var navigationBarHidden: Bool
+    public var bottomBarHidden: Bool
+    public var statusBarHidden: Bool
     public init(props: JSONObject) {
         title = props.string("title") ?? ""
         displayMode = props.string("displayMode") ?? "automatic"
         depth = props.int("depth") ?? 0
         toolbarRole = props.string("toolbarRole")
         backButtonHidden = props.bool("backButtonHidden") ?? false
+        navigationBarHidden = props.bool("navigationBarHidden") ?? false
+        bottomBarHidden = props.bool("bottomBarHidden") ?? false
+        statusBarHidden = props.bool("statusBarHidden") ?? false
     }
 }
 
@@ -532,11 +555,14 @@ public struct SliderProps: Equatable, Sendable {
     public var min: Double
     public var max: Double
     public var step: Double?
+    /// What each child is, in order: `label`, `min` (the minimum value's label), `max`.
+    public var labels: [String]
     public init(props: JSONObject) {
         value = props.double("value") ?? 0
         min = props.double("min") ?? 0
         max = props.double("max") ?? 1
         step = props.double("step")
+        labels = props.array("labels")?.compactMap(\.string) ?? []
     }
 }
 

package/swift/Sources/SwiftBrowserTree/OpTree.swift

@@ -26,6 +26,13 @@ public final class OpTree {
     /// The root container, element id 0.
     public let root: ElementNode
     private var nodes: [Int: ElementNode]
+    /// Screens (`navscreen`) removed lately, with when: a navigation stack
+    /// keeps drawing one through the pop that takes it off (SwiftUI asks
+    /// the destination for it while the transition runs; the app has
+    /// removed it by then, synchronously on the pop's tap).
+    private var poppedScreens: [Int: (node: ElementNode, at: Date)] = [:]
+    /// How long a popped screen stays available: past any pop transition.
+    private static let poppedScreenLife: TimeInterval = 3
     /// The ops of the current pass, until its `commit`.
     private var pending: [Op] = []
     /// How many passes were committed.
@@ -57,6 +64,18 @@ public final class OpTree {
     /// The element with this id, when it exists (created and not removed).
     public func node(_ id: Int) -> ElementNode? { nodes[id] }
 
+    /// A `navscreen` removed within the last moments (`poppedScreenLife`),
+    /// its subtree as it was: what a stack shows while the pop that removed
+    /// it is still animating. Nil once it is forgotten or its id reused.
+    public func poppedScreen(_ id: Int) -> ElementNode? {
+        guard let entry = poppedScreens[id] else { return nil }
+        guard Date().timeIntervalSince(entry.at) < Self.poppedScreenLife else {
+            poppedScreens[id] = nil
+            return nil
+        }
+        return entry.node
+    }
+
     /// How many elements exist, the root included.
     public var count: Int { nodes.count }
 
@@ -126,6 +145,7 @@ public final class OpTree {
                 // for a live id replaces it in place (the web renderer does the same).
                 detach(existing)
             }
+            poppedScreens[id] = nil
             nodes[id] = ElementNode(id: id, kind: kind, props: props)
         case .update(let id, let props):
             guard let node = nodes[id] else { throw OpTreeError("update: no element \(id)") }
@@ -155,6 +175,11 @@ public final class OpTree {
             guard let node = nodes[id] else { throw OpTreeError("remove: no element \(id)") }
             detach(node)
             forget(node)
+            if node.kind == "navscreen" {
+                let now = Date()
+                poppedScreens = poppedScreens.filter { now.timeIntervalSince($0.value.at) < Self.poppedScreenLife }
+                poppedScreens[id] = (node, now)
+            }
         case .commit:
             break
         case .other(let name, let fields):