craft-native 0.0.254 → 0.0.262

package/dist/ios/templates/CraftApp.swift

@@ -686,6 +686,9 @@ final class CraftChrome: ObservableObject {
     /// Whether a hybrid page lets the shell claim horizontal swipes for tabs.
     /// Native screens use their own per-screen `tabSwipeEnabled` option.
     private(set) var tabSwipeEnabled = true
+    /// The selected tab highlight's corner radius. Nil preserves the default
+    /// capsule, while a finite non-negative value opts into a rounded rect.
+    private(set) var tabSelectionCornerRadius: CGFloat?
 
     weak var webView: WKWebView?
     /// What the tab bar covers at the bottom of the screen, in points.
@@ -823,6 +826,7 @@ final class CraftChrome: ObservableObject {
         switch body["type"] as? String {
         case "tabBar":
             pendingHide?.cancel()
+            tabSelectionCornerRadius = Self.selectionCornerRadius(body["selection"])
             tabs = (body["tabs"] as? [[String: Any]] ?? []).compactMap { item in
                 guard let id = item["id"] as? String, let title = item["title"] as? String else { return nil }
                 let badge = (item["badge"] as? String).flatMap { $0.isEmpty ? nil : $0 }
@@ -872,6 +876,15 @@ final class CraftChrome: ObservableObject {
         }
     }
 
+    private static func selectionCornerRadius(_ value: Any?) -> CGFloat? {
+        guard let selection = value as? [String: Any],
+              let raw = selection["cornerRadius"] as? NSNumber,
+              raw.doubleValue.isFinite,
+              raw.doubleValue >= 0,
+              raw.doubleValue <= Double(CGFloat.greatestFiniteMagnitude) else { return nil }
+        return CGFloat(raw.doubleValue)
+    }
+
     /// A tap on a tab: the page navigates, and says which tab is current.
     ///
     /// No haptic. UITabBar plays none, and a tab bar that ticks on every tap is
@@ -1175,7 +1188,7 @@ struct CraftTabBarView: View {
                     }
                     .foregroundStyle(isSelected ? selectedColor : Color.primary)
                     .frame(maxWidth: .infinity, minHeight: 54)
-                    .contentShape(Capsule())
+                    .contentShape(CraftTabSelectionShape(cornerRadius: chrome.tabSelectionCornerRadius))
                 }
                 .buttonStyle(.plain)
                 .accessibilityShowsLargeContentViewer {
@@ -1188,7 +1201,11 @@ struct CraftTabBarView: View {
             }
         }
         .background {
-            CraftTabSelectionIndicator(selected: chrome.tabs.firstIndex(where: { $0.id == chrome.selected }), count: chrome.tabs.count)
+            CraftTabSelectionIndicator(
+                selected: chrome.tabs.firstIndex(where: { $0.id == chrome.selected }),
+                count: chrome.tabs.count,
+                cornerRadius: chrome.tabSelectionCornerRadius
+            )
         }
     }
 
@@ -1230,18 +1247,33 @@ struct CraftTabBarView: View {
     }
 }
 
+private struct CraftTabSelectionShape: Shape {
+    let cornerRadius: CGFloat?
+
+    func path(in rect: CGRect) -> Path {
+        if let cornerRadius {
+            return RoundedRectangle(
+                cornerRadius: min(cornerRadius, min(rect.width, rect.height) / 2),
+                style: .continuous
+            ).path(in: rect)
+        }
+        return Capsule().path(in: rect)
+    }
+}
+
 private struct CraftTabSelectionIndicator: View {
     @ObservedObject private var progress = CraftChrome.shared.tabSwipeProgress
     let selected: Int?
     let count: Int
+    let cornerRadius: CGFloat?
 
     var body: some View {
         GeometryReader { geometry in
             if let position = progress.position ?? selected.map({ CGFloat($0) }) {
                 let width = geometry.size.width / CGFloat(max(1, count))
-                Capsule()
-                    .fill(Color.primary.opacity(0.09))
+                CraftTabSelectionShape(cornerRadius: cornerRadius)
                     .frame(width: width, height: geometry.size.height)
+                    .foregroundStyle(Color.primary.opacity(0.09))
                     .offset(x: position * width)
             }
         }

package/dist/ios/templates/CraftHealth.swift

@@ -43,6 +43,19 @@ private final class CraftHealthWorkoutDelegate: NSObject, HKWorkoutSessionDelega
     }
 }
 
+@available(iOS 26.0, *)
+private final class CraftHealthWorkoutBuilderDelegate: NSObject, HKLiveWorkoutBuilderDelegate {
+    weak var owner: CraftHealth?
+
+    init(owner: CraftHealth) { self.owner = owner }
+
+    func workoutBuilder(_ workoutBuilder: HKLiveWorkoutBuilder, didCollectDataOf collectedTypes: Set<HKSampleType>) {
+        owner?.emitLiveWorkoutMetrics(workoutBuilder)
+    }
+
+    func workoutBuilderDidCollectEvent(_ workoutBuilder: HKLiveWorkoutBuilder) {}
+}
+
 /// Apple Health for the whole app: the web page's bridge (`craft.health` in
 /// the hybrid's web view, CraftApp.swift) and native screens alike
 /// (`Health` through CraftNativeActions), so a screen drawn natively reads
@@ -837,12 +850,15 @@ final class CraftHealth {
             let session = try HKWorkoutSession(healthStore: healthStore, configuration: configuration)
             let builder = session.associatedWorkoutBuilder()
             let delegate = CraftHealthWorkoutDelegate(id: { [weak self] in self?.liveWorkoutID ?? "" }) { [weak self] detail in self?.sendWorkout(detail) }
+            let metricsDelegate = CraftHealthWorkoutBuilderDelegate(owner: self)
             session.delegate = delegate
+            builder.delegate = metricsDelegate
             builder.shouldCollectWorkoutEvents = true
             builder.dataSource = HKLiveWorkoutDataSource(healthStore: healthStore, workoutConfiguration: configuration)
             liveWorkoutSession = session
             liveWorkoutBuilder = builder
             liveWorkoutDelegate = delegate
+            liveWorkoutBuilderDelegate = metricsDelegate
             liveWorkoutID = UUID().uuidString.lowercased()
             liveWorkoutType = type
             liveWorkoutStart = Date()
@@ -923,11 +939,32 @@ final class CraftHealth {
         liveWorkoutSession = nil
         liveWorkoutBuilder = nil
         liveWorkoutDelegate = nil
+        liveWorkoutBuilderDelegate = nil
         liveWorkoutID = nil
         liveWorkoutType = nil
         liveWorkoutStart = nil
     }
 
+    @available(iOS 26.0, *)
+    fileprivate func emitLiveWorkoutMetrics(_ builder: HKLiveWorkoutBuilder) {
+        guard let id = liveWorkoutID else { return }
+        var detail: [String: Any] = ["id": id, "event": "metrics", "date": Date().timeIntervalSince1970 * 1000]
+        let bpm = HKUnit.count().unitDivided(by: .minute())
+        if let type = HKQuantityType.quantityType(forIdentifier: .heartRate),
+           let value = builder.statistics(for: type)?.mostRecentQuantity()?.doubleValue(for: bpm), value.isFinite {
+            detail["heartRateBpm"] = value
+        }
+        if let type = HKQuantityType.quantityType(forIdentifier: .activeEnergyBurned),
+           let value = builder.statistics(for: type)?.sumQuantity()?.doubleValue(for: .kilocalorie()), value.isFinite {
+            detail["activeEnergyCalories"] = value
+        }
+        if let type = HKQuantityType.quantityType(forIdentifier: .distanceWalkingRunning),
+           let value = builder.statistics(for: type)?.sumQuantity()?.doubleValue(for: .meter()), value.isFinite {
+            detail["distanceMeters"] = value
+        }
+        onMain { [weak self] in self?.sendWorkout(detail) }
+    }
+
     private static func workoutActivity(_ type: String) -> HKWorkoutActivityType? {
         switch type {
         case "running": return .running
@@ -965,6 +1002,7 @@ final class CraftHealth {
     private var liveWorkoutSession: AnyObject?
     private var liveWorkoutBuilder: AnyObject?
     private var liveWorkoutDelegate: AnyObject?
+    private var liveWorkoutBuilderDelegate: AnyObject?
     private var liveWorkoutID: String?
     private var liveWorkoutType: String?
     private var liveWorkoutStart: Date?

package/dist/ios/templates/CraftHybrid.swift

@@ -1076,6 +1076,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 +1187,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 +1202,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 +1220,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 +1240,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 +1589,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()

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")

package/dist/ios/templates/CraftNativeFlatList.swift

@@ -63,11 +63,22 @@ 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 }
+            // 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)
@@ -81,10 +92,16 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
 
         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 {
@@ -279,10 +296,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.