@craft-native/ios 0.0.241 → 0.0.243

package/templates/CraftNativeFiles.swift

@@ -1,6 +1,7 @@
 import CryptoKit
 import Foundation
 import ImageIO
+import Network
 import PhotosUI
 import UIKit
 import UniformTypeIdentifiers
@@ -554,6 +555,13 @@ enum CraftNativeMedia {
         return id
     }
 
+    /// Whether `flight` is still the download `address`'s keeps wait for.
+    static func isWaiting(_ address: String, flight: UUID) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return inFlight[address]?.id == flight
+    }
+
     static func finish(_ address: String, flight: UUID, _ result: Result<Any, CraftNativeActionError>) {
         lock.lock()
         let waiting = inFlight[address]?.id == flight ? inFlight.removeValue(forKey: address)?.waiting ?? [] : []
@@ -563,7 +571,7 @@ enum CraftNativeMedia {
 
     /// A finished download moved into place (atomically, so a half-written
     /// file is never played), or a refusal with the server's status.
-    static func store(_ address: String, at location: URL, response: HTTPURLResponse, flight: UUID? = nil) -> Result<Any, CraftNativeActionError> {
+    static func store(_ address: String, at location: URL, response: HTTPURLResponse, flight: UUID? = nil, stillWanted: (() -> Bool)? = nil) -> Result<Any, CraftNativeActionError> {
         guard response.statusCode == 200 else {
             return .success(["ok": false, "url": address, "status": response.statusCode])
         }
@@ -574,6 +582,10 @@ enum CraftNativeMedia {
         if let flight, inFlight[address]?.id != flight {
             return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
         }
+        // A background transfer from before the cache was cleared (sign-out).
+        if let stillWanted, !stillWanted() {
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+        }
         let staging = root.appendingPathComponent(UUID().uuidString + ".part")
         defer { try? fm.removeItem(at: staging) }
         do {
@@ -609,6 +621,9 @@ enum CraftNativeMedia {
         lock.lock()
         let waiting = inFlight.values.flatMap { $0.waiting }
         inFlight.removeAll()
+        // Under the same lock a background transfer commits under: none
+        // started before this lands after it.
+        CraftNativeMediaTransfers.shared.cancelAll()
         let fm = FileManager.default
         let files = (try? fm.contentsOfDirectory(at: root, includingPropertiesForKeys: nil)) ?? []
         var removed = 0
@@ -625,6 +640,7 @@ enum CraftNativeMedia {
 
     /// Removes every copy whose address is not in `keep`; answers how many.
     static func prune(keep: [String]) -> Int {
+        CraftNativeMediaTransfers.shared.cancel(except: keep + Array(inFlightAddresses()))
         lock.lock()
         defer { lock.unlock() }
         let wanted = Set(keep.map { file(for: $0).lastPathComponent })
@@ -637,6 +653,12 @@ enum CraftNativeMedia {
         return removed
     }
 
+    private static func inFlightAddresses() -> Set<String> {
+        lock.lock()
+        defer { lock.unlock() }
+        return Set(inFlight.keys)
+    }
+
     /// What the kept copies come to, in bytes, and how many there are.
     static func usage() -> [String: Any] {
         let files = (try? FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: [.fileSizeKey])) ?? []
@@ -645,3 +667,185 @@ enum CraftNativeMedia {
         return ["files": kept.count, "bytes": bytes]
     }
 }
+
+/// The downloads `media.keep` starts, on a background URLSession: a transfer
+/// carries on while the app is suspended or closed, waits for Wi-Fi when it
+/// was asked to, and lands in CraftNativeMedia when it finishes, whether or
+/// not anyone is still waiting for it (the address travels with the task as
+/// its description, so a transfer outlives the launch that started it).
+///
+/// A request answers as soon as its file is kept, or at once with
+/// `{ ok: false, reason: "cellular" | "offline", queued: true }` when the
+/// phone cannot fetch it now: the transfer stays with iOS and finishes on
+/// its own, and the next `keep` of that address answers from the copy.
+final class CraftNativeMediaTransfers: NSObject, URLSessionDownloadDelegate {
+    static let shared = CraftNativeMediaTransfers()
+    static var identifier: String { "\(Bundle.main.bundleIdentifier ?? "dev.craft.app").craft-media" }
+
+    /// iOS's handler from relaunching the app for this session's events.
+    var backgroundCompletion: (() -> Void)?
+
+    private struct Transfer {
+        let address: String
+        /// The keep still waiting for this transfer; nil once answered early.
+        var flight: UUID?
+        let wifiOnly: Bool
+        /// Transfers from before the last `clear` must not land.
+        let generation: Int
+    }
+
+    private let lock = NSLock()
+    private var transfers: [Int: Transfer] = [:]
+    /// What each finished download came to, until its task completes.
+    private var finished: [Int: Result<Any, CraftNativeActionError>] = [:]
+    /// Transfers left running by an earlier launch, by address.
+    private var restored: [String: URLSessionDownloadTask] = [:]
+    private var generation = 0
+    private let monitor = NWPathMonitor()
+
+    /// Made once, at first use: iOS hands this identifier's finished
+    /// transfers to whichever session object the app makes with it.
+    private(set) var session: URLSession!
+
+    override init() {
+        super.init()
+        let configuration = URLSessionConfiguration.background(withIdentifier: Self.identifier)
+        configuration.sessionSendsLaunchEvents = true
+        configuration.isDiscretionary = false
+        session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+        session.getAllTasks { [weak self] tasks in
+            guard let self else { return }
+            self.lock.lock()
+            for case let task as URLSessionDownloadTask in tasks where task.state == .running || task.state == .suspended {
+                if let address = task.taskDescription, self.transfers[task.taskIdentifier] == nil { self.restored[address] = task }
+            }
+            self.lock.unlock()
+        }
+        // A connection lost (or only a metered one left for a Wi-Fi-only
+        // keep) answers the waiting keeps; their transfers carry on later.
+        monitor.pathUpdateHandler = { [weak self] path in self?.release(on: path) }
+        monitor.start(queue: DispatchQueue(label: "dev.craft.native.media.path"))
+    }
+
+    /// Fetches `request` into the copy for `address`, finishing `flight`.
+    func start(_ request: URLRequest, address: String, flight: UUID, wifiOnly: Bool) -> URLSessionTask {
+        lock.lock()
+        let task: URLSessionDownloadTask
+        if let earlier = restored.removeValue(forKey: address), earlier.state == .running || earlier.state == .suspended {
+            task = earlier
+        }
+        else {
+            task = session.downloadTask(with: request)
+            task.taskDescription = address
+        }
+        transfers[task.taskIdentifier] = Transfer(address: address, flight: flight, wifiOnly: wifiOnly, generation: generation)
+        lock.unlock()
+        task.resume()
+        release(on: monitor.currentPath)
+        return task
+    }
+
+    /// Answers the keeps that cannot be fetched on `path`; their transfers stay queued with iOS.
+    private func release(on path: NWPath) {
+        let offline = path.status != .satisfied
+        let metered = path.isExpensive || path.isConstrained
+        lock.lock()
+        var answered: [(String, UUID, String)] = []
+        for (id, transfer) in transfers {
+            guard let flight = transfer.flight, offline || (transfer.wifiOnly && metered) else { continue }
+            transfers[id]?.flight = nil
+            answered.append((transfer.address, flight, offline ? "offline" : "cellular"))
+        }
+        lock.unlock()
+        for (address, flight, reason) in answered {
+            CraftNativeMedia.finish(address, flight: flight, .success(["ok": false, "url": address, "reason": reason, "queued": true]))
+        }
+    }
+
+    /// Stops every transfer: an account's copies are being cleared, and none of its videos may land after.
+    func cancelAll() {
+        lock.lock()
+        generation += 1
+        restored.removeAll()
+        lock.unlock()
+        session.getAllTasks { tasks in tasks.forEach { $0.cancel() } }
+    }
+
+    /// Stops the transfers for addresses no longer wanted.
+    func cancel(except keep: [String]) {
+        let wanted = Set(keep)
+        lock.lock()
+        restored = restored.filter { wanted.contains($0.key) }
+        lock.unlock()
+        session.getAllTasks { tasks in
+            for task in tasks where !wanted.contains(task.taskDescription ?? "") { task.cancel() }
+        }
+    }
+
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        lock.lock()
+        let transfer = transfers[downloadTask.taskIdentifier]
+        lock.unlock()
+        // One left by an earlier launch belongs to the generation this launch began with.
+        let started = transfer?.generation ?? 0
+        guard let address = transfer?.address ?? downloadTask.taskDescription else { return }
+        guard let http = downloadTask.response as? HTTPURLResponse else {
+            record(downloadTask, .failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "media.keep received a response that is not HTTP")))
+            return
+        }
+        // The system deletes `location` once this returns: move it now. It
+        // lands whether its keep is still waiting or was answered early; only
+        // a clear since it started (sign-out) keeps it out.
+        record(downloadTask, CraftNativeMedia.store(address, at: location, response: http, stillWanted: { [weak self] in self?.isCurrent(started) ?? false }))
+    }
+
+    /// How many times the cache was cleared in this launch; a transfer started before the last clear does not land.
+    var currentGeneration: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return generation
+    }
+
+    func isCurrent(_ started: Int) -> Bool {
+        currentGeneration == started
+    }
+
+    private func record(_ task: URLSessionTask, _ result: Result<Any, CraftNativeActionError>) {
+        lock.lock()
+        finished[task.taskIdentifier] = result
+        lock.unlock()
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        lock.lock()
+        let transfer = transfers.removeValue(forKey: task.taskIdentifier)
+        let result = finished.removeValue(forKey: task.taskIdentifier)
+        if let address = task.taskDescription, restored[address] === task { restored.removeValue(forKey: address) }
+        lock.unlock()
+        guard let transfer, let flight = transfer.flight else { return }
+        if let error {
+            let urlError = error as? URLError
+            if urlError?.code == .cancelled {
+                CraftNativeMedia.finish(transfer.address, flight: flight, .failure(CraftNativeActionError(code: "CANCELLED", message: "media.keep was cancelled")))
+                return
+            }
+            // Refused only because the connection is metered: not a failure, a wait.
+            if let reason = urlError?.networkUnavailableReason, reason == .expensive || reason == .constrained {
+                CraftNativeMedia.finish(transfer.address, flight: flight, .success(["ok": false, "url": transfer.address, "reason": "cellular"]))
+                return
+            }
+            let code = urlError?.code == .timedOut ? "TIMEOUT" : "NETWORK_ERROR"
+            CraftNativeMedia.finish(transfer.address, flight: flight, .failure(CraftNativeActionError(code: CraftNativeMedia.errorCode(error, fallback: code), message: error.localizedDescription)))
+            return
+        }
+        CraftNativeMedia.finish(transfer.address, flight: flight, result ?? .failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "media.keep finished without a file")))
+    }
+
+    func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
+        DispatchQueue.main.async { [weak self] in
+            let done = self?.backgroundCompletion
+            self?.backgroundCompletion = nil
+            done?()
+        }
+    }
+}

package/templates/CraftNativeScreen.swift

@@ -1755,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) }
@@ -1805,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
@@ -1835,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 }
                 }
             }
         }
@@ -4292,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
@@ -4313,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] = [:]
@@ -4461,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
@@ -4494,13 +4598,28 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         applyNavigationBarAppearance()
         // Each screen says whether it wants the tab bar, so one that hid it
-        // never leaves it hidden for the next.
-        restoreShellChrome()
+        // never leaves it hidden for the next. Only the screen on screen:
+        // UIKit tells a tab's screen prepared in a hidden stack that it
+        // appears too, and that one took the accessory of the screen showing.
+        if isShownOnScreen { restoreShellChrome() }
         refreshTraitDefaults()
     }
 
+    /// In the window with nothing above it hidden: the screen the person
+    /// sees, not a tab prepared behind it.
+    private var isShownOnScreen: Bool {
+        guard let window = view.window else { return false }
+        var candidate: UIView? = view
+        while let current = candidate, current !== window {
+            if current.isHidden { return false }
+            candidate = current.superview
+        }
+        return true
+    }
+
     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
@@ -4515,11 +4634,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)
+        // A tab prepared in a hidden stack "appears" to UIKit as well; the
+        // shell says when it really shows (screenVisibilityChanged).
+        if isShownOnScreen {
+            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
@@ -4563,6 +4686,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
@@ -5133,13 +5257,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.
@@ -5485,7 +5607,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()
@@ -5619,8 +5741,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)
@@ -7425,6 +7550,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()
@@ -7687,6 +7814,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.
@@ -7738,14 +7874,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
                     }
@@ -8259,12 +8411,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)])
     }
@@ -8275,6 +8431,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)])
     }