craft-native 0.0.499 → 0.0.500

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? {
@@ -2389,16 +2429,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 +2489,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 +2506,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 +2872,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 +2880,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 +3356,7 @@ private class CraftNativeFlowView: UIStackView {
             if moved {
                 craftScreenController?.scheduleLayoutEvents()
                 craftScreenController?.scheduleKeyboardInsets()
+                craftScreenController?.scheduleFloatingClearance()
             }
         }
         for (child, frame) in result.frames {
@@ -5001,7 +5044,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 +5160,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 +5581,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 +5766,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 +5808,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 +6913,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 +7075,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)`.
@@ -7396,6 +7459,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.
@@ -8816,6 +8880,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 +9031,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 +9048,51 @@ 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. Internal for XCTest.
+    func insetScrollViewsForFloatingActions() {
+        let chrome = CraftChrome.shared
+        let actions = chrome.floatingActions.flatMap { frame in
+            chrome.floatingActionsHost.flatMap { view.isDescendant(of: $0) ? frame : nil }
+        }
+        func cover(_ scroll: UIScrollView) -> CGFloat {
+            guard let actions, let window = scroll.window else { return 0 }
+            let frame = scroll.convert(scroll.bounds, to: window)
+            // 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, frame.maxY - actions.minY - automaticBottom)
+        }
+        func visit(_ node: RenderedNode?) {
+            guard let node else { return }
+            if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical { scroll.floatingCover = cover(scroll) }
+            else if let list = node.view as? CraftNativeFlatList { list.floatingCover = cover(list) }
+            node.children.forEach(visit)
+        }
+        visit(renderedRoot)
+        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 +9880,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 +9944,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 +9963,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 +10005,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 +10074,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 +10120,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 +10147,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 +10757,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 +11290,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 +11326,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 +11348,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 +11390,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 +11405,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 +11425,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 +11482,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 +11505,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 +11547,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 +11604,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 +11627,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 +11653,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 +11692,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/dist/ios/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/dist/ios/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