craft-native 0.0.499 → 0.0.502

package/dist/ios/templates/CraftNativeScreen.swift

@@ -150,6 +150,38 @@ func craftNativeNumber(_ value: Any?) -> NSNumber? {
     return number
 }
 
+/// A number from a prop as an `Int`, the way `toInt()` gives it on the
+/// Android host: toward zero, the nearest end of the 32-bit range when it is
+/// outside it, and 0 when it is not a number.
+///
+/// `Int(_:)` traps on a value it cannot hold, and a prop is whatever the
+/// screen's script said: `maxLength={Number.MAX_VALUE}` ended the process
+/// (#510). The 32-bit range is the other host's, and it leaves room for the
+/// arithmetic done on the result, which `Int.max` would not.
+func craftNativeInt(_ value: Double) -> Int {
+    guard !value.isNaN else { return 0 }
+    return Int(max(Double(Int32.min), min(Double(Int32.max), value.rounded(.towardZero))))
+}
+
+func craftNativeInt(_ value: CGFloat) -> Int { craftNativeInt(Double(value)) }
+
+/// The most a number may be in layout, either side of zero: 2^25 points. It
+/// is far past any screen, and small enough that what the layout makes of a
+/// few such numbers multiplied together still fits a Float, which the flex
+/// engine works in.
+let craftNativeLayoutLimit: CGFloat = 33_554_432
+
+/// A number for layout: inside that limit, and 0 when it is not a number.
+///
+/// A style is whatever the script said. `flex: Number.MAX_VALUE` is finite,
+/// and became an infinite share of a row, an infinite frame, and then
+/// UIKit's `NSLayoutConstraint constant is not finite! That's illegal`, an
+/// exception nothing catches: the app ended. Lengths and flex factors are
+/// held to this as they are read, and so is every frame the layout produces.
+func craftNativeLayoutNumber(_ value: CGFloat) -> CGFloat {
+    value.isNaN ? 0 : max(-craftNativeLayoutLimit, min(craftNativeLayoutLimit, value))
+}
+
 /// A finite number from a prop, for the views outside the screen controller,
 /// which has its own: the keyboard-avoiding view and SVG text read theirs
 /// with it, and without it the template did not compile.
@@ -161,11 +193,19 @@ private func number(_ value: Any?) -> CGFloat? {
     return value.isFinite ? value : nil
 }
 
+/// A finite number from a style, held to what layout can use (see
+/// `craftNativeLayoutNumber`). A padding, radius, spacing or size of
+/// `Number.MAX_VALUE` reached UIKit as an inset or a font it could not place,
+/// and UIKit raised `CALayer position contains NaN`: the app ended.
+private func styleNumber(_ value: Any?) -> CGFloat? {
+    number(value).map(craftNativeLayoutNumber)
+}
+
 private func craftNativeFontWeight(_ value: Any?) -> String? {
     if let value = value as? String { return value }
     guard let number = craftNativeNumber(value), number.doubleValue.isFinite else { return nil }
     let integer = number.doubleValue.rounded()
-    return integer == number.doubleValue ? String(Int(integer)) : nil
+    return integer == number.doubleValue ? String(craftNativeInt(integer)) : nil
 }
 
 private func craftNativePickerValue(_ value: Any?) -> String? {
@@ -174,31 +214,34 @@ private func craftNativePickerValue(_ value: Any?) -> String? {
     return nil
 }
 
-private func craftNativeGridColumnCount(_ value: Any?) -> Int {
-    if let number = craftNativeNumber(value) { return max(1, number.intValue) }
-    guard let text = value as? String else { return 1 }
-    let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
-    if trimmed.hasPrefix("repeat(") {
-        let digits = trimmed.dropFirst("repeat(".count).prefix { $0.isNumber }
-        if let count = Int(digits) { return max(1, count) }
-    }
-    let tracks = trimmed.split(whereSeparator: { $0 == " " || $0 == "\t" || $0 == "\n" })
-    return max(1, tracks.count)
-}
+/// The most tracks a grid is given, either way. A count is whatever the
+/// script said (`gridTemplateRows: Number.MAX_VALUE`,
+/// `repeat(4294967296, 1fr)`), and the layout makes an array of rows that
+/// long and hands the shared engine both counts as a `UInt32`: the first ran
+/// the process out of memory and the second trapped. No screen has room to
+/// show more tracks than this.
+let craftNativeGridTrackLimit = 1024
 
-private func craftNativeGridRowCount(_ value: Any?) -> Int? {
-    if let number = craftNativeNumber(value) { return max(1, number.intValue) }
+func craftNativeGridTrackCount(_ value: Any?) -> Int? {
+    if let number = craftNativeNumber(value) {
+        return min(craftNativeGridTrackLimit, max(1, craftNativeInt(number.doubleValue)))
+    }
     guard let text = value as? String else { return nil }
     let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
     guard !trimmed.isEmpty else { return nil }
     if trimmed.hasPrefix("repeat(") {
-        let digits = trimmed.dropFirst("repeat(".count).prefix { $0.isNumber }
-        if let count = Int(digits) { return max(1, count) }
+        let digits = trimmed.dropFirst("repeat(".count).prefix { ("0"..."9").contains($0) }
+        // Digits past what an Int holds are still a count, and still too many.
+        if !digits.isEmpty { return min(craftNativeGridTrackLimit, max(1, Int(digits) ?? craftNativeGridTrackLimit)) }
     }
     let tracks = trimmed.split(whereSeparator: { $0 == " " || $0 == "\t" || $0 == "\n" })
-    return tracks.isEmpty ? nil : max(1, tracks.count)
+    return tracks.isEmpty ? nil : min(craftNativeGridTrackLimit, tracks.count)
 }
 
+private func craftNativeGridColumnCount(_ value: Any?) -> Int { craftNativeGridTrackCount(value) ?? 1 }
+
+private func craftNativeGridRowCount(_ value: Any?) -> Int? { craftNativeGridTrackCount(value) }
+
 /// Optional bridge to the shared Zig flex rule. Native hosts retain their
 /// local implementation when no Craft runtime is linked (the normal SDK
 /// fallback), while runtime-backed apps get one cross-platform calculation.
@@ -2389,16 +2432,16 @@ private enum CraftNativeLength: Equatable {
         if let number = craftNativeNumber(value) {
             let points = CGFloat(truncating: number)
             guard points.isFinite else { return nil }
-            self = .points(points)
+            self = .points(craftNativeLayoutNumber(points))
             return
         }
         guard let text = (value as? String)?.trimmingCharacters(in: .whitespaces), !text.isEmpty else { return nil }
         if text.hasSuffix("%"), let fraction = Double(text.dropLast()), fraction.isFinite {
-            self = .percent(CGFloat(fraction) / 100)
+            self = .percent(craftNativeLayoutNumber(CGFloat(fraction) / 100))
         } else if text.hasSuffix("px"), let points = Double(text.dropLast(2)), points.isFinite {
-            self = .points(CGFloat(points))
+            self = .points(craftNativeLayoutNumber(CGFloat(points)))
         } else if let points = Double(text), points.isFinite {
-            self = .points(CGFloat(points))
+            self = .points(craftNativeLayoutNumber(CGFloat(points)))
         } else {
             return nil
         }
@@ -2449,7 +2492,7 @@ private struct CraftNativeLayoutStyle {
         func number(_ value: Any?) -> CGFloat? {
             guard let number = craftNativeNumber(value) else { return nil }
             let value = CGFloat(truncating: number)
-            return value.isFinite ? value : nil
+            return value.isFinite ? craftNativeLayoutNumber(value) : nil
         }
         width = CraftNativeLength(raw["width"])
         height = CraftNativeLength(raw["height"])
@@ -2466,7 +2509,7 @@ private struct CraftNativeLayoutStyle {
         left = number(raw["left"])
         let align = raw["alignSelf"] as? String
         alignSelf = align == "auto" ? nil : align
-        order = number(raw["order"]).map { Int($0.rounded(.towardZero)) } ?? 0
+        order = number(raw["order"]).map { craftNativeInt($0) } ?? 0
         // `flex: n` is the web's and React Native's shorthand: a positive
         // number grows by n, shrinks, and starts from nothing, so `flex-1`
         // siblings share a row equally whatever their content.
@@ -2832,7 +2875,7 @@ enum CraftNativeFlexLayout {
     static func ceiled(_ size: CGSize, scale: CGFloat, atLeast floor: CGSize) -> CGSize {
         let scale = max(1, scale)
         // Less a hair, so a size already on the pixel grid stays put.
-        func up(_ value: CGFloat) -> CGFloat { (value * scale - 0.001).rounded(.up) / scale }
+        func up(_ value: CGFloat) -> CGFloat { (craftNativeLayoutNumber(value) * scale - 0.001).rounded(.up) / scale }
         return CGSize(width: max(floor.width, up(size.width)), height: max(floor.height, up(size.height)))
     }
 
@@ -2840,7 +2883,9 @@ enum CraftNativeFlexLayout {
     /// neither overlap nor leave a hairline between them.
     static func snapped(_ rect: CGRect, scale: CGFloat) -> CGRect {
         let scale = max(1, scale)
-        func snap(_ value: CGFloat) -> CGFloat { (value * scale).rounded() / scale }
+        // Whatever the arithmetic before this made of the styles it was
+        // given, the frame UIKit is handed is one it accepts.
+        func snap(_ value: CGFloat) -> CGFloat { (craftNativeLayoutNumber(value) * scale).rounded() / scale }
         let minX = snap(rect.minX), minY = snap(rect.minY)
         return CGRect(x: minX, y: minY, width: max(0, snap(rect.maxX) - minX), height: max(0, snap(rect.maxY) - minY))
     }
@@ -3314,6 +3359,7 @@ private class CraftNativeFlowView: UIStackView {
             if moved {
                 craftScreenController?.scheduleLayoutEvents()
                 craftScreenController?.scheduleKeyboardInsets()
+                craftScreenController?.scheduleFloatingClearance()
             }
         }
         for (child, frame) in result.frames {
@@ -4333,7 +4379,11 @@ class CraftNativePositionedImageView: UIView {
         }
         let rawFit = value("objectFit"), rawPosition = value("objectPosition")
         if rawFit != nil || rawPosition != nil {
-            let requested = rawFit as? String ?? "fill"
+            // A position does not choose a fit, as in CSS. STX compiles
+            // `object-cover` to `resizeMode: "cover"` and sets no objectFit,
+            // so a cover image given a position was drawn as "fill":
+            // stretched to its box instead of cropped (#532).
+            let requested = rawFit as? String ?? Self.objectFit(resizeMode: style["resizeMode"] as? String ?? props["resizeMode"] as? String)
             fit = ["fill", "contain", "cover", "none", "scale-down"].contains(requested) ? requested : "fill"
             position = Self.objectPosition(rawPosition)
         } else { fit = nil }
@@ -4361,6 +4411,17 @@ class CraftNativePositionedImageView: UIView {
     var usesObjectGeometry: Bool { fit != nil }
     var objectCovers: Bool { fit == "cover" }
 
+    /// The fit a `resizeMode` already asks for, for an image that has a
+    /// position and no `objectFit`; "fill" when it has neither.
+    static func objectFit(resizeMode: String?) -> String {
+        switch resizeMode {
+        case "cover": return "cover"
+        case "contain": return "contain"
+        case "center": return "none"
+        default: return "fill"
+        }
+    }
+
     private static func objectPosition(_ raw: Any?) -> CGPoint {
         guard let text = raw as? String else { return CGPoint(x: 0.5, y: 0.5) }
         var parts = text.lowercased().split(whereSeparator: { $0.isWhitespace }).map(String.init)
@@ -5001,7 +5062,7 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
     /// these indices stay at the top of the visible area once scrolled to,
     /// each pushed up by the next. Vertical scroll views only.
     func setStickyHeaderIndices(_ value: Any?) {
-        let next = Array(Set(((value as? [Any]) ?? []).compactMap { number($0).map { Int($0) } }.filter { $0 >= 0 })).sorted()
+        let next = Array(Set(((value as? [Any]) ?? []).compactMap { number($0).map { craftNativeInt($0) } }.filter { $0 >= 0 })).sorted()
         guard next != stickyIndices else { return }
         stickyIndices = next
         setNeedsLayout()
@@ -5117,6 +5178,19 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
         setContentNeedsLayout()
     }
 
+    /// What covers the end of this scroll view from below: the keyboard, and
+    /// the compact tab actions floating above the tab bar (#523). The content
+    /// is inset by the larger, so its last lines can be scrolled clear of
+    /// whichever reaches further.
+    var keyboardCover: CGFloat = 0 { didSet { applyCover() } }
+    var floatingCover: CGFloat = 0 { didSet { applyCover() } }
+
+    private func applyCover() {
+        let cover = max(keyboardCover, floatingCover)
+        if abs(contentInset.bottom - cover) > 0.5 { contentInset.bottom = cover }
+        if abs(verticalScrollIndicatorInsets.bottom - cover) > 0.5 { verticalScrollIndicatorInsets.bottom = cover }
+    }
+
     private var refreshingProp = false
 
     /// `onRefresh` and `refreshing`: the system's pull to refresh, controlled
@@ -5525,7 +5599,7 @@ final class CraftNativeSvgView: UIView {
         var out = from
         var i = 0
         while i < from.count {
-            let command = Int(from[i])
+            let command = craftNativeInt(from[i])
             guard to[i] == from[i] else { return from }
             let count: Int
             switch command {
@@ -5710,7 +5784,7 @@ final class CraftNativeSvgView: UIView {
         guard !text.isEmpty else { return }
         let props = node["props"] as? [String: Any] ?? [:]
         let style = node["style"] as? [String: Any] ?? [:]
-        let size = number(props["fontSize"]) ?? number(style["fontSize"]) ?? 12
+        let size = number(props["fontSize"]) ?? styleNumber(style["fontSize"]) ?? 12
         let weight: UIFont.Weight = {
             switch paint.fontWeight?.lowercased() {
             case "500": return .medium
@@ -5752,7 +5826,7 @@ final class CraftNativeSvgView: UIView {
         var i = 0
         func point(_ at: Int) -> CGPoint { CGPoint(x: n[at], y: n[at + 1]) }
         while i < n.count {
-            switch Int(n[i]) {
+            switch craftNativeInt(n[i]) {
             case 0 where i + 2 < n.count: path.move(to: point(i + 1)); i += 3
             case 1 where i + 2 < n.count: path.addLine(to: point(i + 1)); i += 3
             case 2 where i + 6 < n.count: path.addCurve(to: point(i + 5), controlPoint1: point(i + 1), controlPoint2: point(i + 3)); i += 7
@@ -6857,6 +6931,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         /// targeted update of this subtree inherits it without its ancestors.
         var inheritedFontFamily: String?
         var children: [RenderedNode] = []
+        /// `autoFocus` was on when this input was last drawn. Focus is taken
+        /// when it turns on, which mounting with it on is, and not on each
+        /// render while it stays on (#511).
+        var autoFocus = false
         var widthConstraint: NSLayoutConstraint?
         var heightConstraint: NSLayoutConstraint?
 
@@ -7015,6 +7093,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// Where the keyboard is on the screen while it is up, in screen coordinates.
     private var keyboardScreenFrame: CGRect?
     private var keyboardInsetsScheduled = false
+    private var floatingClearanceScheduled = false
+    /// Whether any scroll view may still hold room for actions that have gone.
+    private var floatingClearanceApplied = false
     /// The hybrid shell (CraftHybrid.swift), when this screen is one of a web
     /// app's native screens: told of the first frame, of a first frame that
     /// could not be drawn, and of `craft.navigation.open(path)`.
@@ -7121,6 +7202,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             // a screen that hid its own.
             navigationController?.setNavigationBarHidden(false, animated: animated)
         }
+        // Options can arrive before the screen is in a stack: whether it has
+        // a screen to go back to is known now.
+        if backButtonSpec != nil { applyLeadingBarItems() }
         applyNavigationBarAppearance()
         // Each screen says whether it wants the tab bar, so one that hid it
         // never leaves it hidden for the next. Only the screen on screen:
@@ -7396,6 +7480,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         emitLayoutEvents()
         sendViewportIfChanged()
         scheduleKeyboardInsets()
+        scheduleFloatingClearance()
     }
 
     /// The width the bundle last heard, so a layout pass at the same size says nothing.
@@ -7794,7 +7879,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// - `craft.secureStorage.getSync(key)`: the Keychain item the web page's
     ///   `craft.secureStorage.set` wrote.
     /// - `craft.navigation.setOptions({ title, titleColor, largeTitle, hidden,
-    ///   backTitle, tabBarHidden, tabBarHiddenWhenPushed, tabItem, swipeBack,
+    ///   backTitle, backButton, tabBarHidden, tabBarHiddenWhenPushed, tabItem, swipeBack,
     ///   contentSwipeBack,
     ///   tabSwipeEnabled, backgroundColor, navigationBarSolid, leftButtons,
     ///   rightButtons, tabAccessory })`; a button's tap is the event
@@ -8410,10 +8495,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 navigationController?.setNavigationBarHidden(hidden, animated: animatesNavigationBarChanges)
             }
         }
+        if options.keys.contains("backButton") {
+            backButtonSpec = options["backButton"] as? [String: Any]
+            backButtonItem = nil
+        }
         if options.keys.contains("leftButtons") {
             let buttons = (options["leftButtons"] as? [[String: Any]]) ?? []
-            navigationItem.leftItemsSupplementBackButton = true
-            navigationItem.leftBarButtonItems = buttons.compactMap(navigationButton)
+            leftButtonItems = buttons.compactMap(navigationButton)
+        }
+        if options.keys.contains("backButton") || options.keys.contains("leftButtons") {
+            applyLeadingBarItems()
         }
         if options.keys.contains("rightButtons") {
             let buttons = (options["rightButtons"] as? [[String: Any]]) ?? []
@@ -8511,6 +8602,44 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         return actions.isEmpty ? nil : UIMenu(children: actions)
     }
 
+    /// `backButton`: what this screen's Back is drawn with, when it is not
+    /// the chevron (`{ symbol: "xmark", accessibilityLabel: "Close" }` for a
+    /// screen that closes rather than goes back). `leftButtons` are added
+    /// beside Back, so a screen could not put its own symbol in Back's place
+    /// (#527). Nil is the system's chevron.
+    private var backButtonSpec: [String: Any]?
+    private var backButtonItem: UIBarButtonItem?
+    private var leftButtonItems: [UIBarButtonItem] = []
+
+    /// The screen's own Back, when it asked for one and has a screen to go
+    /// back to, then its left buttons. The chevron is hidden only while the
+    /// item that replaces it is in the bar: a symbol UIKit does not have
+    /// leaves the chevron. The back-swipe is the shell's to allow, and is
+    /// not affected.
+    private func applyLeadingBarItems() {
+        // Known to be the first screen of its stack: nothing to go back to.
+        let isRoot = navigationController?.viewControllers.first === self
+        if !isRoot, backButtonItem == nil, let spec = backButtonSpec,
+           let symbol = spec["symbol"] as? String, let image = UIImage(systemName: symbol) {
+            let item = UIBarButtonItem(image: image, style: .plain, target: self, action: #selector(backButtonTapped))
+            item.accessibilityIdentifier = "nav-back"
+            item.accessibilityLabel = (spec["accessibilityLabel"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+                ?? (symbol.hasPrefix("xmark") ? "Close" : "Back")
+            backButtonItem = item
+        }
+        let back = isRoot ? nil : backButtonItem
+        navigationItem.hidesBackButton = back != nil
+        navigationItem.leftItemsSupplementBackButton = true
+        navigationItem.leftBarButtonItems = (back.map { [$0] } ?? []) + leftButtonItems
+    }
+
+    /// What `craft.navigation.back()` does.
+    @objc private func backButtonTapped() {
+        if !isAppScript, navigationController?.topViewController === self {
+            navigationController?.popViewController(animated: true)
+        }
+    }
+
     private func navigationButton(_ spec: [String: Any]) -> UIBarButtonItem? {
         guard let id = spec["id"] as? String, !id.isEmpty else { return nil }
         let action = UIAction { [weak self] _ in
@@ -8816,6 +8945,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         // The app script has no screen for the keyboard to cover.
         if !isAppScript {
+            lifecycleObservers.append(NotificationCenter.default.addObserver(
+                forName: CraftChrome.floatingActionsDidMove,
+                object: nil,
+                queue: .main
+            ) { [weak self] _ in
+                self?.scheduleFloatingClearance()
+            })
             lifecycleObservers.append(NotificationCenter.default.addObserver(
                 forName: UIResponder.keyboardWillChangeFrameNotification,
                 object: nil,
@@ -8960,7 +9096,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// took account of) insets its content by that much, so everything in it
     /// can be scrolled above the keyboard. Internal for XCTest.
     func insetScrollViewsForKeyboard() {
-        var scrolls: [UIScrollView] = []
+        var scrolls: [CraftNativeScrollView] = []
         func collect(_ node: RenderedNode?) {
             guard let node else { return }
             if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical { scrolls.append(scroll) }
@@ -8977,8 +9113,68 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 let automaticBottom = max(0, scroll.adjustedContentInset.bottom - scroll.contentInset.bottom)
                 overlap = max(0, overlap - automaticBottom)
             }
-            if abs(scroll.contentInset.bottom - overlap) > 0.5 { scroll.contentInset.bottom = overlap }
-            if abs(scroll.verticalScrollIndicatorInsets.bottom - overlap) > 0.5 { scroll.verticalScrollIndicatorInsets.bottom = overlap }
+            // Its own inset is what is being measured, not part of the answer.
+            scroll.keyboardCover = overlap
+        }
+    }
+
+    /// The compact tab actions float over the trailing end of whatever
+    /// scrolls behind them. Each vertical scroll view and list they reach
+    /// into gets that much room at its end, so its last row can be brought
+    /// clear of them; one that ends above them gets none. How wide a scroll
+    /// view is does not come into it: a page of a pager that is off to one
+    /// side now is under the actions once it is swiped to. The safe area and
+    /// the viewport are left alone: content still scrolls behind the
+    /// actions.
+    ///
+    /// Two things are not behind the actions, and get none. A scroll view
+    /// that is not inside the shell the actions float in: a sheet is
+    /// presented in front of them, and its scroll view was given the room of
+    /// a capsule it covers, so every sheet could be dragged up into blank
+    /// space. And a scroll view or list inside another that scrolls the same
+    /// way: it is brought clear by the outer one, and where it sits in a page
+    /// not yet scrolled to it says nothing about the glass; a short list
+    /// below the fold was given the height of the page above it. Internal
+    /// for XCTest.
+    func insetScrollViewsForFloatingActions() {
+        let chrome = CraftChrome.shared
+        let host = chrome.floatingActionsHost.flatMap { view.isDescendant(of: $0) ? $0 : nil }
+        let actions = host == nil ? nil : chrome.floatingActions
+        func cover(_ scroll: UIScrollView) -> CGFloat {
+            guard let actions, let host, let window = scroll.window, scroll.isDescendant(of: host) else { return 0 }
+            let frame = scroll.convert(scroll.bounds, to: window)
+            // Nothing past the end of the shell is on the glass.
+            let end = min(frame.maxY, host.convert(host.bounds, to: window).maxY)
+            // An edge-to-edge scroller already clears the tab bar through
+            // UIKit's safe area. Add only what the actions reach above it.
+            let automaticBottom = max(0, scroll.adjustedContentInset.bottom - scroll.contentInset.bottom)
+            return max(0, end - actions.minY - automaticBottom)
+        }
+        func visit(_ node: RenderedNode?, inside: Bool) {
+            guard let node else { return }
+            var inside = inside
+            if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical {
+                scroll.floatingCover = inside ? 0 : cover(scroll)
+                inside = true
+            } else if let list = node.view as? CraftNativeFlatList {
+                list.floatingCover = inside ? 0 : cover(list)
+                if (list.collectionViewLayout as? UICollectionViewFlowLayout)?.scrollDirection != .horizontal { inside = true }
+            }
+            node.children.forEach { visit($0, inside: inside) }
+        }
+        visit(renderedRoot, inside: false)
+        floatingClearanceApplied = actions != nil
+    }
+
+    /// A layout moved a view, or the actions moved: measured again once the
+    /// pass is over, where each scroll view now ends.
+    fileprivate func scheduleFloatingClearance() {
+        guard CraftChrome.shared.floatingActions != nil || floatingClearanceApplied, !floatingClearanceScheduled else { return }
+        floatingClearanceScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.floatingClearanceScheduled = false
+            self.insetScrollViewsForFloatingActions()
         }
     }
 
@@ -9766,12 +9962,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         case "Text":
             let text = children.compactMap { $0 as? String }.joined()
             if let selectable = result as? CraftNativeSelectableTextView {
-                selectable.textContainer.maximumNumberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
+                selectable.textContainer.maximumNumberOfLines = max(0, craftNativeInt(number(props["numberOfLines"]) ?? 0))
                 selectable.textContainer.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
                 configureSelectableText(selectable, text: text, style: style)
             } else {
                 let label = result as! UILabel
-                label.numberOfLines = max(0, Int(number(props["numberOfLines"]) ?? 0))
+                label.numberOfLines = max(0, craftNativeInt(number(props["numberOfLines"]) ?? 0))
                 label.lineBreakMode = textLineBreakMode(props["ellipsizeMode"])
                 (label as? CraftNativeLabel)?.insets = paddingInsets(style)
                 configureText(label, text: text, style: style)
@@ -9830,6 +10026,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                         ? nil
                         : inputDrafts[current.identity] ?? props["defaultValue"] as? String
                 )
+                applyAutoFocus(props["autoFocus"], to: textView, node: current)
                 break
             }
             let field = result as! UITextField
@@ -9848,7 +10045,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             field.tintColor = color(props["selectionColor"])
             let fieldId = ObjectIdentifier(field)
             inputIdentities[fieldId] = current.identity
-            let maxLength = Int(number(props["maxLength"]) ?? 0)
+            let maxLength = craftNativeInt(number(props["maxLength"]) ?? 0)
             if maxLength > 0 {
                 textMaxLengths[fieldId] = maxLength
             } else {
@@ -9890,12 +10087,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             updateAuxiliaryHandler(events["onBlur"], in: &blurHandlers, for: field)
             updateAuxiliaryHandler(events["onEndEditing"], in: &endEditingHandlers, for: field)
             updateAuxiliaryHandler(events["onSubmitEditing"], in: &submitHandlers, for: field)
-            if props["autoFocus"] as? Bool == true, !field.isFirstResponder {
-                DispatchQueue.main.async { [weak self] in
-                    guard self?.isLeavingScreen == false else { return }
-                    _ = field.becomeFirstResponder()
-                }
-            }
+            applyAutoFocus(props["autoFocus"], to: field, node: current)
         case "SegmentedControl":
             let control = result as! CraftNativeSegmentedControl
             let items = props["items"] as? [[String: Any]] ?? []
@@ -9964,7 +10156,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 if picker.preferredDatePickerStyle != display { picker.preferredDatePickerStyle = display }
             }
             // UIKit takes an interval that divides an hour, and ignores others.
-            let interval = Int(number(props["minuteInterval"]) ?? 1)
+            let interval = craftNativeInt(number(props["minuteInterval"]) ?? 1)
             picker.minuteInterval = (1...30).contains(interval) && 60 % interval == 0 ? interval : 1
             picker.minimumDate = Self.pickerDate(props["minimumDate"])
             picker.maximumDate = Self.pickerDate(props["maximumDate"])
@@ -10010,7 +10202,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 modalFocusRestore[modalID] = focusBeforeContent
             }
             if visible, wasVisible != true { positionModals() }
-            modal.setVisible(visible, opacity: number(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
+            modal.setVisible(visible, opacity: styleNumber(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
             if !visible, wasVisible == true {
                 let restore = modalFocusRestore.removeValue(forKey: modalID)
                 DispatchQueue.main.async { [weak self, weak restore] in
@@ -10037,7 +10229,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let disabled = props["disabled"] as? Bool == true
             pressable.pressActiveOpacity = disabled
                 ? nil : number(props["activeOpacity"]) ?? 0.5
-            pressable.pressBaseOpacity = number(style["opacity"]) ?? 1
+            pressable.pressBaseOpacity = styleNumber(style["opacity"]) ?? 1
             pressable.pressUnderlayColor = type == "TouchableHighlight" && !disabled ? color(props["underlayColor"]) : nil
         case "Switch":
             if let toggle = result as? CraftNativeSolidSwitch {
@@ -10647,7 +10839,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         list.apply(
             nodes: children,
             horizontal: props["horizontal"] as? Bool == true,
-            columns: Int(number(props["numColumns"]) ?? 1),
+            columns: craftNativeInt(number(props["numColumns"]) ?? 1),
             inverted: props["inverted"] as? Bool == true,
             endReachedThreshold: threshold,
             renderItem: { [weak self] node, identity, reusable in
@@ -11180,13 +11372,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         // An input's own scrolling follows its height (CraftNativeTextView).
         if !(textView is CraftNativeTextView) { textView.isScrollEnabled = false }
-        let numberOfLines = Int(number(props["numberOfLines"]) ?? 0)
+        let numberOfLines = craftNativeInt(number(props["numberOfLines"]) ?? 0)
         if numberOfLines > 0 {
             textView.textContainer.maximumNumberOfLines = numberOfLines
         } else {
             textView.textContainer.maximumNumberOfLines = 0
         }
-        let maxLength = Int(number(props["maxLength"]) ?? 0)
+        let maxLength = craftNativeInt(number(props["maxLength"]) ?? 0)
         if maxLength > 0 {
             textMaxLengths[id] = maxLength
         } else {
@@ -11216,11 +11408,19 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         updateAuxiliaryHandler(events["onBlur"], in: &blurHandlers, for: textView)
         updateAuxiliaryHandler(events["onEndEditing"], in: &endEditingHandlers, for: textView)
         updateAuxiliaryHandler(events["onSubmitEditing"], in: &submitHandlers, for: textView)
-        if props["autoFocus"] as? Bool == true, !textView.isFirstResponder {
-            DispatchQueue.main.async { [weak self] in
-                guard self?.isLeavingScreen == false else { return }
-                _ = textView.becomeFirstResponder()
-            }
+    }
+
+    /// `autoFocus`: focus when the input mounts with it, or when it is turned
+    /// on later. Applied on every render it took the keyboard back each time
+    /// anything else on the screen changed (#511).
+    private func applyAutoFocus(_ value: Any?, to input: UIView, node: RenderedNode) {
+        let wanted = value as? Bool == true
+        let turnedOn = wanted && !node.autoFocus
+        node.autoFocus = wanted
+        guard turnedOn, !input.isFirstResponder else { return }
+        DispatchQueue.main.async { [weak self] in
+            guard self?.isLeavingScreen == false else { return }
+            _ = input.becomeFirstResponder()
         }
     }
 
@@ -11230,8 +11430,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// leaving a hole.
     private func configureIcon(_ icon: UIImageView, props: [String: Any], style: [String: Any]) {
         let name = (props["symbol"] as? String) ?? (props["name"] as? String) ?? ""
-        let box = [number(style["width"]), number(style["height"])].compactMap { $0 }.min()
-        let fontSize = number(style["fontSize"])
+        let box = [styleNumber(style["width"]), styleNumber(style["height"])].compactMap { $0 }.min()
+        let fontSize = styleNumber(style["fontSize"])
         // Without a size of its own an icon is a 20 pt square (contract A2).
         (icon as? CraftNativeIconView)?.defaultBox = box == nil && fontSize == nil ? 20 : nil
         let pointSize = fontSize ?? (box ?? 20) * 0.84
@@ -11272,10 +11472,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         stack.alignItems = style["alignItems"] as? String ?? "stretch"
         stack.alignContent = style["alignContent"] as? String ?? "flex-start"
         stack.justifyContent = style["justifyContent"] as? String ?? "flex-start"
-        let gap = max(0, number(style["gap"]) ?? 0)
+        let gap = max(0, styleNumber(style["gap"]) ?? 0)
         stack.gap = gap
-        stack.rowGap = max(0, number(style["rowGap"]) ?? gap)
-        stack.columnGap = max(0, number(style["columnGap"]) ?? gap)
+        stack.rowGap = max(0, styleNumber(style["rowGap"]) ?? gap)
+        stack.columnGap = max(0, styleNumber(style["columnGap"]) ?? gap)
         stack.grid = style["display"] as? String == "grid"
         stack.gridColumns = craftNativeGridColumnCount(style["gridTemplateColumns"] ?? style["gridColumns"])
         stack.gridRows = craftNativeGridRowCount(style["gridTemplateRows"])
@@ -11287,8 +11487,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func addJustificationSpacers(to stack: CraftNativeFlowView, value: String?) { }
 
     private func applyViewStyle(_ style: [String: Any], to view: UIView, node: RenderedNode) {
-        let width = style["minWidth"] == nil && style["maxWidth"] == nil ? number(style["width"]) : nil
-        let height = style["minHeight"] == nil && style["maxHeight"] == nil ? number(style["height"]) : nil
+        let width = style["minWidth"] == nil && style["maxWidth"] == nil ? styleNumber(style["width"]) : nil
+        let height = style["minHeight"] == nil && style["maxHeight"] == nil ? styleNumber(style["height"]) : nil
         updateDimension(width, constraint: &node.widthConstraint, anchor: view.widthAnchor)
         updateDimension(height, constraint: &node.heightConstraint, anchor: view.heightAnchor)
         view.backgroundColor = color(style["backgroundColor"]) ?? .clear
@@ -11307,31 +11507,31 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             direction: style["gradientDirection"] as? String,
             colors: [color(style["gradientFrom"]), color(style["gradientVia"]), color(style["gradientTo"])]
         )
-        view.alpha = number(style["opacity"]) ?? 1
+        view.alpha = styleNumber(style["opacity"]) ?? 1
         view.isHidden = style["display"] as? String == "none"
-        let borderRadius = number(style["borderRadius"]) ?? 0
+        let borderRadius = styleNumber(style["borderRadius"]) ?? 0
         let cornerRadiusKeys = ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"]
         let hasCornerRadii = cornerRadiusKeys.contains { style[$0] != nil }
         view.craftRequestedCornerRadius = borderRadius
         view.craftRequestedCornerRadii = hasCornerRadii
-            ? cornerRadiusKeys.map { number(style[$0]) ?? borderRadius }
+            ? cornerRadiusKeys.map { styleNumber(style[$0]) ?? borderRadius }
             : nil
-        let borderWidth = number(style["borderWidth"]) ?? 0
+        let borderWidth = styleNumber(style["borderWidth"]) ?? 0
         let borderColor = color(style["borderColor"]) ?? .clear
         let sideWidthKeys = ["borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"]
         let sideColorKeys = ["borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"]
         view.craftApplySideBorders(
             (sideWidthKeys + sideColorKeys).contains { style[$0] != nil },
             style: style["borderStyle"] as? String,
-            widths: sideWidthKeys.map { number(style[$0]) ?? borderWidth },
+            widths: sideWidthKeys.map { styleNumber(style[$0]) ?? borderWidth },
             colors: sideColorKeys.map { color(style[$0]) ?? borderColor }
         )
-        view.layer.zPosition = number(style["zIndex"]) ?? 0
+        view.layer.zPosition = styleNumber(style["zIndex"]) ?? 0
         applyTransform(style["transform"], to: view)
-        let elevation = max(0, number(style["elevation"]) ?? 0)
+        let elevation = max(0, styleNumber(style["elevation"]) ?? 0)
         let shadowColor = color(style["shadowColor"]) ?? .black
-        let shadowOpacity = min(1, max(0, number(style["shadowOpacity"]) ?? (elevation > 0 ? min(0.28, 0.12 + elevation * 0.02) : 0)))
-        let shadowRadius = max(0, number(style["shadowRadius"]) ?? elevation * 0.5)
+        let shadowOpacity = min(1, max(0, styleNumber(style["shadowOpacity"]) ?? (elevation > 0 ? min(0.28, 0.12 + elevation * 0.02) : 0)))
+        let shadowRadius = max(0, styleNumber(style["shadowRadius"]) ?? elevation * 0.5)
         let shadowOffset = style["shadowOffset"] as? [String: Any]
         view.layer.shadowColor = shadowColor.cgColor
         view.layer.shadowOpacity = Float(shadowOpacity)
@@ -11364,7 +11564,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     private func paddingInsets(_ style: [String: Any]) -> UIEdgeInsets {
         func nonNegative(_ value: Any?) -> CGFloat? {
-            guard let value = number(value), value >= 0 else { return nil }
+            guard let value = styleNumber(value), value >= 0 else { return nil }
             return value
         }
         let padding = nonNegative(style["padding"]) ?? 0
@@ -11387,11 +11587,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         var threeDimensional = CATransform3DIdentity
         var hasThreeDimensionalRotation = false
         for transform in transforms {
-            if let value = number(transform["translateX"]) { affine = affine.translatedBy(x: value, y: 0) }
-            if let value = number(transform["translateY"]) { affine = affine.translatedBy(x: 0, y: value) }
-            if let value = number(transform["scale"]) { affine = affine.scaledBy(x: value, y: value) }
-            if let value = number(transform["scaleX"]) { affine = affine.scaledBy(x: value, y: 1) }
-            if let value = number(transform["scaleY"]) { affine = affine.scaledBy(x: 1, y: value) }
+            if let value = styleNumber(transform["translateX"]) { affine = affine.translatedBy(x: value, y: 0) }
+            if let value = styleNumber(transform["translateY"]) { affine = affine.translatedBy(x: 0, y: value) }
+            if let value = styleNumber(transform["scale"]) { affine = affine.scaledBy(x: value, y: value) }
+            if let value = styleNumber(transform["scaleX"]) { affine = affine.scaledBy(x: value, y: 1) }
+            if let value = styleNumber(transform["scaleY"]) { affine = affine.scaledBy(x: 1, y: value) }
             if let value = transformAngle(transform["rotate"] ?? transform["rotateZ"]) { affine = affine.rotated(by: value) }
             if let value = transformAngle(transform["skewX"]) { affine = affine.concatenating(CGAffineTransform(a: 1, b: 0, c: tan(value), d: 1, tx: 0, ty: 0)) }
             if let value = transformAngle(transform["skewY"]) { affine = affine.concatenating(CGAffineTransform(a: 1, b: tan(value), c: 0, d: 1, tx: 0, ty: 0)) }
@@ -11429,10 +11629,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         label.font = textFont(style, default: .systemFont(ofSize: 16))
         label.textAlignment = textAlignment(style["textAlign"])
         var attributes: [NSAttributedString.Key: Any] = [:]
-        if let spacing = number(style["letterSpacing"]) { attributes[.kern] = spacing }
+        if let spacing = styleNumber(style["letterSpacing"]) { attributes[.kern] = spacing }
         addTextDecorationAttributes(style, to: &attributes)
         if let shadow = textShadow(style) { attributes[.shadow] = shadow }
-        if let lineHeight = number(style["lineHeight"]) {
+        if let lineHeight = styleNumber(style["lineHeight"]) {
             let paragraph = NSMutableParagraphStyle()
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
@@ -11486,8 +11686,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             .foregroundColor: color,
             .font: font,
         ]
-        if let spacing = number(style["letterSpacing"]) { attributes[.kern] = spacing }
-        if let lineHeight = number(style["lineHeight"]) {
+        if let spacing = styleNumber(style["letterSpacing"]) { attributes[.kern] = spacing }
+        if let lineHeight = styleNumber(style["lineHeight"]) {
             let paragraph = NSMutableParagraphStyle()
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
@@ -11509,14 +11709,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             .foregroundColor: color(style["color"]) ?? .label,
             .font: font,
         ]
-        if let spacing = number(style["letterSpacing"]) { attributes[.kern] = spacing }
+        if let spacing = styleNumber(style["letterSpacing"]) { attributes[.kern] = spacing }
         // UIKit otherwise resets the field's alignment to natural when these attributes are applied.
         let paragraph = NSMutableParagraphStyle()
         paragraph.alignment = alignment
         // The default paragraph wraps even inside a UITextField. A long URL
         // then paints a second line outside the field instead of scrolling.
         if singleLine { paragraph.lineBreakMode = .byClipping }
-        if let lineHeight = number(style["lineHeight"]) {
+        if let lineHeight = styleNumber(style["lineHeight"]) {
             paragraph.minimumLineHeight = lineHeight
             paragraph.maximumLineHeight = lineHeight
         }
@@ -11535,7 +11735,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             width: number(offset?["width"]) ?? 0,
             height: number(offset?["height"]) ?? 0
         )
-        shadow.shadowBlurRadius = max(0, number(style["textShadowRadius"]) ?? 0)
+        shadow.shadowBlurRadius = max(0, styleNumber(style["textShadowRadius"]) ?? 0)
         return shadow
     }
 
@@ -11574,7 +11774,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func textFont(_ style: [String: Any], default fallback: UIFont) -> UIFont {
-        let size = number(style["fontSize"]) ?? fallback.pointSize
+        let size = styleNumber(style["fontSize"]) ?? fallback.pointSize
         let weight: UIFont.Weight
         switch craftNativeFontWeight(style["fontWeight"]) {
         case "100": weight = .ultraLight