craft-native 0.0.175 → 0.0.177

package/dist/ios/templates/CraftNativeScreen.swift

@@ -12,6 +12,15 @@ import UIKit
 
 private let craftNativeCapabilityTimeoutMilliseconds = 30_000
 
+/// 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.
+private func number(_ value: Any?) -> CGFloat? {
+    guard let number = value as? NSNumber else { return nil }
+    let value = CGFloat(truncating: number)
+    return value.isFinite ? value : nil
+}
+
 private func craftNativeGridColumnCount(_ value: Any?) -> Int {
     if let number = value as? NSNumber { return max(1, number.intValue) }
     guard let text = value as? String else { return 1 }
@@ -81,6 +90,178 @@ private func craftNativeJustifyCode(_ value: String) -> UInt32 {
     }
 }
 
+/// Optional bridge to the host-neutral tree layout ABI. The host still owns
+/// intrinsic measurement and keeps its local implementation for unsupported
+/// trees or runtimes built before this symbol was exported.
+private enum CraftNativeTreeLayoutBridge {
+    private struct StyleInput {
+        var direction: UInt32 = 0
+        var width: Float = .nan
+        var height: Float = .nan
+        var intrinsicWidth: Float = .nan
+        var intrinsicHeight: Float = .nan
+        var baseline: Float = .nan
+        var aspectRatio: Float = .nan
+        var flexBasis: Float = .nan
+        var flexGrow: Float = 0
+        var flexShrink: Float = 0
+        var minWidth: Float = .nan
+        var maxWidth: Float = .nan
+        var minHeight: Float = .nan
+        var maxHeight: Float = .nan
+        var gap: Float = 0
+        var justifyContent: UInt32 = 0
+        var alignItems: UInt32 = 3
+        var alignSelf: UInt32 = 0
+        var flexWrap: UInt32 = 0
+        var alignContent: UInt32 = 6
+        var marginTop: Float = 0
+        var marginRight: Float = 0
+        var marginBottom: Float = 0
+        var marginLeft: Float = 0
+        var paddingTop: Float = 0
+        var paddingRight: Float = 0
+        var paddingBottom: Float = 0
+        var paddingLeft: Float = 0
+        var grid: UInt32 = 0
+        var gridColumns: UInt32 = 1
+        var rowGap: Float = 0
+        var columnGap: Float = 0
+    }
+
+    private struct NodeInput {
+        var style: StyleInput
+        var firstChild: UInt32
+        var childCount: UInt32
+    }
+
+    private struct Frame {
+        var x: Float
+        var y: Float
+        var width: Float
+        var height: Float
+    }
+
+    private typealias Function = @convention(c) (
+        Float, Float, UnsafeRawPointer, Int, UnsafeMutableRawPointer, Int
+    ) -> Int32
+
+    private static let function: Function? = {
+        guard let symbol = dlsym(UnsafeMutableRawPointer(bitPattern: -2), "craft_native_layout_tree") else { return nil }
+        return unsafeBitCast(symbol, to: Function.self)
+    }()
+
+    private static func finite(_ value: CGFloat?) -> Float {
+        guard let value, value.isFinite else { return .nan }
+        return Float(value)
+    }
+
+    private static func length(_ value: CraftNativeLength?, base: CGFloat?) -> Float {
+        guard let value else { return .nan }
+        return finite(value.resolve(base))
+    }
+
+    private static func alignment(_ value: String?) -> UInt32 {
+        switch value {
+        case "center": return 1
+        case "flex-end": return 2
+        case "stretch": return 3
+        case "baseline": return 4
+        default: return 0
+        }
+    }
+
+    private static func alignSelf(_ value: String?) -> UInt32 {
+        switch value {
+        case "flex-start": return 1
+        case "center": return 2
+        case "flex-end": return 3
+        case "stretch": return 4
+        case "baseline": return 5
+        default: return 0
+        }
+    }
+
+    private static func justify(_ value: String) -> UInt32 {
+        craftNativeJustifyCode(value)
+    }
+
+    static func frames(
+        width: CGFloat,
+        height: CGFloat,
+        direction: NSLayoutConstraint.Axis,
+        gap: CGFloat,
+        rowGap: CGFloat?,
+        columnGap: CGFloat?,
+        wrap: Bool,
+        justifyContent: String,
+        alignItems: String,
+        padding: UIEdgeInsets,
+        children: [(UIView, CraftNativeLayoutStyle, CGSize, CGFloat)]
+    ) -> [(UIView, CGRect)]? {
+        guard let function, width.isFinite, height.isFinite, width >= 0, height >= 0, !children.isEmpty else { return nil }
+        let mainGap = direction == .horizontal ? (columnGap ?? gap) : (rowGap ?? gap)
+        let crossGap = direction == .horizontal ? (rowGap ?? gap) : (columnGap ?? gap)
+        var root = StyleInput(
+            direction: direction == .horizontal ? 0 : 1,
+            width: Float(width), height: Float(height), gap: Float(max(0, mainGap)),
+            justifyContent: justify(justifyContent), alignItems: alignment(alignItems), flexWrap: wrap ? 1 : 0,
+            paddingTop: Float(max(0, padding.top)), paddingRight: Float(max(0, padding.right)),
+            paddingBottom: Float(max(0, padding.bottom)), paddingLeft: Float(max(0, padding.left))
+        )
+        root.rowGap = Float(max(0, rowGap ?? 0))
+        root.columnGap = Float(max(0, columnGap ?? 0))
+        let contentWidth = max(0, width - padding.left - padding.right)
+        let contentHeight = max(0, height - padding.top - padding.bottom)
+        let mainSize = direction == .horizontal ? contentWidth : contentHeight
+        var nodes = [NodeInput(style: root, firstChild: 1, childCount: UInt32(children.count))]
+        for (view, style, intrinsic, baseline) in children {
+            let shrink: CGFloat
+            if let authored = style.flexShrink {
+                shrink = authored
+            } else if view is UIScrollView {
+                shrink = 1
+            } else if view is UILabel, direction == .horizontal {
+                shrink = 1
+            } else {
+                shrink = 0
+            }
+            var input = StyleInput(
+                width: length(style.width, base: contentWidth), height: length(style.height, base: contentHeight),
+                intrinsicWidth: Float(max(0, intrinsic.width)), intrinsicHeight: Float(max(0, intrinsic.height)),
+                baseline: Float(max(0, baseline)), aspectRatio: finite(style.aspectRatio),
+                flexBasis: length(style.flexBasis, base: mainSize), flexGrow: Float(max(0, style.flexGrow)), flexShrink: Float(max(0, shrink)),
+                minWidth: length(style.minWidth, base: contentWidth), maxWidth: length(style.maxWidth, base: contentWidth),
+                minHeight: length(style.minHeight, base: contentHeight), maxHeight: length(style.maxHeight, base: contentHeight),
+                alignSelf: alignSelf(style.alignSelf),
+                marginTop: Float(max(0, style.marginTop)), marginRight: Float(max(0, style.marginRight)),
+                marginBottom: Float(max(0, style.marginBottom)), marginLeft: Float(max(0, style.marginLeft))
+            )
+            input.direction = 0
+            nodes.append(NodeInput(style: input, firstChild: 0, childCount: 0))
+        }
+        var output = [Frame](repeating: Frame(x: 0, y: 0, width: 0, height: 0), count: nodes.count)
+        let frameCount = output.count
+        let status = nodes.withUnsafeBufferPointer { nodeBuffer in
+            output.withUnsafeMutableBufferPointer { frameBuffer in
+                function(
+                    Float(width), Float(height), UnsafeRawPointer(nodeBuffer.baseAddress!), nodes.count,
+                    UnsafeMutableRawPointer(frameBuffer.baseAddress!), frameCount
+                )
+            }
+        }
+        guard status == 0 else { return nil }
+        let childFrames = output.dropFirst()
+        guard childFrames.allSatisfy({ frame in
+            frame.x.isFinite && frame.y.isFinite && frame.width.isFinite && frame.height.isFinite &&
+                frame.width >= 0 && frame.height >= 0
+        }) else { return nil }
+        return zip(children, childFrames).map { child, frame in
+            (child.0, CGRect(x: CGFloat(frame.x), y: CGFloat(frame.y), width: CGFloat(frame.width), height: CGFloat(frame.height)))
+        }
+    }
+}
+
 private enum CraftNativeFlexLineBridge {
     private struct Item {
         var basis: Float
@@ -430,6 +611,7 @@ private final class CraftNativeVideoView: UIView {
 private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var annotationsByID: [String: MKPointAnnotation] = [:]
     private var overlaysByID: [String: MKPolyline] = [:]
+    private var overlayCoordinatesByID: [String: [CLLocationCoordinate2D]] = [:]
     private var overlayColors: [ObjectIdentifier: UIColor] = [:]
     private var overlayWidths: [ObjectIdentifier: CGFloat] = [:]
     private(set) var markerHandlers: [String: String] = [:]
@@ -479,7 +661,10 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
                 }
             } else if type == "mappolyline" || type == "polyline" {
                 guard points.count > 1 else { continue }
-                nextPolylines[id] = (points, Self.color(childProps["strokeColor"] as? String), CGFloat((childProps["strokeWidth"] as? NSNumber)?.doubleValue ?? 3))
+                let authoredWidth = (childProps["strokeWidth"] as? NSNumber)?.doubleValue ?? 3
+                let width = CGFloat(authoredWidth)
+                guard authoredWidth.isFinite, width.isFinite, width > 0 else { continue }
+                nextPolylines[id] = (points, Self.color(childProps["strokeColor"] as? String), width)
             }
         }
 
@@ -499,13 +684,31 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         }
         markerHandlers = nextHandlers
 
-        removeOverlays(Array(overlaysByID.values))
-        overlaysByID.removeAll(keepingCapacity: true)
-        overlayColors.removeAll(keepingCapacity: true)
-        overlayWidths.removeAll(keepingCapacity: true)
+        let staleOverlays = overlaysByID.keys.filter { nextPolylines[$0] == nil }
+        for id in staleOverlays {
+            if let overlay = overlaysByID.removeValue(forKey: id) {
+                removeOverlay(overlay)
+                overlayColors.removeValue(forKey: ObjectIdentifier(overlay))
+                overlayWidths.removeValue(forKey: ObjectIdentifier(overlay))
+            }
+            overlayCoordinatesByID.removeValue(forKey: id)
+        }
         for (id, value) in nextPolylines {
+            if let overlay = overlaysByID[id],
+               let coordinates = overlayCoordinatesByID[id],
+               Self.coordinatesEqual(coordinates, value.coordinates),
+               overlayColors[ObjectIdentifier(overlay)]?.isEqual(value.color) == true,
+               overlayWidths[ObjectIdentifier(overlay)] == value.width {
+                continue
+            }
+            if let previous = overlaysByID.removeValue(forKey: id) {
+                removeOverlay(previous)
+                overlayColors.removeValue(forKey: ObjectIdentifier(previous))
+                overlayWidths.removeValue(forKey: ObjectIdentifier(previous))
+            }
             let overlay = MKPolyline(coordinates: value.coordinates, count: value.coordinates.count)
             overlaysByID[id] = overlay
+            overlayCoordinatesByID[id] = value.coordinates
             overlayColors[ObjectIdentifier(overlay)] = value.color
             overlayWidths[ObjectIdentifier(overlay)] = value.width
             addOverlay(overlay)
@@ -557,8 +760,19 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         let numbers = (value as? [Any])?.compactMap { ($0 as? NSNumber)?.doubleValue }
             ?? (value as? [NSNumber])?.map(\.doubleValue)
             ?? []
-        return stride(from: 0, to: numbers.count - 1, by: 2).map {
-            CLLocationCoordinate2D(latitude: numbers[$0], longitude: numbers[$0 + 1])
+        return stride(from: 0, to: numbers.count - 1, by: 2).compactMap {
+            let latitude = numbers[$0]
+            let longitude = numbers[$0 + 1]
+            guard latitude.isFinite, longitude.isFinite,
+                  (-90...90).contains(latitude), (-180...180).contains(longitude) else { return nil }
+            return CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+        }
+    }
+
+    private static func coordinatesEqual(_ lhs: [CLLocationCoordinate2D], _ rhs: [CLLocationCoordinate2D]) -> Bool {
+        guard lhs.count == rhs.count else { return false }
+        return zip(lhs, rhs).allSatisfy { left, right in
+            left.latitude == right.latitude && left.longitude == right.longitude
         }
     }
 
@@ -569,7 +783,11 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
               let latitude = (center["latitude"] as? NSNumber)?.doubleValue,
               let longitude = (center["longitude"] as? NSNumber)?.doubleValue,
               let latitudeDelta = (span["latitudeDelta"] as? NSNumber)?.doubleValue ?? (span["latitude_delta"] as? NSNumber)?.doubleValue,
-              let longitudeDelta = (span["longitudeDelta"] as? NSNumber)?.doubleValue ?? (span["longitude_delta"] as? NSNumber)?.doubleValue else { return nil }
+              let longitudeDelta = (span["longitudeDelta"] as? NSNumber)?.doubleValue ?? (span["longitude_delta"] as? NSNumber)?.doubleValue,
+              latitude.isFinite, longitude.isFinite, latitudeDelta.isFinite, longitudeDelta.isFinite,
+              (-90...90).contains(latitude), (-180...180).contains(longitude),
+              latitudeDelta > 0, latitudeDelta <= 180, longitudeDelta > 0, longitudeDelta <= 360,
+              latitude - latitudeDelta / 2 >= -90, latitude + latitudeDelta / 2 <= 90 else { return nil }
         return MKCoordinateRegion(center: CLLocationCoordinate2D(latitude: latitude, longitude: longitude), span: MKCoordinateSpan(latitudeDelta: latitudeDelta, longitudeDelta: longitudeDelta))
     }
 
@@ -631,15 +849,17 @@ private enum CraftNativeLength: Equatable {
 
     init?(_ value: Any?) {
         if let number = value as? NSNumber {
-            self = .points(CGFloat(truncating: number))
+            let points = CGFloat(truncating: number)
+            guard points.isFinite else { return nil }
+            self = .points(points)
             return
         }
         guard let text = (value as? String)?.trimmingCharacters(in: .whitespaces), !text.isEmpty else { return nil }
-        if text.hasSuffix("%"), let fraction = Double(text.dropLast()) {
+        if text.hasSuffix("%"), let fraction = Double(text.dropLast()), fraction.isFinite {
             self = .percent(CGFloat(fraction) / 100)
-        } else if text.hasSuffix("px"), let points = Double(text.dropLast(2)) {
+        } else if text.hasSuffix("px"), let points = Double(text.dropLast(2)), points.isFinite {
             self = .points(CGFloat(points))
-        } else if let points = Double(text) {
+        } else if let points = Double(text), points.isFinite {
             self = .points(CGFloat(points))
         } else {
             return nil
@@ -648,7 +868,7 @@ private enum CraftNativeLength: Equatable {
 
     func resolve(_ base: CGFloat?) -> CGFloat? {
         switch self {
-        case .points(let value): return value
+        case .points(let value): return max(0, value)
         case .percent(let fraction): return base.map { max(0, $0 * fraction) }
         }
     }
@@ -685,7 +905,11 @@ private struct CraftNativeLayoutStyle {
     static let empty = CraftNativeLayoutStyle([:])
 
     init(_ raw: [String: Any]) {
-        func number(_ value: Any?) -> CGFloat? { (value as? NSNumber).map { CGFloat(truncating: $0) } }
+        func number(_ value: Any?) -> CGFloat? {
+            guard let number = value as? NSNumber else { return nil }
+            let value = CGFloat(truncating: number)
+            return value.isFinite ? value : nil
+        }
         width = CraftNativeLength(raw["width"])
         height = CraftNativeLength(raw["height"])
         let ratio = number(raw["aspectRatio"])
@@ -942,6 +1166,18 @@ enum CraftNativeFlexLayout {
 /// grid. It is a UIStackView in name only, so existing callers and tests keep
 /// `axis`, `alignment` and `arrangedSubviews`; the stack view's own
 /// constraints are never created, and every frame comes from `layout`.
+extension UIView {
+    /// The native screen this view is drawn on, through the responder chain.
+    var craftScreenController: CraftNativeScreenController? {
+        var responder: UIResponder? = next
+        while let current = responder {
+            if let screen = current as? CraftNativeScreenController { return screen }
+            responder = current.next
+        }
+        return nil
+    }
+}
+
 private class CraftNativeFlowView: UIStackView {
     var pressActiveOpacity: CGFloat?
     var pressBaseOpacity: CGFloat = 1
@@ -987,6 +1223,13 @@ private class CraftNativeFlowView: UIStackView {
 
     private var flowChildren: [UIView] = []
     private var measurements: [MeasureKey: CGSize] = [:]
+    /// The screen's rendered root gets a definite viewport from the host. A
+    /// root with `flex: 1` must keep that height even when its first child is
+    /// a ScrollView whose content is taller than the screen; otherwise an
+    /// absolute sibling is positioned against the scroll content and moves
+    /// with it.
+    private weak var viewportChild: UIView?
+    private var viewportChildFillsHeight = false
 
     private struct MeasureKey: Hashable {
         let width: CGFloat?
@@ -1088,6 +1331,12 @@ private class CraftNativeFlowView: UIStackView {
         invalidateMeasurements()
     }
 
+    func setViewportChild(_ view: UIView?, fillsHeight: Bool) {
+        viewportChild = view
+        viewportChildFillsHeight = fillsHeight
+        invalidateMeasurements()
+    }
+
     func removeLayoutStyle(for view: UIView) {
         view.craftLayoutStyle = .empty
     }
@@ -1121,8 +1370,20 @@ private class CraftNativeFlowView: UIStackView {
         craftApplyCornerRadius()
         let scale = window?.screen.scale ?? traitCollection.displayScale
         let result = layout(width: bounds.width, height: bounds.height, maxWidth: bounds.width, maxHeight: bounds.height, place: true)
+        var moved = false
+        defer {
+            // The screen reports onLayout from its own layout pass, which a
+            // change deep in a scroll view's content never runs: a view that
+            // went from 240 to 180 wide kept saying 240.
+            if moved { craftScreenController?.scheduleLayoutEvents() }
+        }
         for (child, frame) in result.frames {
-            var snapped = CraftNativeFlexLayout.snapped(frame, scale: scale)
+            var viewportFrame = frame
+            if child === viewportChild, viewportChildFillsHeight {
+                viewportFrame.origin.y = 0
+                viewportFrame.size.height = bounds.height
+            }
+            var snapped = CraftNativeFlexLayout.snapped(viewportFrame, scale: scale)
             // Snapping each edge can take a pixel off a label (15.83…33.83
             // becomes 16…33.67), and a label a pixel narrower than its text
             // truncates it ("13" drew as "…"). Text keeps its whole size.
@@ -1130,14 +1391,14 @@ private class CraftNativeFlowView: UIStackView {
                 snapped.size = CraftNativeFlexLayout.ceiled(frame.size, scale: scale, atLeast: snapped.size)
             }
             if child.transform.isIdentity {
-                if child.frame != snapped { child.frame = snapped }
+                if child.frame != snapped { child.frame = snapped; moved = true }
             } else {
                 // A transformed child (a sticky header, a scaled spinner) is
                 // placed by bounds and center: its frame is undefined then.
                 let size = CGRect(origin: child.bounds.origin, size: snapped.size)
                 let center = CGPoint(x: snapped.midX, y: snapped.midY)
-                if child.bounds != size { child.bounds = size }
-                if child.center != center { child.center = center }
+                if child.bounds != size { child.bounds = size; moved = true }
+                if child.center != center { child.center = center; moved = true }
             }
             child.craftApplyCornerRadius()
         }
@@ -1205,6 +1466,29 @@ private class CraftNativeFlowView: UIStackView {
     /// outer size when its parent fixes it, nil when it sizes to its content
     /// within `maxWidth`/`maxHeight`. Returns its outer size and, when
     /// placing, every child's frame in its own coordinates.
+    private func sharedDirectFrames(_ children: [UIView], width: CGFloat?, height: CGFloat?) -> [(UIView, CGRect)]? {
+        guard let width, let height, !grid, !reverse, !wrapReverse,
+              width.isFinite, height.isFinite, width >= 0, height >= 0,
+              children.allSatisfy({ child in
+                  let style = child.craftLayoutStyle
+                  return style.position != "absolute" && style.display != "none"
+              }) else { return nil }
+
+        let intrinsic = children.map { child in
+            CraftNativeFlexLayout.measure(child, width: nil, height: nil, maxWidth: width, maxHeight: height)
+        }
+        let baselines = children.enumerated().map { index, child in
+            CraftNativeFlowView.firstBaseline(child, cross: intrinsic[index].height)
+        }
+        let payload = zip(children, zip(intrinsic, baselines)).map { child, measured in
+            (child, child.craftLayoutStyle, measured.0, measured.1)
+        }
+        return CraftNativeTreeLayoutBridge.frames(
+            width: width, height: height, direction: axis, gap: gap, rowGap: rowGap, columnGap: columnGap, wrap: wrap,
+            justifyContent: justifyContent, alignItems: alignItems, padding: effectivePadding, children: payload
+        )
+    }
+
     private func layout(
         width: CGFloat?,
         height: CGFloat?,
@@ -1239,6 +1523,9 @@ private class CraftNativeFlowView: UIStackView {
                 frames: &frames
             )
         }
+        if place, flow.count == children.count, let shared = sharedDirectFrames(flow, width: width, height: height) {
+            frames = shared
+        }
         let size = CGSize(width: width ?? contentSize.width + paddingWidth, height: height ?? contentSize.height + paddingHeight)
 
         if place {
@@ -1286,6 +1573,7 @@ private class CraftNativeFlowView: UIStackView {
         place: Bool,
         frames: inout [(UIView, CGRect)]
     ) -> CGSize {
+        let contentPadding = effectivePadding
         let definiteMain = horizontal ? innerWidth : innerHeight
         let definiteCross = horizontal ? innerHeight : innerWidth
         let roomMain = horizontal ? roomWidth : roomHeight
@@ -1647,6 +1935,7 @@ private class CraftNativeFlowView: UIStackView {
         place: Bool,
         frames: inout [(UIView, CGRect)]
     ) -> CGSize {
+        let contentPadding = effectivePadding
         let columns = max(1, gridColumns)
         let horizontalGap = columnGap ?? gap
         let verticalGap = rowGap ?? gap
@@ -1670,7 +1959,7 @@ private class CraftNativeFlowView: UIStackView {
             let available = max(0, cellWidth - style.marginLeft - style.marginRight)
             let align = style.alignSelf ?? alignItems
             var fixedWidth = style.width?.resolve(cellWidth)
-            var fixedHeight = style.height?.resolve(nil)
+            var fixedHeight = style.height?.resolve(innerHeight)
             // A cell's item is as wide as its column unless it sets a width
             // (or an aspect ratio derives one from its height), whatever its
             // height: a fixed-height swatch with no content was drawn 0 wide.
@@ -1704,7 +1993,7 @@ private class CraftNativeFlowView: UIStackView {
                 let size = sizes[index]
                 let alignment: UInt32 = align == "center" ? 1 : align == "flex-end" ? 2 : 0
                 var explicitWidth = style.width?.resolve(cellWidth)
-                var explicitHeight = style.height?.resolve(nil)
+                var explicitHeight = style.height?.resolve(innerHeight)
                 if explicitWidth == nil && align == "stretch" && (explicitHeight == nil || style.aspectRatio == nil) {
                     explicitWidth = max(0, cellWidth - style.marginLeft - style.marginRight)
                 }
@@ -1713,7 +2002,7 @@ private class CraftNativeFlowView: UIStackView {
                     size.width, size.height,
                     explicitWidth, explicitHeight,
                     style.minWidth?.resolve(cellWidth), style.maxWidth?.resolve(cellWidth),
-                    style.minHeight?.resolve(nil), style.maxHeight?.resolve(nil),
+                    style.minHeight?.resolve(innerHeight), style.maxHeight?.resolve(innerHeight),
                     style.marginLeft, style.marginRight, style.marginTop, style.marginBottom,
                     align == "stretch", alignment
                 )
@@ -1822,7 +2111,7 @@ private final class CraftNativeKeyboardAvoidingView: CraftNativeFlowView {
     func configureKeyboard(props: [String: Any]) {
         let requestedBehavior = (props["behavior"] as? String) ?? "padding"
         keyboardBehavior = ["height", "position", "padding"].contains(requestedBehavior) ? requestedBehavior : "padding"
-        keyboardVerticalOffset = (props["keyboardVerticalOffset"] as? NSNumber).map { CGFloat(truncating: $0) } ?? 0
+        keyboardVerticalOffset = number(props["keyboardVerticalOffset"]) ?? 0
         if keyboardBehavior != "height" { appliedHeightInset = 0 }
         authoredPadding = padding
         applyKeyboardAvoidance()
@@ -1922,6 +2211,10 @@ private final class CraftNativeModalView: UIView {
 
     required init?(coder: NSCoder) { nil }
 
+    /// Whether the modal takes touches is its own to say: shown, it takes
+    /// every one (the scrim and its controls); the screen's press and long
+    /// press bookkeeping once turned that off for a view with no handler of
+    /// its own, and a shown modal let every tap through to the screen behind.
     func setVisible(_ visible: Bool, opacity: CGFloat, animationType: String?) {
         if visible { isUserInteractionEnabled = true }
         if renderedVisible == visible && isHidden == !visible {
@@ -2003,7 +2296,27 @@ private final class CraftNativeModalView: UIView {
     override func layoutSubviews() {
         super.layoutSubviews()
         blocker.frame = bounds
-        contentStack.frame = bounds
+        // The scrim covers the whole screen; what the modal holds stays
+        // clear of the bars and the home indicator it is drawn over.
+        contentStack.frame = bounds.inset(by: UIEdgeInsets(top: contentInsets.top, left: 0, bottom: contentInsets.bottom, right: 0))
+    }
+
+    /// Where the screen's own content starts and ends: the scrim covers the
+    /// whole screen, what the modal holds stays clear of the bars.
+    var contentInsets: UIEdgeInsets = .zero {
+        didSet { if contentInsets != oldValue { setNeedsLayout() } }
+    }
+}
+
+/// The delegate of a Pressable's press-in/out feedback. That recognizer is
+/// a long press of no duration, so it begins the moment a finger lands; on its
+/// own it would claim the touch, and the tap that is the Pressable's onPress
+/// failed whenever onPressIn or onPressOut were set too. It only watches.
+final class CraftPressFeedbackDelegate: NSObject, UIGestureRecognizerDelegate {
+    static let shared = CraftPressFeedbackDelegate()
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        true
     }
 }
 
@@ -2275,14 +2588,24 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
 
     @objc private func keyboardTap() {
         guard keyboardShouldPersistTaps != "always" else { return }
-        if keyboardShouldPersistTaps == "handled" {
-            let point = keyboardTapGesture.location(in: self)
-            var hit = hitTest(point, with: nil)
-            while let view = hit, view !== self {
-                if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { return }
-                hit = view.superview
-            }
-        }
+        let point = keyboardTapGesture.location(in: self)
+        var hit = hitTest(point, with: nil)
+        var onControl = false
+        var onButton = false
+        while let view = hit, view !== self {
+            if view is UIButton { onButton = true }
+            if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { onControl = true; break }
+            hit = view.superview
+        }
+        if keyboardShouldPersistTaps == "handled", onControl { return }
+        // A button keeps the keyboard: its press gives the focus straight
+        // back. Ending editing first only let the keyboard's inset go while
+        // the finger was down, the button moved out from under it, and the
+        // press was lost.
+        if onButton { return }
+        // Otherwise the keyboard goes; after a tap on nothing, for good (the
+        // next render must not bring the last input back).
+        if !onControl { craftScreenController?.forgetFocusedInput() }
         window?.endEditing(true)
     }
 
@@ -2323,7 +2646,7 @@ private final class CraftNativeSvgView: UIView {
         let props = drawing["props"] as? [String: Any] ?? [:]
         guard let box = props["viewBox"] as? [Any], box.count == 4 else { return nil }
         let n = box.compactMap { ($0 as? NSNumber).map { CGFloat(truncating: $0) } }
-        guard n.count == 4, n[2] > 0, n[3] > 0 else { return nil }
+        guard n.count == 4, n.allSatisfy(\.isFinite), n[2] > 0, n[3] > 0 else { return nil }
         return CGRect(x: n[0], y: n[1], width: n[2], height: n[3])
     }
 
@@ -2344,21 +2667,29 @@ private final class CraftNativeSvgView: UIView {
         var linecap: String?
         var linejoin: String?
         var dashes: [CGFloat]?
+        var vectorEffect: String?
 
         func merged(_ node: [String: Any]) -> Paint {
             var next = self
             let props = node["props"] as? [String: Any] ?? [:]
             let style = node["style"] as? [String: Any] ?? [:]
+            func value(_ key: String) -> Any? { style[key] ?? props[key] }
+            func finite(_ raw: Any?) -> CGFloat? {
+                guard let number = raw as? NSNumber else { return nil }
+                let value = CGFloat(truncating: number)
+                return value.isFinite ? value : nil
+            }
             if let color = style["color"] as? String { next.color = color }
             if let fill = style["fill"] as? String ?? props["fill"] as? String { next.fill = fill }
             if let stroke = style["stroke"] as? String ?? props["stroke"] as? String { next.stroke = stroke }
-            if let width = (style["strokeWidth"] as? NSNumber ?? props["strokeWidth"] as? NSNumber) { next.strokeWidth = CGFloat(truncating: width) }
+            if let width = finite(style["strokeWidth"] ?? props["strokeWidth"]) { next.strokeWidth = width }
             // Computed style wins over the component prop, matching Android
             // and the browser's cascade when both provide opacity.
-            if let opacity = style["opacity"] as? NSNumber ?? props["opacity"] as? NSNumber { next.opacity *= CGFloat(truncating: opacity) }
-            if let cap = props["strokeLinecap"] as? String { next.linecap = cap }
-            if let join = props["strokeLinejoin"] as? String { next.linejoin = join }
-            if let dashes = props["strokeDasharray"] as? [Any] { next.dashes = dashes.compactMap { ($0 as? NSNumber).map { CGFloat(truncating: $0) } } }
+            if let opacity = finite(style["opacity"] ?? props["opacity"]) { next.opacity *= opacity }
+            if let cap = value("strokeLinecap") as? String { next.linecap = cap }
+            if let join = value("strokeLinejoin") as? String { next.linejoin = join }
+            if let dashes = value("strokeDasharray") as? [Any] { next.dashes = dashes.compactMap(finite).filter { $0 >= 0 } }
+            if let vectorEffect = value("vectorEffect") as? String { next.vectorEffect = vectorEffect }
             return next
         }
 
@@ -2425,7 +2756,7 @@ private final class CraftNativeSvgView: UIView {
                     // `vector-effect="non-scaling-stroke"`: the stroke is in the
                     // view's points, so a stretched chart's line keeps its width
                     // and a round cap stays a round dot.
-                    let nonScaling = (shape["props"] as? [String: Any])?["vectorEffect"] as? String == "non-scaling-stroke"
+                    let nonScaling = own.vectorEffect == "non-scaling-stroke"
                     let line: UIBezierPath
                     if nonScaling, let copy = path.copy() as? UIBezierPath {
                         copy.apply(viewTransform)
@@ -2452,14 +2783,14 @@ private 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 = CGFloat(truncating: props["fontSize"] as? NSNumber ?? style["fontSize"] as? NSNumber ?? 12)
+        let size = number(props["fontSize"]) ?? number(style["fontSize"]) ?? 12
         let weight: UIFont.Weight = (props["fontWeight"] as? String ?? style["fontWeight"] as? String).map { ["500": .medium, "600": .semibold, "700": .bold, "bold": .bold][$0] ?? .regular } ?? .regular
         let string = NSAttributedString(string: text, attributes: [
             .font: UIFont.systemFont(ofSize: size, weight: weight),
             .foregroundColor: paint.resolve(paint.fill) ?? UIColor.label,
         ])
-        var x = CGFloat(truncating: props["x"] as? NSNumber ?? 0)
-        let y = CGFloat(truncating: props["y"] as? NSNumber ?? 0)
+        var x = number(props["x"]) ?? 0
+        let y = number(props["y"]) ?? 0
         switch props["textAnchor"] as? String {
         case "middle": x -= string.size().width / 2
         case "end": x -= string.size().width
@@ -2472,7 +2803,7 @@ private final class CraftNativeSvgView: UIView {
     static func path(_ value: Any?) -> UIBezierPath? {
         guard let list = value as? [Any] else { return nil }
         let n = list.compactMap { ($0 as? NSNumber).map { CGFloat(truncating: $0) } }
-        guard !n.isEmpty, n.count == list.count else { return nil }
+        guard !n.isEmpty, n.count == list.count, n.allSatisfy(\.isFinite) else { return nil }
         let path = UIBezierPath()
         var i = 0
         func point(_ at: Int) -> CGPoint { CGPoint(x: n[at], y: n[at + 1]) }
@@ -2778,6 +3109,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var linkTargets: [ObjectIdentifier: String] = [:]
     private var renderedRoot: RenderedNode?
     private weak var lastFocusedInput: UIView?
+
+    /// The person put the keyboard away (Return, or a tap on nothing in a
+    /// scroll view): the last input is let go. Kept, the next render or
+    /// button press focused it again and the keyboard came straight back.
+    func forgetFocusedInput(_ input: UIView? = nil) {
+        if input == nil || lastFocusedInput === input { lastFocusedInput = nil }
+    }
     private var flatListRows: [ObjectIdentifier: [String: RenderedNode]] = [:]
     private var flatListOwners: [String: String] = [:]
     /// A drawing's shapes are not views: a change to one redraws its `Svg`.
@@ -2909,6 +3247,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     override func viewDidAppear(_ animated: Bool) {
         super.viewDidAppear(animated)
         screenVisibilityChanged(true)
+        // A navigation breadcrumb for the crash reporter: the trail a crash
+        // report carries is the screens that led to it.
+        if !isAppScript, let routeName, !routeName.isEmpty {
+            CraftCrashReporter.shared.screenAppeared(routeName)
+        }
+        // onLayout reports views that are on screen: a pushed screen lays
+        // out before it has a window, and nothing moved again once it had
+        // one, so its rows never reported.
+        emitLayoutEvents()
     }
 
     override func viewDidDisappear(_ animated: Bool) {
@@ -2983,9 +3330,29 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     override func viewDidLayoutSubviews() {
         super.viewDidLayoutSubviews()
+        positionModals()
         emitLayoutEvents()
     }
 
+    /// Modals cover the screen; their content starts below its bars (the
+    /// status bar is all the safe area counts on a native screen, and a
+    /// modal's first control sat under the navigation bar).
+    private func positionModals() {
+        let modals = view.subviews.compactMap { $0 as? CraftNativeModalView }
+        guard !modals.isEmpty else { return }
+        var insets = view.safeAreaInsets
+        // The navigation bar floats over the screen without counting in its
+        // safe area, and it is drawn above anything the screen adds.
+        if let nav = navigationController, !nav.isNavigationBarHidden, nav.navigationBar.window != nil {
+            let bar = nav.navigationBar.convert(nav.navigationBar.bounds, to: view)
+            if bar.intersects(view.bounds) { insets.top = max(insets.top, bar.maxY) }
+        }
+        for modal in modals {
+            if modal.frame != view.bounds { modal.frame = view.bounds }
+            modal.contentInsets = insets
+        }
+    }
+
     private static func safeJavaScriptString(_ value: JSValue?) -> String? {
         guard let value, !value.isUndefined, !value.isNull, value.isString else { return nil }
         return value.toString()
@@ -3004,7 +3371,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 ?? Self.safeJavaScriptString(exception)
                 ?? "unknown"
             let stack = Self.safeJavaScriptString(exception?.objectForKeyedSubscript("stack")) ?? ""
-            CraftNativeConsole.write("error", category: self?.screenName(in: context) ?? "screen", message: stack.isEmpty || stack == "undefined" ? "Uncaught \(message)" : "Uncaught \(message)\n\(stack)")
+            let screen = self?.screenName(in: context) ?? "screen"
+            CraftNativeConsole.write("error", category: screen, message: stack.isEmpty || stack == "undefined" ? "Uncaught \(message)" : "Uncaught \(message)\n\(stack)")
+            // To the app's crash reporter too (bughq, when configured): an
+            // uncaught error in a shipped screen is otherwise only in a log
+            // nobody reads on someone else's phone.
+            CraftCrashReporter.shared.captureJavaScript(
+                name: Self.safeJavaScriptString(exception?.objectForKeyedSubscript("name")),
+                message: message,
+                stack: stack,
+                route: screen,
+                isAppScript: self?.isAppScript ?? false
+            )
             self?.hybridFailed(message)
         }
         let postMessage: @convention(block) (String) -> Void = { [weak self] json in
@@ -4175,6 +4553,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             guard let target = drawnTarget(id) else { return false }
             guard applied.insert(target).inserted else { continue }
             guard let document = mutationDocument.node(target), let previous = renderedNode(target) else { return false }
+            // A node that needs a new view (a TextInput turned multiline) is
+            // its parent's to swap in: a targeted update only redraws in
+            // place, and the new view was made and never attached.
+            guard canReuseView(document, previous: previous) else { return false }
             let next = reconcile(document, identity: previous.identity, path: target, previous: previous)
             // A style patch is applied in place, layout included: the parent
             // reads the node's new layout style on its next pass.
@@ -4232,6 +4614,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         var rootStyle = next.style
         if rootStyle["flex"] == nil, rootStyle["height"] == nil { rootStyle["flex"] = 1 }
         rootStack.setLayoutStyle(rootStyle, for: next.view)
+        rootStack.setViewportChild(next.view, fillsHeight: rootStyle["height"] == nil)
         rootStack.invalidateMeasurements()
         renderedRoot = next
         rootIsSafeAreaView = next.type == "SafeAreaView"
@@ -4246,6 +4629,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         if let root = renderedRoot { detach(root, from: rootStack) }
         renderedRoot = nil
         rootIsSafeAreaView = false
+        rootStack.setViewportChild(nil, fillsHeight: false)
         rootTopToSafeArea?.isActive = true
         rootTopToView?.isActive = false
         rootBottomToSafeArea?.isActive = true
@@ -4268,6 +4652,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         return nil
     }
 
+    /// Whether `previous`'s view can draw `node`: the same type, and for a
+    /// TextInput the same kind of field (multiline is a UITextView).
+    private func canReuseView(_ node: [String: Any], previous: RenderedNode) -> Bool {
+        let type = canonicalType(node["type"] as? String ?? "View")
+        guard previous.type == type else { return false }
+        guard type == "TextInput" else { return true }
+        let props = node["props"] as? [String: Any] ?? [:]
+        return (previous.view is UITextView) == (props["multiline"] as? Bool == true)
+    }
+
     private func restoreFocus(_ focused: UIView?) {
         guard let focused, focused.window != nil, !focused.isFirstResponder else { return }
         _ = focused.becomeFirstResponder()
@@ -4280,9 +4674,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let events = node["events"] as? [String: String] ?? [:]
         let children = node["children"] as? [Any] ?? []
         let current: RenderedNode
-        let wantsMultilineTextView = type == "TextInput" && props["multiline"] as? Bool == true
-        let canReuseInput = type != "TextInput" || ((previous?.view is UITextView) == wantsMultilineTextView)
-        if let previous = previous, previous.identity == identity, previous.type == type, canReuseInput {
+        if let previous = previous, previous.identity == identity, canReuseView(node, previous: previous) {
             current = previous
         } else {
             current = RenderedNode(identity: identity, type: type, view: makeView(type, props: props))
@@ -4500,6 +4892,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let modalID = ObjectIdentifier(modal)
             let wasVisible = modalVisibility[modalID]
             modalVisibility[modalID] = visible
+            if visible, wasVisible != true { positionModals() }
             modal.setVisible(visible, opacity: number(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
             modal.onRequestClose = nonEmptyHandler(events["onRequestClose"]).map { handler in
                 { [weak self] in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": [:]]) }
@@ -4537,10 +4930,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             updateHandler(nonEmptyHandler(events["onValueChange"]) ?? nonEmptyHandler(events["onChange"]), for: toggle)
         case "Slider":
             let slider = result as! UISlider
-            slider.minimumValue = (props["minimumValue"] as? NSNumber)?.floatValue ?? 0
-            slider.maximumValue = max(slider.minimumValue + .leastNonzeroMagnitude, (props["maximumValue"] as? NSNumber)?.floatValue ?? 1)
-            let value = (props["value"] as? NSNumber)?.floatValue ?? slider.minimumValue
-            if let step = (props["step"] as? NSNumber)?.floatValue, step > 0 { sliderSteps[ObjectIdentifier(slider)] = step }
+            let minimum = (props["minimumValue"] as? NSNumber)?.floatValue ?? 0
+            slider.minimumValue = minimum.isFinite ? minimum : 0
+            let maximum = (props["maximumValue"] as? NSNumber)?.floatValue ?? 1
+            slider.maximumValue = max(slider.minimumValue + .leastNonzeroMagnitude, maximum.isFinite ? maximum : 1)
+            let authoredValue = (props["value"] as? NSNumber)?.floatValue ?? slider.minimumValue
+            let value = authoredValue.isFinite ? authoredValue : slider.minimumValue
+            if let step = (props["step"] as? NSNumber)?.floatValue, step.isFinite, step > 0 { sliderSteps[ObjectIdentifier(slider)] = step }
             else { sliderSteps.removeValue(forKey: ObjectIdentifier(slider)) }
             slider.value = snappedSliderValue(value, for: slider)
             slider.minimumTrackTintColor = color(props["minimumTrackTintColor"])
@@ -4555,7 +4951,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             indicator.style = (requestedSize as? String) == "large" ? .large : .medium
             let scale: CGFloat
             if let numericSize = requestedSize as? NSNumber {
-                scale = max(0.5, CGFloat(numericSize.doubleValue / 20.0))
+                let value = CGFloat(numericSize.doubleValue / 20.0)
+                scale = value.isFinite ? max(0.5, value) : 1
             } else if (requestedSize as? String) == "small" {
                 scale = 0.75
             } else {
@@ -4811,6 +5208,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         case "checkbox": return "Checkbox"
         case "textinput", "input": return "TextInput"
         case "picker", "select": return "Picker"
+        case "datepicker", "date-picker", "date": return "DatePicker"
         case "modal": return "Modal"
         case "switch": return "Switch"
         case "slider": return "Slider"
@@ -4898,14 +5296,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         for child in next where child.type == "Modal" {
             guard let modal = child.view as? CraftNativeModalView else { continue }
-            if modal.superview !== stack {
+            // A modal covers the screen, wherever it is declared. Laid over
+            // its parent instead, one declared in a scroll view covered the
+            // whole content: its controls sat wherever the content had
+            // scrolled to, under the bar or off screen, out of reach.
+            if modal.superview !== view {
                 modal.removeFromSuperview()
-                stack.addSubview(modal)
+                view.addSubview(modal)
             }
-            modal.frame = stack.bounds
             modal.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-            stack.bringSubviewToFront(modal)
+            view.bringSubviewToFront(modal)
         }
+        positionModals()
         parent.children = next
         addJustificationSpacers(to: stack, value: style["justifyContent"] as? String)
     }
@@ -4950,14 +5352,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             { [weak self] scrollView in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": self?.scrollEvent(scrollView) ?? [:]]) }
         }
 
+        let threshold = max(
+            0,
+            Double(number(props["onEndReachedThreshold"]) ?? number(props["threshold"]) ?? 0.1)
+        )
         list.apply(
             nodes: children,
             horizontal: props["horizontal"] as? Bool == true,
             columns: (props["numColumns"] as? NSNumber)?.intValue ?? 1,
             inverted: props["inverted"] as? Bool == true,
-            endReachedThreshold: (props["onEndReachedThreshold"] as? NSNumber)?.doubleValue
-                ?? (props["threshold"] as? NSNumber)?.doubleValue
-                ?? 0.1,
+            endReachedThreshold: threshold,
             renderItem: { [weak self] node, identity, _ in
                 guard let self = self else { return UIView() }
                 let previous = self.flatListRows[listKey]?[identity]
@@ -5023,7 +5427,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         if node.view is CraftNativeSvgView, let owner = node.protocolId { svgOwners = svgOwners.filter { $0.value != owner } }
         let id = ObjectIdentifier(node.view)
-        if let modal = node.view as? CraftNativeModalView { modal.resetForTeardown() }
+        if let modal = node.view as? CraftNativeModalView {
+            modal.resetForTeardown()
+            // It sits on the screen, not in its parent: leaving with the
+            // parent's subtree does not take it away.
+            modal.removeFromSuperview()
+        }
         handlers.removeValue(forKey: id)
         linkTargets.removeValue(forKey: id)
         pressInHandlers.removeValue(forKey: id)
@@ -5098,9 +5507,23 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         emitLayoutEvents(for: renderedRoot)
     }
 
+    private var layoutEventsScheduled = false
+
+    /// A view inside the screen moved: report onLayout once the pass that
+    /// moved it is over, however deep it was.
+    fileprivate func scheduleLayoutEvents() {
+        guard !layoutEventsScheduled, !layoutHandlers.isEmpty else { return }
+        layoutEventsScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.layoutEventsScheduled = false
+            self.emitLayoutEvents()
+        }
+    }
+
     private func emitLayoutEvents(for node: RenderedNode) {
         let id = ObjectIdentifier(node.view)
-        if let handler = layoutHandlers[id], node.view.window != nil {
+        if let handler = layoutHandlers[id], isEffectivelyVisible(node.view) {
             let frame = node.view.frame
             if lastLayoutFrames[id] != frame {
                 lastLayoutFrames[id] = frame
@@ -5121,6 +5544,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
     }
 
+    private func isEffectivelyVisible(_ view: UIView) -> Bool {
+        guard view.window != nil, !view.isHidden else { return false }
+        var ancestor = view.superview
+        while let current = ancestor {
+            if current.isHidden { return false }
+            ancestor = current.superview
+        }
+        return true
+    }
+
     private func updateAuxiliaryHandler(
         _ handler: String?,
         in handlers: inout [ObjectIdentifier: String],
@@ -5150,7 +5583,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         // A container keeps receiving touches without a handler of its own,
         // or every control inside it (and the screen root) would be dead.
-        if !(view is UIScrollView) { view.isUserInteractionEnabled = actionable || longPressHandlers[id] != nil || view is CraftNativeFlowView }
+        if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = actionable || longPressHandlers[id] != nil || view is CraftNativeFlowView }
     }
 
     private func updatePressFeedback(_ pressIn: String?, _ pressOut: String?, for view: UIView) {
@@ -5159,7 +5592,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         if let pressOut, !pressOut.isEmpty { pressOutHandlers[id] = pressOut } else { pressOutHandlers.removeValue(forKey: id) }
         guard pressInHandlers[id] != nil || pressOutHandlers[id] != nil else {
             if let recognizer = pressFeedbackRecognizers.removeValue(forKey: id) { view.removeGestureRecognizer(recognizer) }
-            if !(view is UIScrollView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || longPressHandlers[id] != nil || view is CraftNativeFlowView }
+            if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || longPressHandlers[id] != nil || view is CraftNativeFlowView }
             return
         }
         if pressFeedbackRecognizers[id] == nil {
@@ -5167,17 +5600,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             recognizer.minimumPressDuration = 0
             recognizer.allowableMovement = 10
             recognizer.cancelsTouchesInView = false
+            recognizer.delegate = CraftPressFeedbackDelegate.shared
             pressFeedbackRecognizers[id] = recognizer
             view.addGestureRecognizer(recognizer)
         }
-        if !(view is UIScrollView) { view.isUserInteractionEnabled = true }
+        if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = true }
     }
 
     private func updateLongPressHandler(_ handler: String?, for view: UIView) {
         let id = ObjectIdentifier(view)
         if let handler, !handler.isEmpty {
             longPressHandlers[id] = handler
-            if !(view is UIScrollView) { view.isUserInteractionEnabled = true }
+            if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = true }
             if longPressRecognizers[id] == nil {
                 let recognizer = UILongPressGestureRecognizer(target: self, action: #selector(viewLongPressed(_:)))
                 longPressRecognizers[id] = recognizer
@@ -5188,7 +5622,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if let recognizer = longPressRecognizers.removeValue(forKey: id) {
                 view.removeGestureRecognizer(recognizer)
             }
-            if !(view is UIScrollView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || view is CraftNativeFlowView }
+            if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || view is CraftNativeFlowView }
         }
     }
 
@@ -5327,10 +5761,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 = number(style["gap"]) ?? 0
+        let gap = max(0, number(style["gap"]) ?? 0)
         stack.gap = gap
-        stack.rowGap = number(style["rowGap"]) ?? gap
-        stack.columnGap = number(style["columnGap"]) ?? gap
+        stack.rowGap = max(0, number(style["rowGap"]) ?? gap)
+        stack.columnGap = max(0, number(style["columnGap"]) ?? gap)
         stack.grid = style["display"] as? String == "grid"
         stack.gridColumns = craftNativeGridColumnCount(style["gridTemplateColumns"] ?? style["gridColumns"])
         stack.gridAutoRows = CraftNativeLength(style["gridAutoRows"])
@@ -5405,14 +5839,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func paddingInsets(_ style: [String: Any]) -> UIEdgeInsets {
-        let padding = number(style["padding"]) ?? 0
-        let horizontal = number(style["paddingHorizontal"]) ?? padding
-        let vertical = number(style["paddingVertical"]) ?? padding
+        func nonNegative(_ value: Any?) -> CGFloat? {
+            guard let value = number(value), value >= 0 else { return nil }
+            return value
+        }
+        let padding = nonNegative(style["padding"]) ?? 0
+        let horizontal = nonNegative(style["paddingHorizontal"]) ?? padding
+        let vertical = nonNegative(style["paddingVertical"]) ?? padding
         return UIEdgeInsets(
-            top: number(style["paddingTop"]) ?? vertical,
-            left: number(style["paddingLeft"]) ?? horizontal,
-            bottom: number(style["paddingBottom"]) ?? vertical,
-            right: number(style["paddingRight"]) ?? horizontal
+            top: nonNegative(style["paddingTop"]) ?? vertical,
+            left: nonNegative(style["paddingLeft"]) ?? horizontal,
+            bottom: nonNegative(style["paddingBottom"]) ?? vertical,
+            right: nonNegative(style["paddingRight"]) ?? horizontal
         )
     }
 
@@ -5672,6 +6110,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         imageSources[id] = uri
         imageErrors.removeValue(forKey: id)
         view.image = immediateImage(defaultSource).map { imageForDisplay($0, view: view) }
+        imageDidChange(view)
         view.accessibilityValue = nil
         emitImageEvent(view, handler: imageLoadStartHandlers[id])
 
@@ -5683,6 +6122,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 return
             }
             view.image = imageForDisplay(image, view: view)
+            imageDidChange(view)
             emitImageEvent(view, handler: imageLoadHandlers[id])
             emitImageEvent(view, handler: imageLoadEndHandlers[id])
             return
@@ -5698,6 +6138,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                         return
                     }
                     view.image = self.imageForDisplay(image, view: view)
+                    self.imageDidChange(view)
                     self.emitImageEvent(view, handler: self.imageLoadHandlers[ObjectIdentifier(view)])
                     self.emitImageEvent(view, handler: self.imageLoadEndHandlers[ObjectIdentifier(view)])
                 }
@@ -5712,6 +6153,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 return
             }
             view.image = imageForDisplay(image, view: view)
+            imageDidChange(view)
             emitImageEvent(view, handler: imageLoadHandlers[id])
             emitImageEvent(view, handler: imageLoadEndHandlers[id])
             return
@@ -5736,6 +6178,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func imageFailure(_ view: UIImageView, uri: String?, message: String) {
         imageErrors[ObjectIdentifier(view)] = message
         view.image = nil
+        imageDidChange(view)
         view.accessibilityValue = message
         let id = ObjectIdentifier(view)
         emitImageEvent(view, handler: imageErrorHandlers[id], nativeEvent: ["error": ["message": message]])
@@ -5743,6 +6186,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         NSLog("[craft native] %@: %@", message, uri ?? "<missing>")
     }
 
+    private func imageDidChange(_ view: UIImageView) {
+        view.invalidateIntrinsicContentSize()
+        CraftNativeFlexLayout.invalidateAncestors(of: view)
+    }
+
     private func imageForDisplay(_ image: UIImage, view: UIImageView) -> UIImage {
         image.withRenderingMode(tintedImages.contains(ObjectIdentifier(view)) ? .alwaysTemplate : .alwaysOriginal)
     }
@@ -5766,7 +6214,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             view.accessibilityValue = nil
         }
         let role = props["accessibilityRole"] as? String
-        view.isAccessibilityElement = role != "none" && (view.accessibilityLabel != nil || role != nil || ["Text", "Button", "Link", "Checkbox", "Image", "ImageBackground", "Video", "TextInput", "Picker", "Switch", "Slider"].contains(type))
+        view.isAccessibilityElement = role != "none" && (view.accessibilityLabel != nil || role != nil || ["Text", "Button", "Link", "Checkbox", "Image", "ImageBackground", "Video", "TextInput", "Picker", "DatePicker", "Switch", "Slider"].contains(type))
         var traits: UIAccessibilityTraits = []
         switch role ?? type.lowercased() {
         case "button", "checkbox": traits.insert(.button)
@@ -5789,6 +6237,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if state["checked"] as? Bool == true { traits.insert(.selected) }
         }
         if let control = view as? UIControl, !control.isEnabled { traits.insert(.notEnabled) }
+        // A disabled Pressable or touchable takes no touches; it says so too.
+        if props["disabled"] as? Bool == true { traits.insert(.notEnabled) }
         if type == "Checkbox", let checkbox = view as? CraftNativeCheckboxButton {
             if checkbox.isSelected { traits.insert(.selected) }
             view.accessibilityValue = checkbox.indeterminate ? "mixed" : checkbox.isSelected ? "checked" : "unchecked"
@@ -5939,13 +6389,23 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let value = snappedSliderValue(sender.value, for: sender)
         if sender.value != value { sender.value = value }
         guard let handler = handlers[ObjectIdentifier(sender)] else { return }
-        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(value)]])
+        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(value, step: sliderSteps[ObjectIdentifier(sender)])]])
     }
 
-    /// A slider's value as the script reads it: the shortest decimal that is
-    /// the same Float, so a step of 0.1 gives 0.8 and not 0.800000011920929.
-    static func sliderEventValue(_ value: Float) -> Double {
-        Double(value.description) ?? Double(value)
+    /// A slider's value as the script reads it. UISlider keeps a Float, and a
+    /// step of 0.1 counted up in Floats lands beside the decimal (0.8 read as
+    /// 0.800000011920929, nine steps as 0.90000004), so the value is the
+    /// shortest decimal for that Float, rounded to as many places as the step
+    /// has.
+    static func sliderEventValue(_ value: Float, step: Float? = nil) -> Double {
+        let decimal = Double(value.description) ?? Double(value)
+        guard let step, step > 0, step.isFinite else { return decimal }
+        // "0.1" is one place, "0.25" two, "1.0" none; a step as small as
+        // "1e-07" is held to six.
+        let fraction = step.description.split(separator: ".").dropFirst().first
+        let places = step.description.contains("e") ? 6 : min(6, fraction.map { $0 == "0" ? 0 : $0.count } ?? 0)
+        let scale = pow(10, Double(places))
+        return (decimal * scale).rounded() / scale
     }
 
     /// `@change` on a DatePicker: the value as `<input type="date|time|
@@ -6000,7 +6460,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// Countdown values use seconds when numeric, or `HH:mm[:ss]` text.
     static func countdownDuration(_ value: Any?) -> TimeInterval? {
         let maximum: TimeInterval = 23 * 3600 + 59 * 60 + 59
-        if let number = value as? NSNumber, !(value is Bool) { return min(maximum, max(0, number.doubleValue)) }
+        if let number = value as? NSNumber, !(value is Bool) {
+            let seconds = number.doubleValue
+            guard seconds.isFinite else { return nil }
+            return min(maximum, max(0, seconds))
+        }
         guard let text = (value as? String)?.trimmingCharacters(in: .whitespaces), !text.isEmpty else { return nil }
         if let seconds = Double(text), seconds.isFinite { return min(maximum, max(0, seconds)) }
         let parts = text.split(separator: ":")
@@ -6008,7 +6472,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
               let hours = Double(parts[0]),
               let minutes = Double(parts[1]) else { return nil }
         let seconds = parts.count == 3 ? (Double(parts[2]) ?? -1) : 0
-        guard hours >= 0, minutes >= 0, minutes < 60, seconds >= 0, seconds < 60 else { return nil }
+        guard hours.isFinite, minutes.isFinite, seconds.isFinite,
+              hours >= 0, minutes >= 0, minutes < 60, seconds >= 0, seconds < 60 else { return nil }
         return min(maximum, hours * 3600 + minutes * 60 + seconds)
     }
 
@@ -6016,7 +6481,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// time), `2026-10-12T07:30` (local), a full ISO 8601 string, or
     /// milliseconds since 1970. Nil for anything else.
     static func pickerDate(_ value: Any?) -> Date? {
-        if let number = value as? NSNumber, !(value is Bool) { return Date(timeIntervalSince1970: number.doubleValue / 1000) }
+        if let number = value as? NSNumber, !(value is Bool) {
+            let milliseconds = number.doubleValue
+            guard milliseconds.isFinite else { return nil }
+            return Date(timeIntervalSince1970: milliseconds / 1000)
+        }
         guard let text = (value as? String)?.trimmingCharacters(in: .whitespaces), !text.isEmpty else { return nil }
         let local = DateFormatter()
         local.locale = Locale(identifier: "en_US_POSIX")
@@ -6042,7 +6511,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     @objc private func sliderFinished(_ sender: UISlider) {
         guard let handler = sliderCompleteHandlers[ObjectIdentifier(sender)] else { return }
-        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(snappedSliderValue(sender.value, for: sender))]])
+        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(snappedSliderValue(sender.value, for: sender), step: sliderSteps[ObjectIdentifier(sender)])]])
     }
 
     func numberOfComponents(in pickerView: UIPickerView) -> Int { 1 }
@@ -6087,6 +6556,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     @objc private func textSubmitted(_ sender: UITextField) {
+        // Return put the keyboard away.
+        forgetFocusedInput(sender)
         guard let handler = submitHandlers[ObjectIdentifier(sender)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["text": sender.text ?? ""]])
     }
@@ -6174,7 +6645,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func number(_ value: Any?) -> CGFloat? {
-        (value as? NSNumber).map { CGFloat(truncating: $0) }
+        guard let number = value as? NSNumber else { return nil }
+        let value = CGFloat(truncating: number)
+        return value.isFinite ? value : nil
     }
 
     private func keyboardType(_ value: Any?) -> UIKeyboardType {