@craft-native/ios 0.0.499 → 0.0.502

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.499",
+  "version": "0.0.502",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/ios#readme",
   "repository": {
     "type": "git",

package/templates/CraftApp.swift

@@ -838,6 +838,23 @@ final class CraftChrome: ObservableObject {
     @Published var tabs: [Tab] = []
     @Published var tabAccessory: Tab?
     private weak var tabAccessoryOwner: AnyObject?
+
+    /// Where the compact tab actions float over the page, in window
+    /// coordinates, and the shell that drew them; nil when nothing floats.
+    /// They cover the trailing end of whatever scrolls behind them, so a
+    /// screen gives its scroll views that much room at the end (#523): the
+    /// last row can be brought clear without the app knowing this geometry.
+    private(set) var floatingActions: CGRect?
+    private(set) weak var floatingActionsHost: UIView?
+    static let floatingActionsDidMove = Notification.Name("CraftFloatingActionsDidMove")
+
+    func floatingActionsMoved(to frame: CGRect?, in host: UIView?) {
+        let next = frame.flatMap { $0.isNull || $0.isEmpty ? nil : $0.integral }
+        guard next != floatingActions || (next != nil && host !== floatingActionsHost) else { return }
+        floatingActions = next
+        floatingActionsHost = next == nil ? nil : host
+        NotificationCenter.default.post(name: Self.floatingActionsDidMove, object: self)
+    }
     @Published var selected: String?
     /// The visible destination may be the accessory, independently of its owning stack.
     @Published var visiblePath: String?

package/templates/CraftHybrid.swift

@@ -1665,6 +1665,8 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
     override func viewDidLayoutSubviews() {
         super.viewDidLayoutSubviews()
         guard hybrid.controller === self else { return }
+        // Once the actions are where this pass puts them.
+        defer { CraftChrome.shared.floatingActionsMoved(to: floatingActionsFrame(), in: view) }
 #if compiler(>=6.2)
         if #available(iOS 26.0, *), accessoryModel?.iconOnly != true {
             // UIKit already supplies the native safe area. This measurement is
@@ -1701,6 +1703,20 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         CraftChrome.shared.layoutChanged(tabBar.isHidden ? 0 : max(0, view.bounds.maxY - tabBar.frame.minY) + accessoryInset)
     }
 
+    /// The compact actions' frame in the window, or nil when none float over
+    /// the page: a full-width shelf is reserved for through the safe area,
+    /// and a hidden tab bar takes its actions with it. A group is its one
+    /// capsule; separate actions are the row of them.
+    private func floatingActionsFrame() -> CGRect? {
+        guard let model = accessoryModel, model.iconOnly, view.window != nil,
+              accessoryGlass.superview === view, !accessoryGlass.isHidden, !tabBar.isHidden else { return nil }
+        var frame = accessoryGlass.frame
+        if model.accessoryLayout == nil {
+            for glass in companionGlasses where !glass.isHidden { frame = frame.union(glass.frame) }
+        }
+        return view.convert(frame, to: view.window)
+    }
+
     /// One capsule above the trailing end of the tab bar, companions first
     /// and the primary action last. Nothing divides the actions: the glass
     /// is one control, and each action is found by its place and its symbol.

package/templates/CraftNativeFiles.swift

@@ -85,6 +85,84 @@ final class CraftNotificationAttachments {
 // memory. `fetch` and the share sheet take the path; only files made here are
 // read back for a form, so a screen cannot post an arbitrary file of the app's.
 
+/// A request waiting on a system picker, as the one picker slot sees it.
+protocol CraftPickerRequest: AnyObject {
+    /// Where its picker is.
+    var presence: CraftPickerPresence { get }
+    /// It has neither been answered by its picker nor finished.
+    var isWaiting: Bool { get }
+    /// The picker went without a choice or a cancel reaching its delegate.
+    /// One that was on screen answers as a cancel; one that never appeared
+    /// answers that it could not be presented.
+    func pickerLeft(shown: Bool)
+}
+
+extension CraftPickerRequest {
+    /// Still waiting on a picker that can no longer answer.
+    var lostItsPicker: Bool { isWaiting && presence.lost }
+}
+
+/// Where a request's picker is: on its way to the screen, on it, or gone.
+///
+/// UIKit tells a picker's delegate about a choice and about a cancel. It
+/// says nothing when the picker goes because what presented it did (an app
+/// closing the sheet the picker was on), or when it gives a presentation up
+/// before it began: a system picker runs in another process and is presented
+/// once that process answers, and by then the sheet it was to appear on may
+/// have closed ("whose view is not in the window hierarchy", in the console
+/// only). The request then never answered and kept the one picker slot:
+/// every later pick was refused as BUSY until the app was restarted.
+final class CraftPickerPresence {
+    weak var picker: UIViewController?
+    /// What the picker was handed to for presenting.
+    weak var presenter: UIViewController?
+    weak var watch: CraftPickerWatch?
+
+    /// The picker has been on screen.
+    var shown: Bool { watch?.shown ?? false }
+
+    /// The picker cannot answer any more.
+    var lost: Bool {
+        guard let picker else { return true }
+        if picker.presentingViewController != nil { return false }
+        // It was on screen, is not now, and nothing presents it.
+        if shown { return picker.viewIfLoaded?.window == nil }
+        // It has not appeared yet, and what was to present it has gone.
+        guard let presenter else { return true }
+        return presenter.viewIfLoaded?.window == nil
+    }
+}
+
+/// A view inside a system picker that says when the picker has been seen
+/// and when it is gone: it leaves the window when the picker does and is
+/// released when the picker is, whichever way that happens.
+final class CraftPickerWatch: UIView {
+    private(set) var shown = false
+    private var left: ((_ shown: Bool) -> Void)?
+
+    static func attach(to picker: UIViewController, left: @escaping (_ shown: Bool) -> Void) -> CraftPickerWatch {
+        let watch = CraftPickerWatch(frame: .zero)
+        watch.isHidden = true
+        watch.isUserInteractionEnabled = false
+        watch.left = left
+        picker.view.addSubview(watch)
+        return watch
+    }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil { shown = true } else if shown { report() }
+    }
+
+    deinit { report() }
+
+    private func report() {
+        guard let left else { return }
+        let shown = shown
+        DispatchQueue.main.async { left(shown) }
+    }
+}
+
 enum CraftNativeFiles {
     /// The longest side of a picked photo unless the screen asks otherwise:
     /// sharp on any phone screen and in a share card, a few hundred kilobytes
@@ -104,6 +182,40 @@ enum CraftNativeFiles {
     /// The picker on screen, kept alive until it answers. One at a time.
     private static var activePicker: NSObject?
 
+    /// The slot is free when nothing holds it, or when what holds it is
+    /// waiting on a picker that can no longer answer.
+    private static func pickerSlotIsFree() -> Bool {
+        guard let request = activePicker as? CraftPickerRequest else { return activePicker == nil }
+        guard request.lostItsPicker else { return false }
+        activePicker = nil
+        request.pickerLeft(shown: request.presence.shown)
+        return true
+    }
+
+    /// Follow `picker` for the request that is waiting on it.
+    private static func watch(_ picker: UIViewController, for request: CraftPickerRequest) {
+        let presence = request.presence
+        presence.picker = picker
+        presence.presenter = CraftPresenter.topViewController()
+        presence.watch = CraftPickerWatch.attach(to: picker) { [weak request] shown in request?.pickerLeft(shown: shown) }
+        awaitAppearance(of: request, checks: 60)
+    }
+
+    /// Until the picker is on screen nothing of its own can say it never
+    /// will be, and UIKit may hold a presentation it cannot make for as long
+    /// as the picker's process takes to answer. Look twice a second, for half
+    /// a minute at most, and answer for a picker whose presenter has gone.
+    private static func awaitAppearance(of request: CraftPickerRequest, checks: Int) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak request] in
+            guard let request, request.isWaiting, !request.presence.shown else { return }
+            if request.presence.lost {
+                request.pickerLeft(shown: false)
+            } else if checks > 1 {
+                awaitAppearance(of: request, checks: checks - 1)
+            }
+        }
+    }
+
     // MARK: Files of our own
 
     /// A new file called `name`, in a folder of its own so two files can share
@@ -208,7 +320,7 @@ enum CraftNativeFiles {
             .map { $0.doubleValue }
             .flatMap { $0.isFinite ? $0 : nil } ?? defaultQuality))
         let source = options["source"] as? String ?? "library"
-        guard activePicker == nil else {
+        guard pickerSlotIsFree() else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
@@ -245,6 +357,7 @@ enum CraftNativeFiles {
         picker.delegate = delegate
         delegate.controller = picker
         activePicker = delegate
+        watch(picker, for: delegate)
         if !CraftPresenter.present(picker, from: nil) {
             delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the photo picker")))
         }
@@ -291,7 +404,7 @@ enum CraftNativeFiles {
         return "\(base).jpg"
     }
 
-    final class LibraryDelegate: NSObject, PHPickerViewControllerDelegate {
+    final class LibraryDelegate: NSObject, PHPickerViewControllerDelegate, CraftPickerRequest {
         let maxPixels: Int
         let quality: Double
         let videoLimit: Int?
@@ -353,8 +466,18 @@ enum CraftNativeFiles {
             }
         }
 
+        let presence = CraftPickerPresence()
+        var isWaiting: Bool { !answered && !finished }
+
+        func pickerLeft(shown: Bool) {
+            guard lostItsPicker else { return }
+            answered = true
+            finish(shown ? .success(NSNull()) : .failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the \(videoLimit == nil ? "photo" : "video") picker")))
+        }
+
         func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
-            guard !answered else { return }
+            // A picker whose request was already answered still closes.
+            guard !answered else { picker.dismiss(animated: true); return }
             picker.dismiss(animated: true)
             guard let provider = results.first?.itemProvider else {
                 answered = true
@@ -403,12 +526,13 @@ enum CraftNativeFiles {
         picker.delegate = delegate
         delegate.controller = picker
         activePicker = delegate
+        watch(picker, for: delegate)
         if !CraftPresenter.present(picker, from: nil) {
             delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the camera")))
         }
     }
 
-    final class CameraDelegate: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+    final class CameraDelegate: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate, CraftPickerRequest {
         let maxPixels: Int
         let quality: Double
         let requestToken: String?
@@ -483,6 +607,15 @@ enum CraftNativeFiles {
             answered = true
             finish(.success(NSNull()))
         }
+
+        let presence = CraftPickerPresence()
+        var isWaiting: Bool { !answered && !finished }
+
+        func pickerLeft(shown: Bool) {
+            guard lostItsPicker else { return }
+            answered = true
+            finish(shown ? .success(NSNull()) : .failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the camera")))
+        }
     }
 
     #endif
@@ -493,7 +626,7 @@ enum CraftNativeFiles {
     /// the provider's URL is valid; no movie bytes cross JavaScriptCore.
     static func pickVideo(_ options: [String: Any], requestToken: String? = nil, isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         guard !isCancelled() else { done(.failure(importCancelled())); return }
-        guard activePicker == nil else {
+        guard pickerSlotIsFree() else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
@@ -512,6 +645,7 @@ enum CraftNativeFiles {
             picker.delegate = delegate
             delegate.controller = picker
             activePicker = delegate
+            watch(picker, for: delegate)
             if !CraftPresenter.present(picker, from: nil) {
                 delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
             }
@@ -525,6 +659,7 @@ enum CraftNativeFiles {
             picker.delegate = delegate
             delegate.controller = picker
             activePicker = delegate
+            watch(picker, for: delegate)
             if !CraftPresenter.present(picker, from: nil) {
                 delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
             }
@@ -538,7 +673,7 @@ enum CraftNativeFiles {
     /// UTIs, or filename extensions; an empty list means any document.
     static func pickFile(_ options: [String: Any], requestToken: String? = nil, isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         guard !isCancelled() else { done(.failure(importCancelled())); return }
-        guard activePicker == nil else {
+        guard pickerSlotIsFree() else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
@@ -567,6 +702,7 @@ enum CraftNativeFiles {
         picker.delegate = delegate
         delegate.controller = picker
         activePicker = delegate
+        watch(picker, for: delegate)
         if !CraftPresenter.present(picker, from: nil) {
             delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the file picker")))
         }
@@ -727,7 +863,7 @@ enum CraftNativeFiles {
         }
     }
 
-    final class DocumentDelegate: NSObject, UIDocumentPickerDelegate {
+    final class DocumentDelegate: NSObject, UIDocumentPickerDelegate, CraftPickerRequest {
         let limit: Int
         let video: Bool
         let requestToken: String?
@@ -768,6 +904,15 @@ enum CraftNativeFiles {
             finish(.success(video ? NSNull() : []))
         }
 
+        let presence = CraftPickerPresence()
+        var isWaiting: Bool { !answered && !finished }
+
+        func pickerLeft(shown: Bool) {
+            guard lostItsPicker else { return }
+            answered = true
+            finish(shown ? .success(video ? NSNull() : []) : .failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the \(video ? "video" : "file") picker")))
+        }
+
         func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
             guard !answered else { return }
             answered = true

package/templates/CraftNativeFlatList.swift

@@ -316,7 +316,8 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             rows += (pending + columns - 1) / columns
             content = CGFloat(rows) * 44 + CGFloat(max(0, rows - 1)) * flowLayout.minimumLineSpacing
         }
-        return max(0, ceil(content + contentInset.top + contentInset.bottom))
+        // Its rows and its own padding: not the room left for what floats over it.
+        return max(0, ceil(content + contentPadding.top + contentPadding.bottom))
     }
 
     /// The width a row gets: the list's own width inside its content padding,
@@ -406,6 +407,24 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             bottom: nonNegative(raw?["paddingBottom"]) ?? vertical,
             right: nonNegative(raw?["paddingRight"]) ?? horizontal
         )
+        guard contentPadding != inset else { return }
+        contentPadding = inset
+        applyContentInsets()
+    }
+
+    /// `contentContainerStyle`'s padding, which the list draws as its insets.
+    private var contentPadding: UIEdgeInsets = .zero
+
+    /// How far the compact tab actions reach over the end of this list. The
+    /// rows get that much more room at the end, so the last one can be
+    /// brought clear of them (#523).
+    var floatingCover: CGFloat = 0 {
+        didSet { if abs(oldValue - floatingCover) > 0.5 { applyContentInsets() } }
+    }
+
+    private func applyContentInsets() {
+        var inset = contentPadding
+        if flowLayout.scrollDirection == .vertical { inset.bottom += floatingCover }
         guard contentInset != inset else { return }
         contentInset = inset
         scrollIndicatorInsets = inset
@@ -507,11 +526,10 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         let oldItems = itemsByIdentity
         let viewportAnchor = currentViewportAnchor()
         var seen: [String: Int] = [:]
+        var taken = Set<String>()
         var next = nodes.enumerated().map { index, node -> Item in
             let base = Self.identity(for: node) ?? "index:\(index)"
-            let occurrence = seen[base, default: 0]
-            seen[base] = occurrence + 1
-            let identity = occurrence == 0 ? base : "\(base)#\(occurrence)"
+            let identity = Self.uniqueIdentity(base, seen: &seen, taken: &taken)
             let props = node["props"] as? [String: Any] ?? [:]
             let role = props["listRole"] as? String
             let signature = (try? JSONSerialization.data(withJSONObject: node, options: [.sortedKeys])) ?? Data()
@@ -532,7 +550,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             return dataItemCount - 1
         }
         items = next
-        itemsByIdentity = Dictionary(uniqueKeysWithValues: next.map { ($0.identity, $0) })
+        itemsByIdentity = Dictionary(next.map { ($0.identity, $0) }, uniquingKeysWith: { first, _ in first })
 
         flowLayout.scrollDirection = horizontal ? .horizontal : .vertical
         alwaysBounceHorizontal = horizontal
@@ -680,7 +698,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         let lastDataOrdinal = dataOrdinals[lastVisible]
         guard lastDataOrdinal >= 0 else { return }
         let remaining = dataItemCount - lastDataOrdinal - 1
-        let thresholdItems = max(1, Int(ceil(Double(dataItemCount) * endReachedThreshold)))
+        let thresholdItems = max(1, craftNativeInt(ceil(Double(dataItemCount) * endReachedThreshold)))
         guard remaining <= thresholdItems else { return }
         let signature = dataContentSignature
         guard endReachedSignature != signature else { return }
@@ -864,6 +882,25 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         setContentOffset(clamped(offset), animated: false)
     }
 
+    /// A row's identity, its own in this list.
+    ///
+    /// Rows that share a key are told apart by a suffix: `run`, then `run#1`.
+    /// A row whose own key was `run#1` then had the identity of the second
+    /// `run`, and the list's table and its snapshot both trap on a repeated
+    /// identity: three tags keyed `run`, `run` and `run#1` ended the process.
+    /// The suffix counts on until the identity is one no row has taken. A
+    /// list with no such key has the identities it always had.
+    static func uniqueIdentity(_ base: String, seen: inout [String: Int], taken: inout Set<String>) -> String {
+        var occurrence = seen[base, default: 0]
+        var identity = occurrence == 0 ? base : "\(base)#\(occurrence)"
+        while !taken.insert(identity).inserted {
+            occurrence += 1
+            identity = "\(base)#\(occurrence)"
+        }
+        seen[base] = occurrence + 1
+        return identity
+    }
+
     private static func identity(for node: [String: Any]) -> String? {
         let props = node["props"] as? [String: Any] ?? [:]
         return [node["key"], props["key"], props["testID"], node["id"]]

package/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

package/templates/CraftScheduledWorkouts.swift

@@ -317,6 +317,13 @@ enum CraftWorkoutPlanBuilder {
         return double.isFinite ? double : nil
     }
 
+    /// A number as a whole one, toward zero, or nil when no `Int` holds it.
+    /// `Int(_:)` traps there, and these come from the caller: an `hour` of
+    /// `1e30` ended the process where it should have been refused (#510).
+    private static func whole(_ value: Any?) -> Int? {
+        number(value).flatMap { Int(exactly: $0.rounded(.towardZero)) }
+    }
+
     /// Two schedule dates as WorkoutKit compares them: the day and the time of day.
     static func sameMoment(_ a: DateComponents, _ b: DateComponents) -> Bool {
         a.year == b.year && a.month == b.month && a.day == b.day && (a.hour ?? 0) == (b.hour ?? 0) && (a.minute ?? 0) == (b.minute ?? 0)
@@ -328,8 +335,8 @@ enum CraftWorkoutPlanBuilder {
         let parts = text.split(separator: "-", omittingEmptySubsequences: false)
         guard parts.count == 3, parts[0].count == 4, parts[1].count == 2, parts[2].count == 2,
               let year = Int(parts[0]), let month = Int(parts[1]), let day = Int(parts[2]) else { return nil }
-        let hour = body["hour"] == nil || body["hour"] is NSNull ? 7 : number(body["hour"]).map { Int($0) }
-        let minute = body["minute"] == nil || body["minute"] is NSNull ? 0 : number(body["minute"]).map { Int($0) }
+        let hour = body["hour"] == nil || body["hour"] is NSNull ? 7 : whole(body["hour"])
+        let minute = body["minute"] == nil || body["minute"] is NSNull ? 0 : whole(body["minute"])
         guard let hour, let minute, (0...23).contains(hour), (0...59).contains(minute) else { return nil }
         var components = DateComponents()
         components.year = year
@@ -379,7 +386,7 @@ enum CraftWorkoutPlanBuilder {
         }
         func zone() -> Int? {
             guard let value = number(body["zone"]), value >= 1, value.rounded() == value else { return nil }
-            return Int(value)
+            return Int(exactly: value)
         }
         switch type {
         case "heartRate":
@@ -485,7 +492,7 @@ enum CraftWorkoutPlanBuilder {
         var blocks: [IntervalBlock] = []
         for (blockIndex, value) in (workout["blocks"] as? [Any] ?? []).enumerated() {
             let block = value as? [String: Any] ?? [:]
-            let iterations = number(block["iterations"] ?? 1).map { Int($0) } ?? 0
+            let iterations = whole(block["iterations"] ?? 1) ?? 0
             guard iterations >= 1 else { return refuse("block \(blockIndex + 1) needs iterations of 1 or more") }
             var steps: [IntervalStep] = []
             for (stepIndex, entry) in (block["steps"] as? [Any] ?? []).enumerated() {

package/templates/CraftWebAudio.swift

@@ -503,6 +503,25 @@ final class CraftAudioBufferSource: CraftAudioSource {
     private var played = 0.0
     private var began = false
 
+    /// An arbitrary limit on the rate, and WebKit's: `MaxRate` in its
+    /// AudioBufferSourceNode.
+    static let maximumRate = 1024.0
+
+    /// The rate a buffer plays at: its own sample rate over the context's,
+    /// times `playbackRate`, times two to the power of `detune` in octaves.
+    ///
+    /// Neither param is bounded for a buffer source, so the product can be
+    /// infinite (a detune of 2,000,000 cents) or not a number (that, with a
+    /// playbackRate of 0). A looping source wrapped an infinite position into
+    /// one that is not a number, and `Int(position)` traps on it: the render
+    /// thread ended the process. WebKit clamps the rate to its limit either
+    /// side of zero and plays a rate that is not a number at 1; so does this.
+    static func rate(ratio: Double, playbackRate: Double, detune: Double) -> Double {
+        let rate = ratio * playbackRate * pow(2, detune / 1200)
+        guard !rate.isNaN else { return 1 }
+        return max(-maximumRate, min(maximumRate, rate))
+    }
+
     override init(id: Int) {
         super.init(id: id)
         params = [playbackRate, detune]
@@ -530,7 +549,7 @@ final class CraftAudioBufferSource: CraftAudioSource {
                 position = loopFrom + (position - loopFrom).truncatingRemainder(dividingBy: span)
             }
         }
-        let rate = buffer.sampleRate / render.sampleRate * Double(playbackRate.values[0]) * pow(2, Double(detune.values[0]) / 1200)
+        let rate = Self.rate(ratio: buffer.sampleRate / render.sampleRate, playbackRate: Double(playbackRate.values[0]), detune: Double(detune.values[0]))
         let first = buffer.channels[0]
         let second = buffer.channels.count > 1 ? buffer.channels[1] : first
         let frames = buffer.length