craft-native 0.0.254 → 0.0.272

package/dist/ios/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] = [
@@ -1076,6 +1078,18 @@ final class CraftHybridWebSlot: UIViewController {
     }
 }
 
+/// A native stack lets the top screen consume Back for its presented modal
+/// before UIKit removes the screen from the navigation stack.
+final class CraftNativeNavigationController: UINavigationController {
+    override func popViewController(animated: Bool) -> UIViewController? {
+        if let screen = topViewController as? CraftNativeScreenController,
+           screen.handleBackForModal() {
+            return nil
+        }
+        return super.popViewController(animated: animated)
+    }
+}
+
 final class CraftHybridController: UIViewController, UINavigationControllerDelegate, UIGestureRecognizerDelegate, CraftHybridScreenEvents {
     private let config: CraftConfig
     private let hybrid = CraftHybrid.shared
@@ -1175,6 +1189,10 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         tabSwipeRecognizers.append(recognizer)
     }
 
+    private func shouldCompleteTabSwipe(progress: CGFloat, speed: CGFloat) -> Bool {
+        speed > -700 && (progress >= max(32, view.bounds.width * 0.28) || speed > 700)
+    }
+
     @objc private func tabSwipeRecognized(_ recognizer: UIPanGestureRecognizer) {
         // A finger that lands while the last swipe settles takes the screens
         // from where they are, as a paging scroll view does. This swipe used
@@ -1186,7 +1204,10 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         let translation = recognizer.translation(in: view).x
         let velocity = recognizer.velocity(in: view).x
         switch recognizer.state {
-        case .changed:
+        case .began, .changed:
+            // Catching a settle can begin at zero translation. Keep its
+            // committed selection until the new finger actually moves.
+            if recognizer.state == .began, caughtSettle != nil, abs(translation) <= 1 { return }
             if activeTabSwipeTarget == nil {
                 let direction = abs(translation) > 1 ? translation : velocity
                 guard abs(direction) > 1 else { return }
@@ -1201,9 +1222,14 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
                 // the caught screens finish where they were going.
                 if caughtSettle != nil { settleCaughtScreens(); return }
                 guard recognizer.state == .ended else { return }
-                let delta = abs(translation) >= 32 ? translation : velocity
-                guard abs(delta) >= 32 else { return }
-                let next = delta < 0 ? index + 1 : index - 1
+                // UIKit can coalesce a short gesture without a changed
+                // callback. Keep the same completion rule as the animated
+                // path instead of treating any 32-point drag as a full page.
+                let direction = abs(translation) > 1 ? translation : velocity
+                guard abs(direction) > 1 else { return }
+                let sign: CGFloat = direction < 0 ? -1 : 1
+                guard shouldCompleteTabSwipe(progress: translation * sign, speed: velocity * sign) else { return }
+                let next = direction < 0 ? index + 1 : index - 1
                 guard tabs.indices.contains(next) else { return }
                 CraftChrome.shared.swipe(to: tabs[next])
                 return
@@ -1216,8 +1242,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             let direction: CGFloat = tabSwipeFrom > 0 ? -1 : 1
             let progress = (translation + tabSwipeBase) * direction
             let speed = velocity * direction
-            let complete = recognizer.state == .ended && speed > -700
-                && (progress >= max(32, view.bounds.width * 0.28) || speed > 700)
+            let complete = recognizer.state == .ended && shouldCompleteTabSwipe(progress: progress, speed: speed)
             finishInteractiveTabSwipe(completed: complete, velocity: velocity) { [weak self] in
                 CraftFramePacing.shared.end("tab swipe")
                 self?.activeTabSwipeTarget = nil
@@ -1566,7 +1591,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         // Constructing the navigation controller can load the root's view and
         // mount its script immediately. Set its initial focus before that.
         if hidden { (root as? CraftNativeScreenController)?.screenVisibilityChanged(false) }
-        let nav = UINavigationController(rootViewController: root)
+        let nav = CraftNativeNavigationController(rootViewController: root)
         nav.delegate = self
         nav.view.backgroundColor = config.resolvedBackgroundColor
         nav.additionalSafeAreaInsets.bottom = safeAreaForTabBar()
@@ -2011,6 +2036,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
@@ -2278,6 +2305,22 @@ final class CraftFramePacing: NSObject {
         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/dist/ios/templates/CraftNativeActions.swift

@@ -42,7 +42,7 @@ enum CraftNativeActions {
     static func capabilities(config: CraftConfig) -> [String] {
         // `speech`, `audio` (background sound) and `eventStream` (a fetch read
         // as it arrives) need nothing the app has to declare.
-        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge", "animation", "viewFocus", "viewMeasure", "viewReparent"]
+        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge", "animation", "viewFocus", "viewMeasure", "viewReparent", "viewNonModalPresentation"]
         values.append("storageCompareAndSet")
         values.append("storageSetIfAbsent")
         values.append("viewScroll")
@@ -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/dist/ios/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()
@@ -63,32 +65,66 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
             onRecycle = nil
         }
 
+        /// Whether the row view this cell is meant to show is in it. UIKit
+        /// can prepare a second cell for a row (a prefetch, an update), and
+        /// the row's one view then moves there: the first cell keeps its
+        /// height and draws nothing.
+        var showsHostedView: Bool { hostedView.map { $0.superview === contentView } ?? true }
+
         func host(_ view: UIView, identity: String) {
             if let shown = representedIdentity, shown != identity { recycle() }
             representedIdentity = identity
-            guard hostedView !== view else { return }
-            hostedView?.removeFromSuperview()
+            // 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 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.
+            if let shown = hostedView, shown !== view, shown.superview === contentView { shown.removeFromSuperview() }
             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() {
             recycle()
-            hostedView?.removeFromSuperview()
+            if let shown = hostedView, shown.superview === contentView { shown.removeFromSuperview() }
             hostedView = nil
         }
 
+        /// Puts this cell's row view back when another cell took it.
+        func reclaimHostedView() {
+            guard let identity = representedIdentity, let view = hostedView, view.superview !== contentView else { return }
+            host(view, identity: identity)
+        }
+
         override func preferredLayoutAttributesFitting(
             _ 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.
@@ -104,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
         }
@@ -167,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()
@@ -279,10 +325,22 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
     override func layoutSubviews() {
         updateItemEstimate()
         super.layoutSubviews()
+        reclaimVisibleRows()
         craftApplyCornerRadius()
         scrollToPendingTarget()
     }
 
+    /// A row on screen whose view went to a cell UIKit prepared for the same
+    /// row and then did not show gets it back, rather than staying blank.
+    private func reclaimVisibleRows() {
+        for case let cell as Cell in visibleCells where !cell.showsHostedView { cell.reclaimHostedView() }
+    }
+
+    /// Every row on screen draws its own view (simulator-hosted XCTest).
+    var visibleRowsShowTheirViews: Bool {
+        visibleCells.allSatisfy { ($0 as? Cell)?.showsHostedView ?? true }
+    }
+
     /// Scroll to a virtualized row identified by its native testID, id, or key.
     /// The row need not be mounted yet; the data snapshot is enough to find its
     /// index, and UIKit will mount it as part of the scroll.
@@ -310,6 +368,7 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
         guard key != scrollTargetKey else { return }
         scrollTargetKey = key
         pendingScrollTarget = (id, animated, 0)
+        cancelEndSettle()
         scrollToPendingTarget()
     }
 
@@ -509,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
@@ -540,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)
     }
@@ -607,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)
@@ -620,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/dist/ios/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() })