@craft-native/ios 0.0.238 → 0.0.242

package/templates/CraftNativeScreen.swift

@@ -139,7 +139,7 @@ private enum CraftNativeTreeLayoutBridge {
         var alignItems: UInt32 = 3
         var alignSelf: UInt32 = 0
         var flexWrap: UInt32 = 0
-        var alignContent: UInt32 = 6
+        var alignContent: UInt32 = 5
         var marginTop: Float = 0
         var marginRight: Float = 0
         var marginBottom: Float = 0
@@ -180,7 +180,7 @@ private enum CraftNativeTreeLayoutBridge {
         var alignItems: UInt32 = 3
         var alignSelf: UInt32 = 0
         var flexWrap: UInt32 = 0
-        var alignContent: UInt32 = 6
+        var alignContent: UInt32 = 5
         var marginTop: Float = 0
         var marginRight: Float = 0
         var marginBottom: Float = 0
@@ -222,7 +222,7 @@ private enum CraftNativeTreeLayoutBridge {
         var alignItems: UInt32 = 3
         var alignSelf: UInt32 = 0
         var flexWrap: UInt32 = 0
-        var alignContent: UInt32 = 6
+        var alignContent: UInt32 = 5
         var marginTop: Float = 0
         var marginRight: Float = 0
         var marginBottom: Float = 0
@@ -1171,8 +1171,10 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var authoredHeading: Double?
     private var edgePadding = UIEdgeInsets(top: 24, left: 24, bottom: 24, right: 24)
     private var markerBearings: [String: Double] = [:]
+    private var markerPinColors: [String: UIColor] = [:]
     private var tileOverlay: MKTileOverlay?
     private var tileTemplate: String?
+    private var tileAttributionBottom: NSLayoutConstraint?
     private lazy var tileAttribution: UILabel = {
         let label = UILabel()
         label.font = .systemFont(ofSize: 9)
@@ -1181,7 +1183,9 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         label.translatesAutoresizingMaskIntoConstraints = false
         label.numberOfLines = 2
         addSubview(label)
-        NSLayoutConstraint.activate([label.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -8), label.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -8), label.leadingAnchor.constraint(greaterThanOrEqualTo: leadingAnchor, constant: 48)])
+        let bottom = label.bottomAnchor.constraint(equalTo: bottomAnchor, constant: -8)
+        tileAttributionBottom = bottom
+        NSLayoutConstraint.activate([label.trailingAnchor.constraint(equalTo: trailingAnchor, constant: -8), bottom, label.leadingAnchor.constraint(greaterThanOrEqualTo: leadingAnchor, constant: 48)])
         return label
     }()
 
@@ -1206,6 +1210,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         isScrollEnabled = props["scrollEnabled"] as? Bool ?? true
         isZoomEnabled = props["zoomEnabled"] as? Bool ?? true
         isRotateEnabled = props["rotateEnabled"] as? Bool ?? false
+        isPitchEnabled = props["pitchEnabled"] as? Bool ?? true
         mapType = Self.mapType(props["mapType"] as? String)
         configureTiles(props["tileOverlay"] as? [String: Any])
         showsCompass = props["showsCompass"] as? Bool ?? false
@@ -1219,6 +1224,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         }
         edgePadding = UIEdgeInsets(top: inset("top"), left: inset("left"), bottom: inset("bottom"), right: inset("right"))
         var nextBearings: [String: Double] = [:]
+        var nextPinColors: [String: UIColor] = [:]
         // Showing the user dot must not trigger a permission prompt from a
         // renderer pass. The app's existing location capability owns that
         // prompt; a map only opts in after authorization is already granted.
@@ -1227,6 +1233,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         var nextMarkers: [String: (coordinate: CLLocationCoordinate2D, title: String?)] = [:]
         var nextHandlers: [String: String] = [:]
         var nextPolylines: [String: (coordinates: [CLLocationCoordinate2D], color: UIColor, width: CGFloat)] = [:]
+        var nextPolylineIDs: [String] = []
         for (index, child) in children.enumerated() {
             guard let node = child as? [String: Any], let rawType = node["type"] as? String else { continue }
             let type = rawType.lowercased()
@@ -1239,6 +1246,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             if type == "mapmarker" || type == "marker" {
                 guard let point = points.first else { continue }
                 nextMarkers[id] = (point, childProps["title"] as? String)
+                if let color = childProps["pinColor"] as? String { nextPinColors[id] = Self.color(color) }
                 if let bearing = Self.numeric(childProps["bearing"]), bearing.isFinite {
                     nextBearings[id] = bearing.truncatingRemainder(dividingBy: 360)
                 }
@@ -1251,11 +1259,13 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
                 let authoredWidth = Self.numeric(childProps["strokeWidth"]) ?? 3
                 let width = CGFloat(authoredWidth)
                 guard authoredWidth.isFinite, width.isFinite, width > 0 else { continue }
+                if nextPolylines[id] == nil { nextPolylineIDs.append(id) }
                 nextPolylines[id] = (points, Self.color(childProps["strokeColor"] as? String), width)
             }
         }
 
         markerBearings = nextBearings
+        markerPinColors = nextPinColors
         let staleMarkers = annotationsByID.keys.filter { nextMarkers[$0] == nil }
         removeAnnotations(staleMarkers.compactMap { annotationsByID.removeValue(forKey: $0) })
         for (id, value) in nextMarkers {
@@ -1282,7 +1292,8 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             }
             overlayCoordinatesByID.removeValue(forKey: id)
         }
-        for (id, value) in nextPolylines {
+        for id in nextPolylineIDs {
+            guard let value = nextPolylines[id] else { continue }
             if let overlay = overlaysByID[id],
                let coordinates = overlayCoordinatesByID[id],
                Self.coordinatesEqual(coordinates, value.coordinates),
@@ -1302,6 +1313,19 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             overlayWidths[ObjectIdentifier(overlay)] = value.width
             addOverlay(overlay)
         }
+        // Keep authored casing/foreground order when an earlier line changes
+        // or retained children move. Exchanging native overlays preserves the
+        // unchanged objects, tile levels and current camera.
+        let ownedOverlayIDs = Set(overlaysByID.values.map { ObjectIdentifier($0) })
+        var orderedOverlays = overlays.compactMap { $0 as? MKPolyline }
+            .filter { ownedOverlayIDs.contains(ObjectIdentifier($0)) }
+        for (index, id) in nextPolylineIDs.enumerated() {
+            guard let overlay = overlaysByID[id], index < orderedOverlays.count,
+                  orderedOverlays[index] !== overlay,
+                  let previousIndex = orderedOverlays.firstIndex(where: { $0 === overlay }) else { continue }
+            exchangeOverlay(orderedOverlays[index], with: orderedOverlays[previousIndex])
+            orderedOverlays.swapAt(index, previousIndex)
+        }
 
         if let region = Self.region(props["region"]) {
             // `region` is controlled: an authored change is allowed to move
@@ -1411,20 +1435,27 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
 
     private func configureMarkerView(_ view: MKAnnotationView, id: String) {
         if let bearing = markerBearings[id] {
-            let configuration = UIImage.SymbolConfiguration(pointSize: 24, weight: .semibold)
+            let configuration = UIImage.SymbolConfiguration(pointSize: 16, weight: .semibold)
                 .applying(UIImage.SymbolConfiguration(paletteColors: [.white, .systemGreen]))
-            view.image = UIImage(systemName: "arrow.up.circle.fill", withConfiguration: configuration)
+            // MapKit otherwise tints this as a monochrome template and loses
+            // the contrasting route arrow when displayed over map content.
+            view.image = UIImage(systemName: "arrow.up.circle.fill", withConfiguration: configuration)?
+                .withRenderingMode(.alwaysOriginal)
             view.transform = CGAffineTransform(rotationAngle: CGFloat((bearing - camera.heading) * .pi / 180))
         } else {
+            view.tintColor = markerPinColors[id] ?? .systemRed
             view.image = UIImage(systemName: "mappin.circle.fill", withConfiguration: UIImage.SymbolConfiguration(pointSize: 28))?
-                .withTintColor(.systemRed, renderingMode: .alwaysOriginal)
+                .withTintColor(view.tintColor, renderingMode: .alwaysOriginal)
             view.transform = .identity
         }
     }
 
     override func layoutSubviews() {
         super.layoutSubviews()
-        if tileTemplate != nil { bringSubviewToFront(tileAttribution) }
+        if tileTemplate != nil {
+            tileAttributionBottom?.constant = -min(edgePadding.bottom, max(0, bounds.height - 40)) - 8
+            bringSubviewToFront(tileAttribution)
+        }
         if let region = pendingRegion, bounds.width > 0, bounds.height > 0 {
             pendingRegion = nil
             setRegion(region, animated: false)
@@ -1724,6 +1755,25 @@ private var craftNativeCornerRadiiKey: UInt8 = 0
 private var craftNativeBorderLayerKey: UInt8 = 0
 private var craftNativeSideBorderLayersKey: UInt8 = 0
 
+private let craftAllCorners: CACornerMask = [.layerMinXMinYCorner, .layerMaxXMinYCorner, .layerMaxXMaxYCorner, .layerMinXMaxYCorner]
+
+/// One radius for every rounded corner of `radii` (top-left, top-right,
+/// bottom-right, bottom-left), and which corners those are; nil when the
+/// rounded corners differ.
+func craftSharedCornerRadius(_ radii: [CGFloat]) -> (radius: CGFloat, corners: CACornerMask)? {
+    let order: [CACornerMask] = [.layerMinXMinYCorner, .layerMaxXMinYCorner, .layerMaxXMaxYCorner, .layerMinXMaxYCorner]
+    var radius: CGFloat?
+    var corners: CACornerMask = []
+    for (index, corner) in order.enumerated() {
+        let value = max(0, radii.count > index ? radii[index] : 0)
+        guard value > 0 else { continue }
+        if let radius, abs(radius - value) > 0.01 { return nil }
+        radius = value
+        corners.insert(corner)
+    }
+    return radius.map { ($0, corners) } ?? (0, craftAllCorners)
+}
+
 private func craftRoundedPath(_ rect: CGRect, _ rawRadii: [CGFloat]) -> CGPath {
     let limit = min(rect.width, rect.height) / 2
     let radii = (0..<4).map { min(max(0, rawRadii.count > $0 ? rawRadii[$0] : 0), limit) }
@@ -1774,25 +1824,62 @@ extension UIView {
         let requested = craftRequestedCornerRadius ?? 0
         let limit = min(bounds.width, bounds.height) / 2
         let radius = limit > 0 ? min(requested, limit) : min(requested, 9_998)
-        if let radii = craftRequestedCornerRadii {
+        if let radii = craftRequestedCornerRadii, let shared = craftSharedCornerRadius(radii) {
+            // The rounded corners share one radius (`rounded-t-md`): the
+            // layer rounds just those corners itself. A mask layer is an
+            // offscreen render pass for every frame the view is on screen,
+            // which Apple names first among render-phase hitches. Clipped
+            // like the mask was.
+            let clamped = limit > 0 ? min(shared.radius, limit) : min(shared.radius, 9_998)
+            layer.mask = nil
+            if layer.cornerRadius != clamped { layer.cornerRadius = clamped }
+            if layer.maskedCorners != shared.corners { layer.maskedCorners = shared.corners }
+            if !layer.masksToBounds { layer.masksToBounds = true }
+        } else if let radii = craftRequestedCornerRadii {
+            // Corners of different radii: only a path can draw them.
             let mask = (layer.mask as? CAShapeLayer) ?? CAShapeLayer()
-            mask.frame = bounds
+            if mask.frame != bounds { mask.frame = bounds }
             mask.path = craftRoundedPath(bounds, radii)
             layer.mask = mask
             layer.cornerRadius = 0
         } else {
-            layer.mask = nil
+            if layer.mask != nil { layer.mask = nil }
+            if layer.maskedCorners != craftAllCorners { layer.maskedCorners = craftAllCorners }
             if layer.cornerRadius != radius { layer.cornerRadius = radius }
         }
-        if let border = objc_getAssociatedObject(self, &craftNativeBorderLayerKey) as? CAShapeLayer {
-            border.frame = bounds
+        // A box shadow, as CSS draws it: the shape of the rounded box. Given
+        // no path, Core Animation renders the layer offscreen every frame to
+        // find the shadow's shape from its pixels.
+        if layer.shadowOpacity > 0, bounds.width > 0, bounds.height > 0 {
+            let cornerRadius = layer.mask == nil ? layer.cornerRadius : 0
+            let shape: CGPath = layer.mask == nil
+                ? (layer.maskedCorners == craftAllCorners || cornerRadius == 0
+                    ? CGPath(roundedRect: bounds, cornerWidth: cornerRadius, cornerHeight: cornerRadius, transform: nil)
+                    : craftRoundedPath(bounds, [CACornerMask.layerMinXMinYCorner, .layerMaxXMinYCorner, .layerMaxXMaxYCorner, .layerMinXMaxYCorner].map { layer.maskedCorners.contains($0) ? cornerRadius : 0 }))
+                : craftRoundedPath(bounds, craftRequestedCornerRadii ?? [])
+            if layer.shadowPath != shape { layer.shadowPath = shape }
+        } else if layer.shadowPath != nil {
+            layer.shadowPath = nil
+        }
+        let border = objc_getAssociatedObject(self, &craftNativeBorderLayerKey) as? CAShapeLayer
+        let sides = (objc_getAssociatedObject(self, &craftNativeSideBorderLayersKey) as? [CALayer]).flatMap { $0.count == 4 ? $0 : nil }
+        guard border != nil || sides != nil else { return }
+        // Border layers are the view's own sublayers, so a new frame or path
+        // would animate implicitly; and a path set again, even an equal one,
+        // draws the shape again. Layout runs for every child on every pass.
+        CATransaction.begin()
+        CATransaction.setDisableActions(true)
+        defer { CATransaction.commit() }
+        if let border {
+            if border.frame != bounds { border.frame = bounds }
             let inset = border.lineWidth / 2
-            border.path = UIBezierPath(
+            let path = UIBezierPath(
                 roundedRect: bounds.insetBy(dx: inset, dy: inset),
                 cornerRadius: max(0, radius - inset)
             ).cgPath
+            if border.path != path { border.path = path }
         }
-        if let sides = objc_getAssociatedObject(self, &craftNativeSideBorderLayersKey) as? [CALayer], sides.count == 4 {
+        if let sides {
             let top = sides[0].frame.height
             let right = sides[1].frame.width
             let bottom = sides[2].frame.height
@@ -1804,9 +1891,10 @@ extension UIView {
                 CGRect(x: 0, y: 0, width: left, height: bounds.height),
             ]
             for (index, side) in sides.enumerated() {
-                side.frame = frames[index]
+                if side.frame != frames[index] { side.frame = frames[index] }
                 if let shape = side as? CAShapeLayer {
-                    shape.path = craftSideBorderPath(shape.bounds, index: index)
+                    let path = craftSideBorderPath(shape.bounds, index: index)
+                    if shape.path != path { shape.path = path }
                 }
             }
         }
@@ -2681,11 +2769,24 @@ private class CraftNativeFlowView: UIStackView {
                 var fixedHeight = style.top != nil && style.bottom != nil
                     ? max(0, content.height - (style.top ?? 0) - (style.bottom ?? 0))
                     : style.height?.resolve(content.height)
+                let authoredWidth = fixedWidth != nil
+                let authoredHeight = fixedHeight != nil
                 (fixedWidth, fixedHeight) = aspectDimensions(style, width: fixedWidth, height: fixedHeight)
-                let measured = CraftNativeFlexLayout.measure(child, width: fixedWidth, height: fixedHeight, maxWidth: content.width, maxHeight: content.height)
-                let x = style.left ?? (style.right.map { content.width - $0 - measured.width } ?? 0)
-                let y = style.top ?? (style.bottom.map { content.height - $0 - measured.height } ?? 0)
-                frames.append((child, CGRect(x: content.minX + x, y: content.minY + y, width: measured.width, height: measured.height)))
+                var measured = CraftNativeFlexLayout.measure(child, width: fixedWidth, height: fixedHeight, maxWidth: content.width, maxHeight: content.height)
+                var boundedWidth = clamp(measured.width, style.minWidth?.resolve(content.width), style.maxWidth?.resolve(content.width))
+                let proposedHeight = !authoredHeight && style.aspectRatio != nil ? boundedWidth / style.aspectRatio! : fixedHeight
+                if abs(boundedWidth - measured.width) > 0.0001 || proposedHeight != fixedHeight {
+                    // A narrower label or container must wrap before its
+                    // height and bottom anchor are resolved.
+                    measured = CraftNativeFlexLayout.measure(child, width: boundedWidth, height: proposedHeight, maxWidth: content.width, maxHeight: content.height)
+                }
+                let boundedHeight = clamp(measured.height, style.minHeight?.resolve(content.height), style.maxHeight?.resolve(content.height))
+                if !authoredWidth, authoredHeight, let ratio = style.aspectRatio {
+                    boundedWidth = clamp(boundedHeight * ratio, style.minWidth?.resolve(content.width), style.maxWidth?.resolve(content.width))
+                }
+                let x = style.left ?? (style.right.map { content.width - $0 - boundedWidth } ?? 0)
+                let y = style.top ?? (style.bottom.map { content.height - $0 - boundedHeight } ?? 0)
+                frames.append((child, CGRect(x: content.minX + x, y: content.minY + y, width: boundedWidth, height: boundedHeight)))
             }
         }
         return (size, frames)
@@ -3370,6 +3471,8 @@ private final class CraftNativeModalView: UIView {
         let generation = animationGeneration
         layer.removeAllAnimations()
         guard visible else {
+            craftScreenController?.forgetFocusedInput(in: self)
+            endEditing(true)
             if animationType == "slide" && wasVisible {
                 let distance = max(bounds.height, superview?.bounds.height ?? UIScreen.main.bounds.height)
                 UIView.animate(withDuration: 0.24, animations: {
@@ -3409,6 +3512,8 @@ private final class CraftNativeModalView: UIView {
     }
 
     func resetForTeardown() {
+        craftScreenController?.forgetFocusedInput(in: self)
+        endEditing(true)
         animationGeneration += 1
         layer.removeAllAnimations()
         isHidden = true
@@ -4244,6 +4349,52 @@ private final class CraftNativeTextView: UITextView {
     }
 }
 
+/// The native screens' JavaScript. A screen is a JavaScriptCore context of
+/// its own and evaluates the whole file it is given, so each route has a file
+/// of its own when stx wrote one (`dist/native-screens/<route>.js`, stx's
+/// `routesDir`): a screen then parses its own code rather than every
+/// screen's. The one-file `dist/native-screen.js` remains the fallback.
+enum CraftNativeBundle {
+    /// Every screen's context lives in this one virtual machine. They all run
+    /// on the main thread, the machine's only one, and sharing it shares its
+    /// code cache: a screen opened again (a second workout, a tab rebuilt)
+    /// is not parsed again. Each screen keeps a global object of its own.
+    static let virtualMachine = JSVirtualMachine()!
+
+    private static let sources: NSCache<NSString, NSString> = {
+        let cache = NSCache<NSString, NSString>()
+        // Room for the one-file bundle, or a dozen route files.
+        cache.totalCostLimit = 24 << 20
+        return cache
+    }()
+
+    /// The file a route runs from: its own, else the one-file bundle.
+    static func url(for route: String?) -> URL? {
+        if let route, !route.isEmpty, !route.contains("/"), !route.hasPrefix("."),
+           let own = Bundle.main.url(forResource: route, withExtension: "js", subdirectory: "dist/native-screens") {
+            return own
+        }
+        return Bundle.main.url(forResource: "native-screen", withExtension: "js", subdirectory: "dist")
+            ?? Bundle.main.url(forResource: "native-screen", withExtension: "js")
+    }
+
+    /// Whether the app has native screens to run at all.
+    static var isAvailable: Bool {
+        url(for: nil) != nil || Bundle.main.url(forResource: "native-screens", withExtension: nil, subdirectory: "dist") != nil
+    }
+
+    /// The route's source, read from disk once and kept while memory allows:
+    /// a push read and decoded the file on the main thread every time.
+    static func source(for route: String?) -> (source: String, url: URL)? {
+        guard let url = url(for: route) else { return nil }
+        let key = url.path as NSString
+        if let cached = sources.object(forKey: key) { return (cached as String, url) }
+        guard let text = try? String(contentsOf: url, encoding: .utf8) else { return nil }
+        sources.setObject(text as NSString, forKey: key, cost: text.utf8.count)
+        return (text, url)
+    }
+}
+
 final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate, UITextFieldDelegate, UITextViewDelegate, UIPickerViewDataSource, UIPickerViewDelegate {
     private final class RenderedNode {
         let identity: String
@@ -4265,7 +4416,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private let config: CraftConfig
     private let routeName: String?
     private(set) var routeParams: [String: Any]
-    private let jsContext = JSContext()!
+    private let jsContext = JSContext(virtualMachine: CraftNativeBundle.virtualMachine)!
     private let rootStack = CraftNativeFlowView()
     private var handlers: [ObjectIdentifier: String] = [:]
     private var pressInHandlers: [ObjectIdentifier: String] = [:]
@@ -4326,6 +4477,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     func forgetFocusedInput(_ input: UIView? = nil) {
         if input == nil || lastFocusedInput === input { lastFocusedInput = nil }
     }
+    func forgetFocusedInput(in container: UIView) {
+        if let input = lastFocusedInput, input === container || input.isDescendant(of: container) {
+            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`.
@@ -4408,8 +4564,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             rootLeadingToSafeArea!,
             rootTrailingToSafeArea!
         ])
-        setupJavaScript()
-        loadBundle()
+        let pacing = CraftFramePacing.shared
+        pacing.measure("mount \(routeName ?? "screen") setup") { setupJavaScript() }
+        pacing.measure("mount \(routeName ?? "screen") bundle") { loadBundle() }
         observeNativeEvents()
         if isAppScript {
             // Its bundle has run, so its listeners are in place: the app's
@@ -4448,6 +4605,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     override func viewWillDisappear(_ animated: Bool) {
         super.viewWillDisappear(animated)
+        screenVisibilityChanged(false)
         stopCelebrations(in: view)
         // The accessory belongs to the visible native screen. Clear the
         // shared shell state before a hybrid/web route appears, otherwise a
@@ -4510,6 +4668,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         if visible { restoreShellChrome() }
         guard visible != reportedVisible else { return }
         reportedVisible = visible
+        if visible { DeepLinkManager.shared.replayNativeLinks() }
         if visible, !hasAppeared {
             hasAppeared = true
             return
@@ -5080,13 +5239,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     private func loadBundle() {
-        guard let url = Bundle.main.url(forResource: "native-screen", withExtension: "js", subdirectory: "dist")
-            ?? Bundle.main.url(forResource: "native-screen", withExtension: "js"),
-            let script = try? String(contentsOf: url, encoding: .utf8) else {
+        guard let bundle = CraftNativeBundle.source(for: routeName) else {
             showError("Missing dist/native-screen.js. Compile a .stx screen with `stx native compile` first.")
             return
         }
-        jsContext.evaluateScript(script)
+        jsContext.evaluateScript(bundle.source, withSourceURL: bundle.url)
         // A bundle that names no route leaves `__stxNativeRoute` undefined;
         // its title is the app's, not the word "undefined". A title the
         // script set with `navigation.setOptions` wins over both.
@@ -5432,7 +5589,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func loadBarImage(_ url: URL, _ done: @escaping (UIImage?) -> Void) {
         if let cached = Self.barImages.object(forKey: url as NSURL) { done(cached); return }
         URLSession.shared.dataTask(with: url) { data, _, _ in
-            let image = data.flatMap(UIImage.init(data:))
+            let image = data.flatMap(UIImage.init(data:)).map { $0.preparingForDisplay() ?? $0 }
             if let image { Self.barImages.setObject(image, forKey: url as NSURL) }
             DispatchQueue.main.async { done(image) }
         }.resume()
@@ -5566,8 +5723,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         sendAppState(CraftNativeActions.currentAppState())
         // Links are the screens' to show; the app script hears none.
         guard !isAppScript else { return }
-        deepLinkListener = DeepLinkManager.shared.addNativeListener { [weak self] url, initial in
-            guard let self = self, self.navigationController?.topViewController === self else { return }
+        deepLinkListener = DeepLinkManager.shared.addNativeListener(canReceive: { [weak self] in
+            guard let self = self else { return false }
+            return self.reportedVisible && !self.runtimeDisposed && self.navigationController?.topViewController === self
+        }) { [weak self] url, initial in
+            guard let self = self else { return }
             var payload = CraftNativeActions.deepLinkData(url)
             payload["initial"] = initial
             self.send(type: "DEEP_LINK", payload: payload)
@@ -6054,6 +6214,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func restoreFocus(_ focused: UIView?) {
         guard let focused, focused.window != nil, !focused.isFirstResponder,
               lastFocusedInput === focused, firstResponder(in: rootStack) == nil else { return }
+        var ancestor: UIView? = focused
+        while let view = ancestor {
+            if view.isHidden { return }
+            ancestor = view.superview
+        }
         // A delayed acknowledgement belongs to the input that scheduled it.
         // A newer field or an explicit dismissal owns focus now.
         _ = focused.becomeFirstResponder()
@@ -7367,6 +7532,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             || (view is UIScrollView && overflow != "visible")
             || (view is UILabel && (view.craftRequestedCornerRadius ?? 0) > 0)
             || (view is UIImageView && (borderRadius > 0 || hasCornerRadii))
+            // Per-corner rounding clips its content, as its mask did.
+            || hasCornerRadii
         view.layer.masksToBounds = view.clipsToBounds
         view.craftLayoutStyle = CraftNativeLayoutStyle(style)
         (view as? CraftNativeFlowView)?.invalidateMeasurements()
@@ -7629,6 +7796,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
     }
 
+    /// Downloaded images, decoded, for every screen: a screen opened again or
+    /// a row scrolled back draws its picture in its first frame rather than
+    /// fetching and decoding it again. Bounded by decoded bytes.
+    private static let decodedImages: NSCache<NSString, UIImage> = {
+        let cache = NSCache<NSString, UIImage>()
+        cache.totalCostLimit = 48 << 20
+        return cache
+    }()
+
     /// An image the screen downloads: https anywhere, and http only from this
     /// machine (localhost, 127.0.0.1, ::1, *.localhost), the development
     /// server the app's ATS exception already allows. Internal for XCTest.
@@ -7680,14 +7856,30 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             return
         }
         if let url = URL(string: uri), Self.loadsImage(from: url) {
+            // Shown before: on screen in this same frame, already decoded.
+            if let decoded = Self.decodedImages.object(forKey: requestKey as NSString) {
+                view.image = imageForDisplay(decoded, view: view)
+                imageDidChange(view)
+                emitImageEvent(view, handler: imageLoadHandlers[id])
+                emitImageEvent(view, handler: imageLoadEndHandlers[id])
+                return
+            }
             var request = URLRequest(url: url)
             for (name, value) in headers { request.setValue(value, forHTTPHeaderField: name) }
             let task = URLSession.shared.dataTask(with: request) { [weak self, weak view] data, _, _ in
+                // Decoded here, off the main thread. A UIImage made from data
+                // is only decoded when it first draws, on the main thread, in
+                // the frame it scrolls into view: Apple's "prepare" hitch.
+                let decoded = data.flatMap(UIImage.init(data:)).map { $0.preparingForDisplay() ?? $0 }
+                if let decoded {
+                    let pixels = decoded.size.width * decoded.scale * decoded.size.height * decoded.scale
+                    Self.decodedImages.setObject(decoded, forKey: requestKey as NSString, cost: Int(pixels * 4))
+                }
                 guard let self, let view else { return }
                 DispatchQueue.main.async {
                     guard self.imageSources[ObjectIdentifier(view)] == requestKey else { return }
                     self.imageTasks.removeValue(forKey: ObjectIdentifier(view))
-                    guard let data, let image = UIImage(data: data) else {
+                    guard let image = decoded else {
                         self.imageFailure(view, uri: uri, message: "Image download failed")
                         return
                     }
@@ -8201,12 +8393,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
 
+    private var pacingName: String { "scroll \(routeName ?? "screen")" }
+
     func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        CraftFramePacing.shared.begin(pacingName)
         guard let handler = scrollBeginHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
 
     func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
+        if !decelerate { CraftFramePacing.shared.end(pacingName) }
         guard let handler = scrollEndHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }
@@ -8217,6 +8413,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
+        CraftFramePacing.shared.end(pacingName)
         guard let handler = scrollMomentumEndHandlers[ObjectIdentifier(scrollView)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": scrollEvent(scrollView)])
     }

package/templates/testing/DriverTests.swift.template

@@ -21,6 +21,7 @@ import Darwin
 ///   tap <text>            first hittable element whose label contains text
 ///   tapif <text>          tap it when it is on screen, else carry on (the big timer's "Show the controls")
 ///   tapid <identifier>
+///   longpressid <identifier> holds a hittable native element to open its edit menu
 ///   touches <JSON>       timed normalized touch paths in one native dispatch
 ///   tapxy <x> <y>         normalised 0…1 of the screen
 ///   tapexact <label>      a button whose label is exactly this
@@ -29,11 +30,14 @@ import Darwin
 ///   return                the keyboard's return key (Go on a sign-in form)
 ///   field <n> <text>      tap the n-th text field (0-based, secure fields after plain) and type
 ///   typeid <identifier> <text>  tap the element with this identifier and type
+///   sliderid <identifier> <0…1> adjusts a hittable native slider
+///   expectapp <bundle-id> [| secs] asserts a native app handoff reached the foreground
 ///   expect <text> [| secs]  waits for an element containing text; logs PASS/FAIL
 ///   expectexact <label> [| secs]  a button or text whose label is exactly this
 ///   absent <text>         logs PASS when no element contains text
 ///   expectid <id> [| secs] / absentid <id>   the same by accessibility identifier (testID)
 ///   labelid <id> <text>   that element's label is exactly text (a count, a status)
+///   valueid <id> <text>   that element's actual string value is exactly text
 ///   tabbar shown|hidden   the native tab bar (Today, Calendar, …) can be tapped, or not
 ///   selected <tab>        the tab bar's selected button is this one
 ///   tab <name>            tap a tab bar button
@@ -297,6 +301,14 @@ final class DriverTests: XCTestCase {
             let target = identified(arg)
             if target.waitForExistence(timeout: 10) { press(target); note("tapid \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
+        case "longpressid":
+            let target = identified(arg)
+            guard target.waitForExistence(timeout: 10), target.isHittable else {
+                check(false, "longpressid \(arg) is hittable")
+                return
+            }
+            target.press(forDuration: 1.2)
+            note("longpressid \(arg): ok")
         case "touches":
             do {
                 guard let data = arg.data(using: .utf8),
@@ -367,6 +379,23 @@ final class DriverTests: XCTestCase {
                 app.typeText(idParts.count > 1 ? idParts[1] : "")
                 note("typeid \(idParts[0]): ok")
             } else { XCTFail("Element not found"); note("FAIL typeid \(idParts[0]): NOT FOUND") }
+        case "sliderid":
+            let parts = arg.split(separator: " ", maxSplits: 1).map(String.init)
+            guard parts.count == 2, let position = Double(parts[1]), position.isFinite, (0...1).contains(position) else {
+                check(false, "sliderid requires an identifier and normalized position")
+                return
+            }
+            let slider = app.sliders.matching(NSPredicate(format: "identifier == %@", parts[0])).firstMatch
+            guard slider.waitForExistence(timeout: 10), slider.isHittable else {
+                check(false, "sliderid \(parts[0]) is hittable")
+                return
+            }
+            slider.adjust(toNormalizedSliderPosition: CGFloat(position))
+            note("sliderid \(parts[0]): \(position)")
+        case "expectapp":
+            let (bundle, seconds) = split(arg)
+            let target = XCUIApplication(bundleIdentifier: bundle)
+            check(target.wait(for: .runningForeground, timeout: seconds), "expectapp \(bundle)")
         case "field":
             let fieldParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let index = Int(fieldParts[0]) ?? 0
@@ -392,6 +421,14 @@ final class DriverTests: XCTestCase {
             let want = idParts.count > 1 ? idParts[1] : ""
             let seen = target.waitForExistence(timeout: 5) ? target.label : "(missing)"
             check(seen == want, "labelid \(idParts[0]) \(want) (saw \(seen))")
+        case "valueid":
+            let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
+            let target = identified(idParts[0])
+            let want = idParts.count > 1 ? idParts[1] : ""
+            let matched = poll(5) {
+                target.exists && (target.value as? String) == want ? target : nil
+            }
+            check(matched != nil, "valueid \(idParts[0]) \(want)")
         case "absentid":
             check(!identified(arg).exists, "absentid \(arg)")
         case "absent":