@craft-native/ios 0.0.262 → 0.0.276

package/package.json

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

package/templates/CraftApp.swift

@@ -797,10 +797,21 @@ final class CraftChrome: ObservableObject {
         tabAccessory = next
     }
 
-    /// A retained or prepared screen cannot clear another screen's chrome.
-    func clearTabAccessory(ownedBy owner: AnyObject) {
+    /// A screen going away gives its accessory up without taking it off the
+    /// bar (a retained or prepared screen cannot clear another's): the screen coming in shows it until it says what it wants. Taken
+    /// off at once, the pill stretched across the bar and back while the
+    /// next screen (Messages, opened from the accessory; a tab opened for the
+    /// first time) started up and set the same accessory again.
+    func releaseTabAccessory(ownedBy owner: AnyObject) {
         guard tabAccessoryOwner === owner else { return }
-        updateTabAccessory(nil)
+        tabAccessoryOwner = nil
+    }
+
+    /// Takes off an accessory nobody claims any more: the screen now showing
+    /// drew without asking for one, or is a page that never does.
+    func clearUnclaimedTabAccessory() {
+        guard tabAccessoryOwner == nil, tabAccessory != nil else { return }
+        tabAccessory = nil
     }
 
     func setHiddenByScreen(_ hidden: Bool) {
@@ -6347,6 +6358,7 @@ struct CraftWebView: UIViewRepresentable {
 
             SecItemDelete(query as CFDictionary)
             let status = SecItemAdd(query as CFDictionary, nil)
+            CraftKeychain.forget(account: key)
             return status == errSecSuccess
         }
 
@@ -6373,12 +6385,14 @@ struct CraftWebView: UIViewRepresentable {
                 kSecAttrAccount as String: key
             ]
             let status = SecItemDelete(query as CFDictionary)
+            CraftKeychain.forget(account: key)
             return status == errSecSuccess || status == errSecItemNotFound
         }
 
         private func secureClear() -> Bool {
             let query: [String: Any] = [kSecClass as String: kSecClassGenericPassword]
             let status = SecItemDelete(query as CFDictionary)
+            CraftKeychain.forget(account: nil)
             return status == errSecSuccess || status == errSecItemNotFound
         }
 
@@ -8259,6 +8273,7 @@ struct CraftWebView: UIViewRepresentable {
             SecItemDelete(query as CFDictionary)
 
             let status = SecItemAdd(query as CFDictionary, nil)
+            CraftKeychain.forget(account: key)
             if status == errSecSuccess {
                 resolveCallback(callbackId, result: ["success": true, "key": key])
             } else {
@@ -8301,6 +8316,7 @@ struct CraftWebView: UIViewRepresentable {
             }
 
             let status = SecItemDelete(query as CFDictionary)
+            CraftKeychain.forget(account: key)
             if status == errSecSuccess || status == errSecItemNotFound {
                 resolveCallback(callbackId, result: ["success": true, "key": key])
             } else {

package/templates/CraftHybrid.swift

@@ -240,8 +240,10 @@ enum CraftHybridKeychain {
     static let nativeService = "dev.craft.native.secure"
 
     static func set(_ key: String, value: String?) {
+        defer { CraftKeychain.forget(account: key) }
         // Every item for the account, whatever its service.
         SecItemDelete([kSecClass as String: kSecClassGenericPassword, kSecAttrAccount as String: key] as CFDictionary)
+        CraftKeychain.forget(account: key)
         guard let value else { return }
         for service in [nil, nativeService] {
             var add: [String: Any] = [
@@ -355,6 +357,7 @@ final class CraftHybrid: NSObject {
         isConfigured = true
         self.config = config
         CraftNativeScriptThread.isBackground = config.nativeScriptThread == "background"
+        if CraftNativeScriptThread.isBackground { CraftNativeBundle.prewarm() }
         hasWeb = config.renderer != "native"
         siteURL = config.devServerURL.flatMap(URL.init(string:)).flatMap { url in
             ["http", "https"].contains((url.scheme ?? "").lowercased()) ? url : nil
@@ -2034,6 +2037,8 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     func navigationController(_ navigationController: UINavigationController, didShow viewController: UIViewController, animated: Bool) {
         lastNavigation = CACurrentMediaTime()
         CraftFramePacing.shared.end("navigation")
+        // A page shows no native accessory; one a screen gave up is taken off.
+        if viewController is CraftHybridWebSlot { CraftChrome.shared.clearUnclaimedTabAccessory() }
         let key = ObjectIdentifier(navigationController)
         let before = shownStacks[key] ?? []
         let now = navigationController.viewControllers
@@ -2291,16 +2296,34 @@ final class CraftFramePacing: NSObject {
         }
     }
 
-    /// One main-thread block, timed: a screen mount, a bundle evaluation.
+    /// One block, timed: a screen mount, a bundle evaluation. Labelled by the
+    /// thread it ran on, since a screen's script now runs off the main thread
+    /// and a bundle's time there costs no frames.
     @discardableResult
     func measure<T>(_ name: String, _ work: () -> T) -> T {
         guard enabled else { return work() }
         let started = CACurrentMediaTime()
         let result = work()
-        write(String(format: "%@ main=%.1fms", name, (CACurrentMediaTime() - started) * 1000))
+        write(String(format: "%@ %@=%.1fms", name, Thread.isMainThread ? "main" : "script", (CACurrentMediaTime() - started) * 1000))
         return result
     }
 
+    /// One piece of the screens' JavaScript (CraftNativeScriptThread): how
+    /// long it waited behind other screens' work, and how long it ran. The
+    /// screens share one serial script thread, so a screen in front can sit
+    /// behind hidden tabs reloading; `waited` is where that shows.
+    func scriptWork(_ name: String, waited: CFTimeInterval, ran: CFTimeInterval) {
+        guard enabled else { return }
+        write(String(format: "script %@ waited=%.1fms ran=%.1fms", name, waited * 1000, ran * 1000))
+    }
+
+    /// A capability a screen asked for (a request, the keychain), from the
+    /// ask to the answer. Logged from 4ms, as script work is.
+    func capability(_ name: String, took: CFTimeInterval) {
+        guard enabled, took >= 0.004 else { return }
+        write(String(format: "capability %@ took=%.1fms", name, took * 1000))
+    }
+
     /// Each line to the log and to `Library/Caches/craft-frame-pacing.log`
     /// in the app's container, which a test run reads back whole (a
     /// simulator's unified log can drop an app's lines under load). Written

package/templates/CraftNativeActions.swift

@@ -219,11 +219,13 @@ enum CraftNativeActions {
             }
             // A write that moves the sign-in token is the account's change:
             // every screen hears it (CraftSession). Reads skip the check.
-            if ["set", "remove", "delete", "clear"].contains(method) {
-                sync = CraftSession.observe(key: method == "clear" ? nil : args.first as? String, config: config, write)
-            } else {
-                sync = write()
+            // Off the main thread, in order (CraftKeychain.queue).
+            let isWrite = ["set", "remove", "delete", "clear"].contains(method)
+            CraftKeychain.queue.async {
+                let result = isWrite ? CraftSession.observe(key: method == "clear" ? nil : args.first as? String, config: config, write) : write()
+                complete(requestToken, result, completion)
             }
+            return
         case ("Biometrics", "isAvailable"):
             sync = config.enableBiometric ? .success(biometricContext().canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: nil)) : failure("CAPABILITY_DISABLED", "Biometric authentication is disabled")
         case ("Biometrics", "getBiometricType"):
@@ -957,6 +959,7 @@ enum CraftNativeActions {
         if method == "clear" {
             let query: [String: Any] = [kSecClass as String: kSecClassGenericPassword, kSecAttrService as String: service]
             let status = SecItemDelete(query as CFDictionary)
+            CraftKeychain.forget(account: nil)
             guard status == errSecSuccess || status == errSecItemNotFound else {
                 return failure("SECURE_STORAGE_ERROR", "Secure storage could not be cleared")
             }
@@ -977,24 +980,38 @@ enum CraftNativeActions {
             query[kSecValueData as String] = Data(value.utf8)
             query[kSecAttrAccessible as String] = kSecAttrAccessibleWhenUnlockedThisDeviceOnly
             let removed = SecItemDelete(base as CFDictionary)
+            CraftKeychain.forget(account: key)
             guard removed == errSecSuccess || removed == errSecItemNotFound else {
                 return failure("SECURE_STORAGE_ERROR", "Secure storage could not be replaced (\(removed))")
             }
             let status = SecItemAdd(query as CFDictionary, nil)
+            CraftKeychain.forget(account: key)
             return status == errSecSuccess ? .success(true) : failure("SECURE_STORAGE_ERROR", "Secure storage could not be written (\(status))")
         case "get":
-            var query = base
-            query[kSecReturnData as String] = true
-            query[kSecMatchLimit as String] = kSecMatchLimitOne
-            var result: AnyObject?
-            let status = SecItemCopyMatching(query as CFDictionary, &result)
-            if status == errSecItemNotFound { return .success(NSNull()) }
-            guard status == errSecSuccess, let data = result as? Data else {
+            // A failed read is not remembered: it is answered as a failure,
+            // and the next read asks the Keychain again.
+            var failed = false
+            let value = CraftKeychain.value(account: key, service: service) { () -> String? in
+                var query = base
+                query[kSecReturnData as String] = true
+                query[kSecMatchLimit as String] = kSecMatchLimitOne
+                var result: AnyObject?
+                let status = SecItemCopyMatching(query as CFDictionary, &result)
+                if status == errSecItemNotFound { return nil }
+                guard status == errSecSuccess, let data = result as? Data else {
+                    failed = true
+                    return nil
+                }
+                return String(decoding: data, as: UTF8.self)
+            }
+            if failed {
+                CraftKeychain.forget(account: key)
                 return failure("SECURE_STORAGE_ERROR", "Secure storage could not be read")
             }
-            return .success(String(decoding: data, as: UTF8.self))
+            return .success(value.map { $0 as Any } ?? NSNull())
         case "remove":
             let status = SecItemDelete(base as CFDictionary)
+            CraftKeychain.forget(account: key)
             return status == errSecSuccess || status == errSecItemNotFound ? .success(true) : failure("SECURE_STORAGE_ERROR", "Secure storage could not be removed")
         default:
             return failure("UNKNOWN_ACTION", "Unsupported SecureStorage method")
@@ -1500,15 +1517,85 @@ extension CraftNativeActions {
     /// `secureStore` writes it. Nil when there is none.
     static func webSecureValue(forKey key: String) -> String? {
         guard let key = validKey(key) else { return nil }
-        let query: [String: Any] = [
-            kSecClass as String: kSecClassGenericPassword,
-            kSecAttrAccount as String: key,
-            kSecReturnData as String: true,
-            kSecMatchLimit as String: kSecMatchLimitOne,
-        ]
-        var result: AnyObject?
-        guard SecItemCopyMatching(query as CFDictionary, &result) == errSecSuccess, let data = result as? Data else { return nil }
-        return String(data: data, encoding: .utf8)
+        return CraftKeychain.value(account: key, service: nil) {
+            let query: [String: Any] = [
+                kSecClass as String: kSecClassGenericPassword,
+                kSecAttrAccount as String: key,
+                kSecReturnData as String: true,
+                kSecMatchLimit as String: kSecMatchLimitOne,
+            ]
+            var result: AnyObject?
+            guard SecItemCopyMatching(query as CFDictionary, &result) == errSecSuccess, let data = result as? Data else { return nil }
+            return String(data: data, encoding: .utf8)
+        }
+    }
+}
+
+/// The app's own Keychain items, read once and then remembered.
+///
+/// A Keychain read is `SecItemCopyMatching`, which took 100-900ms a read on a
+/// simulator and is not free on a phone, and every screen reads the sign-in
+/// token and the account beside it when it opens. They ran on the main
+/// thread, one after another, so a sign-in that made each open screen check
+/// the account again held the interface for seconds.
+///
+/// This process is the only writer of these items, through `secureStorage`,
+/// `CraftHybridKeychain` and the web bridge's secure storage, and each of
+/// them forgets what it changed. An item another process could write (a
+/// shared access group, an extension) is not remembered, and coming back to
+/// the foreground forgets everything, so a value written while the app was
+/// away is read fresh.
+enum CraftKeychain {
+    /// Where native screens' secure storage runs: off the main thread, one
+    /// call at a time, so a write is always seen by the read after it.
+    static let queue = DispatchQueue(label: "craft.keychain", qos: .userInitiated)
+    private static let lock = NSLock()
+    private static var values: [String: String?] = [:]
+    /// Moves on every forget, so a read that raced a write is not kept.
+    private static var generation = 0
+    private static var observing: NSObjectProtocol?
+
+    private static func cacheKey(_ account: String, _ service: String?) -> String {
+        "\(service ?? "*")\u{1F}\(account)"
+    }
+
+    /// `account`'s value under `service` (nil: whichever service holds it),
+    /// from memory when it was read before, else from `read`.
+    static func value(account: String, service: String?, read: () -> String?) -> String? {
+        let key = cacheKey(account, service)
+        lock.lock()
+        if observing == nil { observeForeground() }
+        if let known = values[key] {
+            lock.unlock()
+            return known
+        }
+        let started = generation
+        lock.unlock()
+        let value = read()
+        lock.lock()
+        if generation == started { values[key] = .some(value) }
+        lock.unlock()
+        return value
+    }
+
+    /// Drop what is remembered for `account`, under every service; nil drops all.
+    static func forget(account: String?) {
+        lock.lock()
+        generation += 1
+        if let account {
+            let suffix = "\u{1F}\(account)"
+            values = values.filter { !$0.key.hasSuffix(suffix) }
+        } else {
+            values.removeAll()
+        }
+        lock.unlock()
+    }
+
+    /// Called with `lock` held.
+    private static func observeForeground() {
+        observing = NotificationCenter.default.addObserver(forName: UIApplication.willEnterForegroundNotification, object: nil, queue: nil) { _ in
+            forget(account: nil)
+        }
     }
 }
 

package/templates/CraftNativeFlatList.swift

@@ -49,6 +49,8 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
 
         private(set) var representedIdentity: String?
         private(set) var hostedView: UIView?
+        /// Top, bottom, leading and trailing: the row's own margins inset it.
+        private var hostedConstraints: [NSLayoutConstraint] = []
         var onRecycle: ((String) -> Void)?
         override func prepareForReuse() {
             super.prepareForReuse()
@@ -74,7 +76,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             representedIdentity = identity
             // The same view, already here. A view that left for another cell
             // and is asked for again is put back below.
-            guard hostedView !== view || view.superview !== contentView else { return }
+            guard hostedView !== view || view.superview !== contentView else { return applyHostedMargins() }
             // Only a view still in this cell is taken out of it: one that has
             // since moved to another cell is that cell's now, and pulling it
             // from there blanked a row on screen.
@@ -82,12 +84,27 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             hostedView = view
             view.translatesAutoresizingMaskIntoConstraints = false
             contentView.addSubview(view)
-            NSLayoutConstraint.activate([
+            hostedConstraints = [
                 view.topAnchor.constraint(equalTo: contentView.topAnchor),
-                view.bottomAnchor.constraint(equalTo: contentView.bottomAnchor),
+                contentView.bottomAnchor.constraint(equalTo: view.bottomAnchor),
                 view.leadingAnchor.constraint(equalTo: contentView.leadingAnchor),
-                view.trailingAnchor.constraint(equalTo: contentView.trailingAnchor),
-            ])
+                contentView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
+            ]
+            applyHostedMargins()
+            NSLayoutConstraint.activate(hostedConstraints)
+        }
+
+        /// A row's margins (`mx-4` on a grouped row) inset it in its cell, as
+        /// a column inset it: pinned edge to edge, HQ's Discover results ran
+        /// to the screen's sides. Read again on every pass, since a style
+        /// update changes the row in place.
+        private func applyHostedMargins() {
+            guard let view = hostedView, view.superview === contentView, hostedConstraints.count == 4 else { return }
+            let margins = view.craftLayoutMargins
+            let constants = [margins.top, margins.bottom, margins.left, margins.right]
+            for (constraint, constant) in zip(hostedConstraints, constants) where constraint.constant != constant {
+                constraint.constant = constant
+            }
         }
 
         func releaseHostedView() {
@@ -106,6 +123,8 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             _ layoutAttributes: UICollectionViewLayoutAttributes
         ) -> UICollectionViewLayoutAttributes {
             guard let hostedView = hostedView else { return layoutAttributes }
+            applyHostedMargins()
+            let margins = hostedView.craftLayoutMargins
             let attributes = layoutAttributes.copy() as! UICollectionViewLayoutAttributes
             // A cell has no collectionView property; the list is its nearest
             // collection view ancestor.
@@ -121,24 +140,26 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
                let flowLayout = collectionView.collectionViewLayout as? UICollectionViewFlowLayout,
                flowLayout.scrollDirection == .horizontal {
                 let height = fittingExtent ?? layoutAttributes.size.height
+                let inner = max(0, height - margins.top - margins.bottom)
                 let measured = CraftNativeFlexLayout.measure(
                     hostedView,
                     width: nil,
-                    height: height,
+                    height: inner,
                     maxWidth: CraftNativeFlexLayout.unbounded,
-                    maxHeight: height
+                    maxHeight: inner
                 )
-                attributes.size = CGSize(width: max(1, ceil(measured.width)), height: max(1, height))
+                attributes.size = CGSize(width: max(1, ceil(measured.width + margins.left + margins.right)), height: max(1, height))
             } else {
                 let width = fittingExtent ?? layoutAttributes.size.width
+                let inner = max(0, width - margins.left - margins.right)
                 let measured = CraftNativeFlexLayout.measure(
                     hostedView,
-                    width: width,
+                    width: inner,
                     height: nil,
-                    maxWidth: width,
+                    maxWidth: inner,
                     maxHeight: CraftNativeFlexLayout.unbounded
                 )
-                attributes.size = CGSize(width: max(1, width), height: max(1, ceil(measured.height)))
+                attributes.size = CGSize(width: max(1, width), height: max(1, ceil(measured.height + margins.top + margins.bottom)))
             }
             return attributes
         }
@@ -184,6 +205,14 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
     private var keyboardShouldPersistTaps = "never"
     private var scrollTargetKey: String?
     private var pendingScrollTarget: (id: String, animated: Bool, attempts: Int)?
+    /// A target that ends at the list's end, held to the true bottom while
+    /// the rows near it measure themselves. Rows self-size from a 44pt
+    /// estimate, so an offset worked out before they are measured stops short
+    /// of tall rows (multi-paragraph replies, cards). Cleared by a drag.
+    private var endSettlePasses: Int?
+    private var endSettleGeneration = 0
+    private var isAnimatingToEnd = false
+    private var isMeasuringEnd = false
 
     init() {
         let layout = CraftNativeFlatListLayout()
@@ -339,6 +368,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         guard key != scrollTargetKey else { return }
         scrollTargetKey = key
         pendingScrollTarget = (id, animated, 0)
+        cancelEndSettle()
         scrollToPendingTarget()
     }
 
@@ -538,6 +568,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         pendingThemeRefresh = false
         scrollTargetKey = nil
         pendingScrollTarget = nil
+        cancelEndSettle()
     }
 
     /// Releases callbacks and UIKit ownership that belong to a permanently
@@ -569,15 +600,28 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
     }
 
     func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        // The end is measured by jumping there and back in one pass, before
+        // anything draws: the screen hears only where the scroll goes.
+        guard !isMeasuringEnd else { return }
         onScrollEvent?(scrollView)
         onLayoutChanged?()
         evaluateEndReached()
     }
 
     func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        // The finger has the list now: stop holding it to its end.
+        cancelEndSettle()
         onScrollBeginDrag?(scrollView)
     }
 
+    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
+        guard isAnimatingToEnd else { return }
+        isAnimatingToEnd = false
+        // Rows passed on the way measured themselves and moved the end.
+        settleAtEnd()
+        scheduleEndSettle()
+    }
+
     func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
         onScrollEndDrag?(scrollView)
     }
@@ -636,12 +680,16 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
 
     private func scrollToPendingTarget() {
         guard let target = pendingScrollTarget else { return }
+        // A snapshot that is landing, or queued behind the one landing, can
+        // add rows before the target or move it: an index read now is stale
+        // (it scrolled to the old end). finishApplyingSnapshot() aims again
+        // once the rows are in, and so does a list not laid out yet.
+        guard !isApplyingSnapshot, pendingApply == nil, bounds.width > 0, bounds.height > 0 else { return }
         guard let index = targetIndex(for: target.id), index < numberOfItems(inSection: 0) else {
+            // No row has this id once the list is idle: try a few more
+            // passes, then let it go.
             if target.attempts >= 4 {
-                // A diffable snapshot may still be applying. Keep the target
-                // for finishApplyingSnapshot(), but discard an invalid target
-                // once the list is otherwise idle.
-                if !isApplyingSnapshot { pendingScrollTarget = nil }
+                pendingScrollTarget = nil
                 return
             }
             pendingScrollTarget = (target.id, target.animated, target.attempts + 1)
@@ -649,8 +697,100 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             return
         }
         pendingScrollTarget = nil
+        let indexPath = IndexPath(item: index, section: 0)
+        let identity = diffableDataSource.itemIdentifier(for: indexPath) ?? items[index].identity
+        if index == numberOfItems(inSection: 0) - 1 {
+            scrollToEnd(animated: target.animated)
+            return
+        }
         let position: UICollectionView.ScrollPosition = flowLayout.scrollDirection == .horizontal ? .left : .top
-        scrollToItem(at: IndexPath(item: index, section: 0), at: position, animated: target.animated)
+        scrollToItem(at: indexPath, at: position, animated: target.animated)
+        guard !target.animated else { return }
+        // A row near the end cannot come to the top: the list stops at its
+        // end, which is only true once the rows there are measured.
+        layoutIfNeeded()
+        if rowReachesPastEnd(identity) { scrollToEnd(animated: false) }
+    }
+
+    /// The offset that shows the end of the content, along the scroll axis.
+    private var endOffset: CGPoint {
+        if flowLayout.scrollDirection == .horizontal {
+            return CGPoint(
+                x: max(-adjustedContentInset.left, contentSize.width + adjustedContentInset.right - bounds.width),
+                y: contentOffset.y
+            )
+        }
+        return CGPoint(
+            x: contentOffset.x,
+            y: max(-adjustedContentInset.top, contentSize.height + adjustedContentInset.bottom - bounds.height)
+        )
+    }
+
+    /// Whether the row's leading edge lies past where the list can scroll to.
+    private func rowReachesPastEnd(_ identity: String) -> Bool {
+        guard let indexPath = diffableDataSource.indexPath(for: identity),
+              let frame = layoutAttributesForItem(at: indexPath)?.frame else { return false }
+        if flowLayout.scrollDirection == .horizontal {
+            return frame.minX - adjustedContentInset.left >= endOffset.x - 0.5
+        }
+        return frame.minY - adjustedContentInset.top >= endOffset.y - 0.5
+    }
+
+    private func scrollToEnd(animated: Bool) {
+        endSettlePasses = 2
+        endSettleGeneration += 1
+        if animated {
+            // Measure the rows at the end where they will be, then animate
+            // there from where the list was, so the animation lands on the
+            // true end rather than on an estimate.
+            let start = contentOffset
+            isMeasuringEnd = true
+            settleAtEnd()
+            let end = contentOffset
+            setContentOffset(start, animated: false)
+            isMeasuringEnd = false
+            if abs(end.x - start.x) > 0.5 || abs(end.y - start.y) > 0.5 {
+                isAnimatingToEnd = true
+                setContentOffset(end, animated: true)
+            }
+        } else {
+            settleAtEnd()
+        }
+        scheduleEndSettle()
+    }
+
+    /// Moves to the end until it stops moving: each move shows rows that
+    /// measure themselves and change the content size.
+    private func settleAtEnd() {
+        guard endSettlePasses != nil, !isDragging, !isTracking else { return cancelEndSettle() }
+        for _ in 0..<6 {
+            layoutIfNeeded()
+            let end = endOffset
+            guard abs(end.x - contentOffset.x) > 0.5 || abs(end.y - contentOffset.y) > 0.5 else { break }
+            setContentOffset(end, animated: false)
+        }
+    }
+
+    /// Checks the end again on the next runloop passes, while late rows and
+    /// the content size settle.
+    private func scheduleEndSettle() {
+        let generation = endSettleGeneration
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.endSettleGeneration == generation, let passes = self.endSettlePasses,
+                  // An animation on its way there settles, and checks
+                  // again, when it ends.
+                  !self.isAnimatingToEnd else { return }
+            if passes <= 0 { return self.cancelEndSettle() }
+            self.endSettlePasses = passes - 1
+            if !self.isApplyingSnapshot, self.pendingApply == nil { self.settleAtEnd() }
+            self.scheduleEndSettle()
+        }
+    }
+
+    private func cancelEndSettle() {
+        endSettlePasses = nil
+        endSettleGeneration += 1
+        isAnimatingToEnd = false
     }
 
     private func clamped(_ offset: CGPoint) -> CGPoint {

package/templates/CraftNativeMutation.swift

@@ -339,11 +339,13 @@ final class CraftNativeMutationDocument {
     /// `Svg`). Only View, SafeAreaView and ScrollView used to be here, so a
     /// drawing revealed after the first paint (an `:if` around an `<svg>`)
     /// had its shapes refused as INVALID_PARENT, and the whole screen was
-    /// drawn again; Android's host already took the same list.
+    /// drawn again; Android's host already took the same list. A shape holds
+    /// its `Animate` (SMIL keyframes: HQ's moving exercise figures).
     static let containerTypes: Set<String> = [
         "View", "SafeAreaView", "ScrollView", "KeyboardAvoidingView", "Modal", "Pressable",
         "TouchableOpacity", "TouchableHighlight", "ImageBackground", "FlatList", "SectionList",
         "Fragment", "Svg", "G", "Map",
+        "Path", "Line", "Rect", "Circle", "Ellipse", "Polyline", "Polygon",
     ]
     private static let containerTypeKeys = Set(containerTypes.map { $0.lowercased() })
 

package/templates/CraftNativeScreen.swift

@@ -1345,6 +1345,64 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
     deinit { stop() }
 }
 
+/// A map pin that answers being activated as it answers a tap.
+final class CraftMarkerAnnotationView: MKAnnotationView {
+    var onActivate: (() -> Void)?
+
+    override func accessibilityActivate() -> Bool {
+        guard let onActivate else { return super.accessibilityActivate() }
+        onActivate()
+        return true
+    }
+
+    override func prepareForReuse() {
+        super.prepareForReuse()
+        onActivate = nil
+    }
+}
+
+/// A tile overlay whose tiles are kept on disk.
+///
+/// MKTileOverlay asked the network for every tile on every pan back over the
+/// same ground, and drew nothing where a tile had not come yet. These go
+/// through one session with a cache of its own (Caches/craft-map-tiles), so
+/// ground seen before draws at once and offline, and a phone on a trail
+/// does not fetch the same hillside twice.
+final class CraftCachedTileOverlay: MKTileOverlay {
+    static let session: URLSession = {
+        let configuration = URLSessionConfiguration.default
+        let directory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?.appendingPathComponent("craft-map-tiles", isDirectory: true)
+        configuration.urlCache = URLCache(memoryCapacity: 48 << 20, diskCapacity: 512 << 20, directory: directory)
+        // Topography and imagery change on the scale of months: a tile held
+        // is used without asking again.
+        configuration.requestCachePolicy = .returnCacheDataElseLoad
+        configuration.httpMaximumConnectionsPerHost = 8
+        return URLSession(configuration: configuration)
+    }()
+
+    override func loadTile(at path: MKTileOverlayPath, result: @escaping (Data?, Error?) -> Void) {
+        let request = URLRequest(url: url(forTilePath: path), cachePolicy: .returnCacheDataElseLoad, timeoutInterval: 20)
+        Self.session.dataTask(with: request) { data, response, error in
+            if let status = (response as? HTTPURLResponse)?.statusCode, !(200..<300).contains(status) {
+                result(nil, error ?? URLError(.badServerResponse))
+                return
+            }
+            result(data, error)
+        }.resume()
+    }
+}
+
+/// The basemaps a `Map` names with `basemap`, drawn the best way each
+/// platform can: Apple's vector map (with real terrain from iOS 16) for
+/// standard, imagery and hybrid, and topography with contours over a muted
+/// Apple map for outdoors.
+enum CraftBasemap: String {
+    case standard, outdoors, satellite, hybrid
+
+    static let outdoorTiles = "https://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}"
+    static let outdoorCredit = "Topography: Esri, USGS, NOAA, OpenStreetMap contributors"
+}
+
 private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var annotationsByID: [String: MKPointAnnotation] = [:]
     private var overlaysByID: [String: MKPolyline] = [:]
@@ -1371,6 +1429,8 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var markerPinColors: [String: UIColor] = [:]
     private var tileOverlay: MKTileOverlay?
     private var tileTemplate: String?
+    private var tileReplacesMap = true
+    private var appliedBasemap: CraftBasemap?
     private var tileAttributionBottom: NSLayoutConstraint?
     private lazy var tileAttribution: UILabel = {
         let label = UILabel()
@@ -1395,6 +1455,10 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         isRotateEnabled = false
         let tap = UITapGestureRecognizer(target: self, action: #selector(pressedMap(_:)))
         tap.cancelsTouchesInView = false
+        // Alongside MapKit's own recognizers, not instead of them: on its own
+        // this tap won the touch, MapKit never selected the pin under it, and
+        // a pin's onPress (Explore's trail card) never fired on a phone.
+        tap.delegate = CraftMapTapDelegate.shared
         addGestureRecognizer(tap)
     }
 
@@ -1429,8 +1493,13 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         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])
+        if let basemap = (props["basemap"] as? String).flatMap({ CraftBasemap(rawValue: $0.lowercased()) }) {
+            applyBasemap(basemap)
+        } else {
+            appliedBasemap = nil
+            mapType = Self.mapType(props["mapType"] as? String)
+            configureTiles(props["tileOverlay"] as? [String: Any])
+        }
         showsCompass = props["showsCompass"] as? Bool ?? false
         showsScale = props["showsScale"] as? Bool ?? false
         authoredPitch = Self.numeric(props["cameraPitch"])
@@ -1562,7 +1631,9 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             overlayCoordinatesByID[id] = value.coordinates
             overlayColors[ObjectIdentifier(overlay)] = value.color
             overlayWidths[ObjectIdentifier(overlay)] = value.width
-            addOverlay(overlay)
+            // Above labels, as a basemap's topography is: at a lower level
+            // the outdoors layer covered every route drawn on it.
+            addOverlay(overlay, level: .aboveLabels)
         }
         let stalePolygons = polygonsByID.keys.filter { nextPolygons[$0] == nil }
         for id in stalePolygons {
@@ -1595,7 +1666,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             polygonFills[ObjectIdentifier(polygon)] = value.fill
             polygonStrokes[ObjectIdentifier(polygon)] = value.stroke
             polygonWidths[ObjectIdentifier(polygon)] = value.width
-            addOverlay(polygon)
+            addOverlay(polygon, level: .aboveLabels)
         }
         // Keep authored casing/foreground order when an earlier line changes
         // or retained children move. Exchanging native overlays preserves the
@@ -1684,20 +1755,48 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         tileAttribution.isHidden = true
     }
 
-    private func configureTiles(_ options: [String: Any]?) {
+    /// A named basemap. Applied once per change: setting a map configuration
+    /// again redraws the whole map.
+    private func applyBasemap(_ basemap: CraftBasemap) {
+        if appliedBasemap != basemap {
+            appliedBasemap = basemap
+            if #available(iOS 16.0, *) {
+                switch basemap {
+                case .satellite: preferredConfiguration = MKImageryMapConfiguration(elevationStyle: .realistic)
+                case .hybrid: preferredConfiguration = MKHybridMapConfiguration(elevationStyle: .realistic)
+                // Flat under the topography, so the overlay's contours sit
+                // on the ground they describe.
+                case .outdoors: preferredConfiguration = MKStandardMapConfiguration(elevationStyle: .flat, emphasisStyle: .muted)
+                case .standard: preferredConfiguration = MKStandardMapConfiguration(elevationStyle: .realistic)
+                }
+            }
+            else {
+                mapType = basemap == .satellite ? .satellite : basemap == .hybrid ? .hybrid : basemap == .outdoors ? .mutedStandard : .standard
+            }
+        }
+        configureTiles(basemap == .outdoors ? ["urlTemplate": CraftBasemap.outdoorTiles, "attribution": CraftBasemap.outdoorCredit] : nil, replacesMap: false)
+    }
+
+    /// `replacesMap`: an authored `tileOverlay` replaces Apple's map, as it
+    /// always has. A basemap's topography draws over it instead, above its
+    /// labels, so ground whose tiles have not come yet shows the map rather
+    /// than an empty grid.
+    private func configureTiles(_ options: [String: Any]?, replacesMap: Bool = true) {
         let template = options?["urlTemplate"] as? String
         let credit = options?["attribution"] as? String ?? ""
         let valid = template.map { value in value.hasPrefix("https://") && ["{z}", "{x}", "{y}"].allSatisfy { value.contains($0) } } ?? false
         let next = valid && !credit.isEmpty ? template : nil
-        if tileTemplate != next {
+        if tileTemplate != next || tileReplacesMap != replacesMap {
             if let overlay = tileOverlay { removeOverlay(overlay) }
             tileOverlay = nil
             tileTemplate = next
+            tileReplacesMap = replacesMap
             if let next {
-                let overlay = MKTileOverlay(urlTemplate: next)
-                overlay.canReplaceMapContent = true
+                let overlay = CraftCachedTileOverlay(urlTemplate: next)
+                overlay.canReplaceMapContent = replacesMap
+                overlay.maximumZ = 19
                 tileOverlay = overlay
-                insertOverlay(overlay, at: 0, level: .aboveRoads)
+                insertOverlay(overlay, at: 0, level: replacesMap ? .aboveRoads : .aboveLabels)
             }
         }
         tileAttribution.text = next == nil ? nil : credit
@@ -1756,11 +1855,27 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             view.tintColor = color
             view.image = Self.markerImage(color: color, direction: true)
             view.transform = CGAffineTransform(rotationAngle: CGFloat((bearing - camera.heading) * .pi / 180))
+            // Direction marks thin themselves: MapKit hides the ones that
+            // would overlap at this zoom and brings them back closer in, so
+            // a trail reads as a line with chevrons along it, not a column of
+            // badges over the route.
+            view.displayPriority = .defaultLow
+            view.collisionMode = .circle
+            // Decoration along the route: not a stop for VoiceOver.
+            view.isAccessibilityElement = false
         } else {
             let color = (markerPinColors[id] ?? .systemRed).resolvedColor(with: traitCollection)
             view.tintColor = color
             view.image = Self.markerImage(color: color, direction: false)
             view.transform = .identity
+            view.displayPriority = .required
+            view.collisionMode = .rectangle
+            // Above the user's own location: at a trailhead - where the map
+            // is most often opened - the dot sat on the trail's pin and took
+            // every tap meant for it.
+            if #available(iOS 14.0, *) { view.zPriority = .max }
+            view.isAccessibilityElement = true
+            view.accessibilityTraits = .button
         }
     }
 
@@ -1771,9 +1886,10 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     }()
 
     private static func markerImage(color: UIColor, direction: Bool) -> UIImage {
-        let key = "\(direction ? "direction" : "pin"):\(color.description)" as NSString
+        let key = "\(direction ? "chevron" : "pin"):\(color.description)" as NSString
         if let cached = markerImages.object(forKey: key) { return cached }
-        let size = direction ? CGSize(width: 20, height: 24) : CGSize(width: 28, height: 28)
+        if direction { return directionImage(color: color, key: key) }
+        let size = CGSize(width: 28, height: 28)
         // Explicit native drawing preserves the light backing independently
         // of MapKit's tint and SF Symbols' multicolor rendering preferences.
         let image = UIGraphicsImageRenderer(size: size).image { _ in
@@ -1787,7 +1903,32 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             let symbol = UIImage(systemName: direction ? "arrow.up" : "mappin",
                 withConfiguration: UIImage.SymbolConfiguration(pointSize: 16, weight: .semibold))?
                 .withTintColor(color, renderingMode: .alwaysOriginal)
-            symbol?.draw(in: direction ? CGRect(x: 5, y: 6, width: 10, height: 12) : CGRect(x: 7, y: 5, width: 14, height: 18))
+            symbol?.draw(in: CGRect(x: 7, y: 5, width: 14, height: 18))
+        }.withRenderingMode(.alwaysOriginal)
+        markerImages.setObject(image, forKey: key)
+        return image
+    }
+
+    /// A route's direction: a 16-point chevron in the route's colour with a
+    /// white edge, so it sits on the line it describes and stays legible
+    /// over topography and imagery alike.
+    private static func directionImage(color: UIColor, key: NSString) -> UIImage {
+        let size = CGSize(width: 16, height: 16)
+        let image = UIGraphicsImageRenderer(size: size).image { context in
+            let chevron = UIBezierPath()
+            chevron.move(to: CGPoint(x: 8, y: 2.5))
+            chevron.addLine(to: CGPoint(x: 13.5, y: 12))
+            chevron.addLine(to: CGPoint(x: 8, y: 9.25))
+            chevron.addLine(to: CGPoint(x: 2.5, y: 12))
+            chevron.close()
+            chevron.lineJoinStyle = .round
+            context.cgContext.setShadow(offset: .zero, blur: 1.5, color: UIColor.black.withAlphaComponent(0.25).cgColor)
+            UIColor.white.setStroke()
+            chevron.lineWidth = 3
+            chevron.stroke()
+            context.cgContext.setShadow(offset: .zero, blur: 0, color: nil)
+            color.setFill()
+            chevron.fill()
         }.withRenderingMode(.alwaysOriginal)
         markerImages.setObject(image, forKey: key)
         return image
@@ -1844,9 +1985,12 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
 
     func mapView(_ mapView: MKMapView, viewFor annotation: MKAnnotation) -> MKAnnotationView? {
         guard let id = annotationsByID.first(where: { $0.value === annotation })?.key else { return nil }
-        let view = dequeueReusableAnnotationView(withIdentifier: "craft-native-marker")
-            ?? MKAnnotationView(annotation: annotation, reuseIdentifier: "craft-native-marker")
+        let view = (dequeueReusableAnnotationView(withIdentifier: "craft-native-marker") as? CraftMarkerAnnotationView)
+            ?? CraftMarkerAnnotationView(annotation: annotation, reuseIdentifier: "craft-native-marker")
         view.annotation = annotation
+        // Activated (VoiceOver, Switch Control, a UI test) as a tap would:
+        // the plain annotation view did nothing when activated.
+        view.onActivate = { [weak self] in self?.onMarkerTap?(id) }
         configureMarkerView(view, id: id)
         view.accessibilityIdentifier = id
         return view
@@ -2164,6 +2308,13 @@ extension UIView {
         set { objc_setAssociatedObject(self, &craftNativeLayoutStyleKey, CraftNativeLayoutStyleBox(newValue), .OBJC_ASSOCIATION_RETAIN_NONATOMIC) }
     }
 
+    /// The margins this view's style asks for, for a container that places
+    /// it without a flex parent (a FlatList cell).
+    var craftLayoutMargins: UIEdgeInsets {
+        let style = craftLayoutStyle
+        return UIEdgeInsets(top: max(0, style.marginTop), left: max(0, style.marginLeft), bottom: max(0, style.marginBottom), right: max(0, style.marginRight))
+    }
+
     /// The corner radius the style asked for. The layer gets at most half the
     /// shortest side: Core Animation draws nothing at all for a radius larger
     /// than the view (`rounded-full` is 9999).
@@ -3991,6 +4142,16 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
     }
 }
 
+/// The delegate of a map's own tap (`Map`'s onPress): it watches beside
+/// MapKit's recognizers, so a tap on a pin still selects it.
+final class CraftMapTapDelegate: NSObject, UIGestureRecognizerDelegate {
+    static let shared = CraftMapTapDelegate()
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        true
+    }
+}
+
 /// 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
@@ -4328,9 +4489,13 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
 /// 3 quadratic, 4 close, in viewBox units - and scaled to the view. Paint is
 /// inherited down the tree as SVG does; `dark:` classes arrive already
 /// resolved for the appearance, so a redraw is all a theme change needs.
-private final class CraftNativeSvgView: UIView {
+final class CraftNativeSvgView: UIView {
     var drawing: [String: Any] = [:] {
-        didSet { setNeedsDisplay() }
+        didSet {
+            animates = Self.hasAnimation(drawing["children"] as? [Any] ?? [])
+            setNeedsDisplay()
+            updateFrames()
+        }
     }
 
     override init(frame: CGRect) {
@@ -4338,10 +4503,123 @@ private final class CraftNativeSvgView: UIView {
         isOpaque = false
         backgroundColor = .clear
         contentMode = .redraw
+        NotificationCenter.default.addObserver(self, selector: #selector(reduceMotionChanged), name: UIAccessibility.reduceMotionStatusDidChangeNotification, object: nil)
     }
 
     required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
 
+    deinit { CraftNativeFrameClock.shared.cancel(self) }
+
+    // MARK: Animation
+
+    /// Whether a shape carries keyframes (SMIL `<animate attributeName="d">`,
+    /// stx's `Animate`: an exercise's moving figure).
+    private var animates = false
+    /// When this drawing's repetition began: each one starts from its first
+    /// pose when it comes on screen, as a page's SMIL starts when it loads.
+    private var animationStart: CFTimeInterval?
+
+    /// Moving now: on display, and the person has not asked for less motion,
+    /// when each shape keeps its own outline (the still pose).
+    var isAnimating: Bool { animates && window != nil && !isHidden && !UIAccessibility.isReduceMotionEnabled }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        updateFrames()
+    }
+
+    override var isHidden: Bool {
+        didSet { if isHidden != oldValue { updateFrames() } }
+    }
+
+    @objc private func reduceMotionChanged() {
+        updateFrames()
+        setNeedsDisplay()
+    }
+
+    /// Frames from the screens' display link (CraftNativeFrameClock, up to
+    /// 120Hz) while moving; none at all while still or out of sight.
+    private func updateFrames() {
+        if isAnimating {
+            if animationStart == nil { animationStart = CACurrentMediaTime() }
+            CraftNativeFrameClock.shared.request(self) { [weak self] in self?.nextFrame() }
+        } else {
+            animationStart = nil
+            CraftNativeFrameClock.shared.cancel(self)
+        }
+    }
+
+    private func nextFrame() {
+        guard isAnimating else { return updateFrames() }
+        // Drawn only while some of it is on screen; a row scrolled away keeps
+        // its time and is right when it comes back.
+        if let window, window.bounds.intersects(convert(bounds, to: window)) { setNeedsDisplay() }
+        CraftNativeFrameClock.shared.request(self) { [weak self] in self?.nextFrame() }
+    }
+
+    private static func hasAnimation(_ children: [Any]) -> Bool {
+        children.contains { child in
+            guard let node = child as? [String: Any] else { return false }
+            if node["type"] as? String == "Animate" { return (node["props"] as? [String: Any])?["frames"] != nil }
+            return hasAnimation(node["children"] as? [Any] ?? [])
+        }
+    }
+
+    /// A shape's outline now: between the keyframes either side of `elapsed`
+    /// seconds into its animation (SMIL's linear `calcMode`), or its own
+    /// outline when it has none, the animation has ended, or motion is reduced.
+    private func outline(of shape: [String: Any]) -> Any? {
+        let geometry = (shape["props"] as? [String: Any])?["geometry"]
+        guard isAnimating, let start = animationStart,
+              let animate = (shape["children"] as? [Any])?.lazy.compactMap({ $0 as? [String: Any] }).first(where: { $0["type"] as? String == "Animate" }),
+              let current = Self.keyframe(animate["props"] as? [String: Any] ?? [:], at: CACurrentMediaTime() - start) else { return geometry }
+        return current
+    }
+
+    /// The outline `elapsed` seconds into an `Animate`'s repetitions; nil
+    /// when it does not animate path data or its repetitions are over.
+    static func keyframe(_ props: [String: Any], at elapsed: CFTimeInterval) -> [Any]? {
+        guard props["attributeName"] as? String == "d",
+              let duration = number(props["duration"]), duration > 0, duration.isFinite,
+              let frames = (props["frames"] as? [Any])?.compactMap({ ($0 as? [Any])?.compactMap(number) }),
+              frames.count >= 2, elapsed >= 0 else { return nil }
+        if let count = number(props["repeatCount"]), elapsed >= Double(count * duration) { return nil }
+        let given = (props["frameTimes"] as? [Any])?.compactMap(number) ?? []
+        let times = given.count == frames.count ? given : frames.indices.map { CGFloat($0) / CGFloat(frames.count - 1) }
+        let phase = CGFloat(elapsed.truncatingRemainder(dividingBy: Double(duration))) / duration
+        var index = 0
+        while index < frames.count - 2, times[index + 1] <= phase { index += 1 }
+        let from = frames[index]
+        let to = frames[index + 1]
+        let span = times[index + 1] - times[index]
+        let share = span > 0 ? min(1, max(0, (phase - times[index]) / span)) : 0
+        return interpolate(from, to, share).map { NSNumber(value: Double($0)) }
+    }
+
+    /// Two outlines with the same commands, a share of the way from one to
+    /// the other; the first as it is when their commands differ.
+    static func interpolate(_ from: [CGFloat], _ to: [CGFloat], _ share: CGFloat) -> [CGFloat] {
+        guard from.count == to.count, share > 0 else { return from }
+        var out = from
+        var i = 0
+        while i < from.count {
+            let command = Int(from[i])
+            guard to[i] == from[i] else { return from }
+            let count: Int
+            switch command {
+            case 0, 1: count = 2
+            case 2: count = 6
+            case 3: count = 4
+            case 4: count = 0
+            default: return from
+            }
+            guard i + count < from.count else { return from }
+            if count > 0 { for k in 1...count { out[i + k] = from[i + k] + (to[i + k] - from[i + k]) * share } }
+            i += count + 1
+        }
+        return out
+    }
+
     var viewBox: CGRect? {
         let props = drawing["props"] as? [String: Any] ?? [:]
         guard let box = props["viewBox"] as? [Any], box.count == 4 else { return nil }
@@ -4461,8 +4739,10 @@ private final class CraftNativeSvgView: UIView {
                 draw(children: shape["children"] as? [Any] ?? [], paint: own, in: context)
             case "SvgText":
                 drawText(shape, paint: own)
+            case "Animate":
+                continue
             default:
-                guard let path = CraftNativeSvgView.path((shape["props"] as? [String: Any])?["geometry"]) else { continue }
+                guard let path = CraftNativeSvgView.path(outline(of: shape)) else { continue }
                 context.saveGState()
                 path.usesEvenOddFillRule = own.fillRule == "evenodd"
                 if let fill = own.resolve(own.fill) {
@@ -4859,9 +5139,24 @@ enum CraftNativeScriptThread {
     static let queue = DispatchQueue(label: "craft.native.script", qos: .userInteractive)
 
     /// `work` where the screens' JavaScript runs: now on the main thread, or
-    /// queued in order on the script thread.
-    static func run(_ work: @escaping () -> Void) {
-        if isBackground { queue.async(execute: work) } else { work() }
+    /// queued in order on the script thread. With frame pacing on
+    /// (`CRAFT_FRAME_PACING=1`), work that waited or ran for 4ms or more is
+    /// logged under `label`, so a slow screen can be told from a queued one.
+    static func run(label: @autoclosure @escaping () -> String = "script", _ work: @escaping () -> Void) {
+        let pacing = CraftFramePacing.shared
+        guard pacing.enabled else {
+            if isBackground { queue.async(execute: work) } else { work() }
+            return
+        }
+        let queued = CACurrentMediaTime()
+        let timed = {
+            let started = CACurrentMediaTime()
+            work()
+            let ran = CACurrentMediaTime() - started
+            let waited = started - queued
+            if waited + ran >= 0.004 { pacing.scriptWork(label(), waited: waited, ran: ran) }
+        }
+        if isBackground { queue.async(execute: timed) } else { timed() }
     }
 
     /// From the script thread, `work` on the main thread, not waited for.
@@ -4954,6 +5249,17 @@ enum CraftNativeBundle {
     /// is not parsed again. Each screen keeps a global object of its own.
     static let virtualMachine = JSVirtualMachine()!
 
+    /// JavaScriptCore's first machine and context, made on the script thread
+    /// at launch instead of on the main thread by the first screen: that one-
+    /// time setup was a quarter of a second of the first tab's mount, all of
+    /// it in front of the first frame. Nothing is evaluated, so the main
+    /// thread never waits on the machine for it.
+    static func prewarm() {
+        CraftNativeScriptThread.queue.async {
+            _ = JSContext(virtualMachine: virtualMachine)
+        }
+    }
+
     private static let sources: NSCache<NSString, NSString> = {
         let cache = NSCache<NSString, NSString>()
         // Room for the one-file bundle, or a dozen route files.
@@ -5241,7 +5547,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let pacing = CraftFramePacing.shared
         let inputs = scriptInputs()
         let name = routeName ?? "screen"
-        CraftNativeScriptThread.run { [self] in
+        CraftNativeScriptThread.run(label: "mount \(name)") { [self] in
             pacing.measure("mount \(name) setup") { setupJavaScript(inputs) }
             pacing.measure("mount \(name) bundle") { loadBundle() }
         }
@@ -5302,8 +5608,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         screenVisibilityChanged(false)
         stopCelebrations(in: view)
         // Release only this screen's accessory. A retained or prepared screen
-        // can disappear after the destination has already published its own.
-        CraftChrome.shared.clearTabAccessory(ownedBy: self)
+        // can disappear after the destination has already published its own;
+        // released, it stays drawn until the destination says what it wants.
+        CraftChrome.shared.releaseTabAccessory(ownedBy: self)
         // Popped (or its stack dismissed) while the bar was away: it comes
         // back for whatever shows next, a web page included.
         if tabBarHidden, isMovingFromParent || isBeingDismissed || navigationController?.isBeingDismissed == true {
@@ -5348,7 +5655,11 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func restoreShellChrome() {
         guard !isAppScript else { return }
         CraftChrome.shared.setHiddenByScreen(tabBarHidden)
-        CraftChrome.shared.updateTabAccessory(tabAccessory, owner: self)
+        // A screen not yet asked about the accessory (one shown for the first
+        // time, before its script has run) leaves the bar as it is; one that
+        // has drawn without asking for it takes off what nobody claims.
+        if tabAccessoryDeclared { CraftChrome.shared.updateTabAccessory(tabAccessory, owner: self) }
+        else if hybridRendered { CraftChrome.shared.clearUnclaimedTabAccessory() }
     }
 
     /// `requestAnimationFrame`: the next display frame, for a screen on display
@@ -5365,7 +5676,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         guard frameWanted, !runtimeDisposed else { return }
         frameWanted = false
         let context = jsContext
-        CraftNativeScriptThread.run { context.objectForKeyedSubscript("__craftNativeFireFrame")?.call(withArguments: []) }
+        let route = routeName ?? "screen"
+        CraftNativeScriptThread.run(label: "frame \(route)") { context.objectForKeyedSubscript("__craftNativeFireFrame")?.call(withArguments: []) }
     }
 
     /// The screen came on screen or went off it: a screen pushed over it was
@@ -5400,7 +5712,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         routeProps = props
         guard isViewLoaded, !runtimeDisposed else { return }
         let context = jsContext
-        CraftNativeScriptThread.run {
+        let route = routeName ?? "screen"
+        CraftNativeScriptThread.run(label: "params \(route)") {
             context.setObject(params as NSDictionary, forKeyedSubscript: "__stxNativeParams" as NSString)
             context.setObject(props as NSDictionary, forKeyedSubscript: "__stxNativeProps" as NSString)
         }
@@ -5414,7 +5727,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         CraftNativeFrameClock.shared.cancel(self)
         disposeRenderedTree()
         let context = jsContext
-        CraftNativeScriptThread.run { context.objectForKeyedSubscript("__stxNativeUnmount")?.call(withArguments: []) }
+        let route = routeName ?? "screen"
+        CraftNativeScriptThread.run(label: "unmount \(route)") { context.objectForKeyedSubscript("__stxNativeUnmount")?.call(withArguments: []) }
         audio.close()
         sounds.close()
         streams.close()
@@ -6215,6 +6529,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// The app's tab bar away while this screen shows (`tabBarHidden`).
     private var tabBarHidden = false
     private var tabAccessory: [String: Any]?
+    /// Whether the screen has said anything about the accessory yet
+    /// (`tabAccessory`, null included): until it has, the bar keeps showing
+    /// the one it had (CraftChrome.releaseTabAccessory).
+    private var tabAccessoryDeclared = false
     /// Whether a back-swipe may leave this screen at all, the edge's
     /// included (`swipeBack: false`): a screen that steps through its own
     /// pages with a Back of its own (a first-run tour's questions) would
@@ -6263,6 +6581,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         guard !isAppScript else { return }
         if options.keys.contains("tabAccessory") {
             tabAccessory = options["tabAccessory"] as? [String: Any]
+            tabAccessoryDeclared = true
             if navigationController?.topViewController === self, view.window != nil {
                 CraftChrome.shared.updateTabAccessory(tabAccessory, owner: self)
             }
@@ -6652,7 +6971,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 let previous = info["previous"] as? String
                 self.send(type: "SESSION_CHANGED", payload: ["key": key, "token": token ?? NSNull(), "previous": previous ?? NSNull()])
                 let context = self.jsContext
-                CraftNativeScriptThread.run { context.objectForKeyedSubscript("__craftSessionChanged")?.call(withArguments: [token ?? NSNull(), previous ?? NSNull()]) }
+                CraftNativeScriptThread.run(label: "session \(self.routeName ?? "screen")") { context.objectForKeyedSubscript("__craftSessionChanged")?.call(withArguments: [token ?? NSNull(), previous ?? NSNull()]) }
             })
         }
         if config.enablePushNotifications {
@@ -6937,8 +7256,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             }
             let module = payload["module"] as? String ?? ""
             let method = payload["method"] as? String ?? ""
+            // With frame pacing on: how long the capability took to answer,
+            // which a screen's script waits on (a request, the keychain).
+            let pacing = CraftFramePacing.shared
+            let asked = pacing.enabled ? CACurrentMediaTime() : 0
+            let route = routeName ?? "screen"
+            let what = module == "Network" ? "\(module).\(method) \(((args.first as? [String: Any])?["url"] as? String).flatMap { URL(string: $0)?.path } ?? "")" : "\(module).\(method)"
             let reply: (Result<Any, CraftNativeActionError>) -> Void = { [weak self] answer in
                 guard let self = self, self.pendingCapabilityRequests.remove(requestToken) != nil else { return }
+                if pacing.enabled { pacing.capability("\(what) \(route)", took: CACurrentMediaTime() - asked) }
                 self.pendingCapabilityDeadlines.removeValue(forKey: requestToken)?.cancel()
                 self.screenRequestCancellers.removeValue(forKey: requestToken)
                 switch answer {
@@ -7167,6 +7493,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             hybridRendered = true
             // The app script's drawing is never on screen: not a first frame.
             if !isAppScript { hybridEvents?.nativeScreenDidRender(self) }
+            // Drawn without a word about the accessory: it wants none.
+            if !isAppScript, !tabAccessoryDeclared, isShownOnScreen { CraftChrome.shared.clearUnclaimedTabAccessory() }
             let waiting = renderWaiters
             renderWaiters.removeAll()
             waiting.forEach { $0() }
@@ -8486,8 +8814,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// Views that take their own touches whatever handlers the screen gives
     /// them: native controls, a scroll view, a modal, and a video's controls (with
     /// interaction off, its play, scrubber and full screen never answered).
+    /// A map and a wheel picker too: neither is a UIControl, so a map with no
+    /// long-press handler - every map - was made non-interactive, and could
+    /// not be panned, zoomed, or have a pin tapped; a picker could not be spun.
     private func ownsTouches(_ view: UIView) -> Bool {
         view is UIControl || view is UIScrollView || view is CraftNativeModalView || view is CraftNativeVideoView
+            || view is MKMapView || view is UIPickerView
     }
 
     private func updatePressHandler(_ handler: String?, for view: UIView) {
@@ -9832,7 +10164,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         guard let data = try? JSONSerialization.data(withJSONObject: message),
               let json = String(data: data, encoding: .utf8) else { return }
         let context = jsContext
-        CraftNativeScriptThread.run { context.objectForKeyedSubscript("__stxNativeCallback")?.call(withArguments: [json]) }
+        let route = routeName ?? "screen"
+        CraftNativeScriptThread.run(label: "\(type) \(route)") { context.objectForKeyedSubscript("__stxNativeCallback")?.call(withArguments: [json]) }
     }
 
     private func number(_ value: Any?) -> CGFloat? {