@craft-native/ios 0.0.254 → 0.0.262

package/README.md

@@ -77,11 +77,19 @@ decoration. Resuming does not replay it. Available on both native renderers.
 The iOS support is built into the main `craft` CLI:
 
 `Pressable`, `TouchableOpacity`, and `TouchableHighlight` render as native
-pressable flow containers. `Modal` renders a parent-scoped blocking layer in native mode, with `visible`,
-`transparent`, `animationType`, `onShow`, `onDismiss`, and `onRequestClose`
-support. `FlatList` item roots receive the same `onLayout` callback as ordinary native
+pressable flow containers. `Modal` renders a parent-scoped native layer in native mode, with `visible`,
+`transparent`, `nonModal`, `dismissOnOutsideTap`, `animationType`, `onShow`,
+`onDismiss`, and `onRequestClose` support. Non-modal popups remain pass-through
+unless outside-tap dismissal is explicitly enabled. `FlatList` item roots receive the same `onLayout` callback as ordinary native
 views when rows are materialized or recycled.
 
+`View.measure` and non-modal `left`/`top` placement use the same `screenViewport`
+coordinate space. Safe-area and navigation-bar offsets are not added implicitly;
+anchored callers must clamp against the measured viewport when needed. Re-run
+measurement after the anchor or screen root emits `onLayout`, and after every
+`onScroll` from an ancestor; those are the host-neutral invalidation signals for
+repositioning an anchored popup.
+
 ```bash
 bun add craft-native
 ```
@@ -151,6 +159,9 @@ bounds and corners through layout changes.
 
 The opt-in `native` renderer hosts compiled `.stx` screens in JavaScriptCore and renders their `View`, `SafeAreaView`, `KeyboardAvoidingView`, `StatusBar`, `RefreshControl`, `Text`, `Button`, `Link`, `Checkbox`, `TextInput`, `Picker`, `DatePicker`, `Switch`, `Slider`, `ActivityIndicator`, `Icon`, `Image`, `ImageBackground`, `Video`, `Map`, `Svg`, `G`, `SvgText`, `ScrollView`, `SectionList`, and recycling `FlatList` nodes as UIKit controls. `StatusBar` and `RefreshControl` are screen/scroll utility nodes rather than visible children. `Map` uses MapKit for trail polylines and marker taps; its overlays carry flat latitude/longitude `geometry` arrays, `strokeWidth` is expressed in logical points, and the camera supports controlled `region`, one-time `initialRegion`, and `fitToBounds`. `Svg` is a DOM-free drawing surface; grouped `G` and `SvgText` nodes are painted inside it. `Icon` uses SF Symbols with the shared symbol/name contract and accessibility metadata. `SectionList` uses the same native scroll host for ordinary `.stx` slot children; grouped section data should use `FlatList` until the section-data protocol is available. `FlatList` uses `UICollectionView` with stable keyed rows, incremental diffs, grids, horizontal and inverted layouts, list chrome, and end-reached pagination. Native views support `onLayout` callbacks with point-based frame measurements that refresh after safe-area or orientation changes. Flex items support `flex`, `flexGrow`, `flexShrink`, and numeric `flexBasis` for main-axis space distribution. Native screens also expose the versioned capability bridge: JSON storage and SQLite survive relaunch, lifecycle and deep-link events are scoped to the top route, and local notifications use `UNUserNotificationCenter`. Enable each capability in `craft.config.json`; disabled calls preserve Craft's `CAPABILITY_DISABLED` rejection code and every request has deterministic timeout/cancellation behavior. The default remains `web`; existing iOS apps are unchanged. `Checkbox` supports controlled `checked`/`value`, indeterminate state, and boolean `onValueChange`; `Picker` renders `<select>`/`<option>` values with `onValueChange` or `onChange`; `DatePicker` emits local date/time values plus ISO and millisecond `timestamp` fields; `Switch` supports state-aware `trackColor`, `thumbColor`, and iOS `ios_backgroundColor`; `Slider` supports track/thumb tint props and `step` snapping; `Image` reports load lifecycle events and structured failures; `Video` uses an `AVPlayerViewController` attached to the native screen for URI playback, native controls, and route-safe teardown. `craft.navigation.setOptions` also accepts a `tabAccessory` destination beside the tab pill; it uses an app-local `path`, `title`, `symbol`, optional `badge`, and `accessibilityLabel`, and `null` clears it. The portable component, capability, list, style, image-source, event, accessibility, and reconciliation behavior is specified in the [Native STX guide](../../docs/guides/native-stx.md).
 
+`FlatList` rows are authored as keyed `:for` child rows in native STX; the
+maintained protocol does not serialize `data`/`renderItem` callbacks.
+
 JavaScriptCore has no DOM `window`; Craft aliases `globalThis.window` to
 `globalThis` before installing the native bridge so browser-safe SDK calls such
 as `window.craft.dialog.actionSheet()` reach the native capability host. This
@@ -220,9 +231,9 @@ Follow it with `selected` and content checks, then a full `swipe` to verify the
 next gesture still works. Synchronized XCTest gestures do not replace separate
 direct-input rapid-tap checks.
 
-The iOS host uses the shared tree-layout ABI for eligible definite-size,
-non-grid, non-wrapped containers and retains a local fallback for older
-runtimes or unsupported styles. Both paths implement wrapped-line and grid
+The iOS host uses the shared tree-layout ABI for eligible definite-size
+containers, including reverse and wrap-reverse direct flows, and retains a
+local fallback for older runtimes or unsupported styles. Both paths implement wrapped-line and grid
 `alignContent`, including `space-evenly`, so a missing optional shared symbol
 does not change placement semantics.
 Reverse flex directions also retain wrapped line order on the cross axis while

package/package.json

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

package/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/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/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/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/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.

package/templates/CraftNativeScreen.swift

@@ -1090,6 +1090,8 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
     private var playingObservation: NSKeyValueObservation?
     private var timeObserver: Any?
     private var loops = false
+    private var requestedTime: Double?
+    private var pendingSeek: Double?
     private var wasPlaying: Bool?
     private var playIntent: Bool?
     private var userPaused = false
@@ -1097,7 +1099,8 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
     /// This video holds a claim on the audio session (`CraftNativeSounds`).
     private var claimedSession = false
     /// The screen's handlers by event name (`onEnd`, `onPlay`, `onPause`,
-    /// `onProgress`, `onLoad`, `onError`), and how an event reaches them.
+    /// `onProgress`, `onLoadStart`, `onLoad`, `onLoadEnd`, `onError`), and how
+    /// an event reaches them.
     var handlers: [String: String] = [:]
     var emit: ((_ handler: String, _ nativeEvent: [String: Any]) -> Void)?
 
@@ -1170,8 +1173,21 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
         CraftNativeSounds.releaseSession()
     }
 
-    func configure(source: Any?, autoplay: Bool, paused: Bool, loop: Bool, muted: Bool, controls: Bool, resizeMode: String?, pictureInPicture: Bool = false) {
+    private func applyPendingSeek() {
+        guard let target = pendingSeek, let player, let item = player.currentItem, item.status == .readyToPlay else { return }
+        let current = seconds(player.currentTime())
+        pendingSeek = nil
+        guard abs(current - target) > 0.25 else { return }
+        player.seek(to: CMTime(seconds: target, preferredTimescale: 600))
+    }
+
+    func configure(source: Any?, autoplay: Bool, paused: Bool, loop: Bool, muted: Bool, currentTime: Any?, controls: Bool, resizeMode: String?, pictureInPicture: Bool = false) {
         let uri = (source as? String) ?? (source as? [String: Any])?["uri"] as? String ?? ""
+        let nextTime = number(currentTime).map(Double.init).map { max(0, $0) }
+        if nextTime != requestedTime {
+            requestedTime = nextTime
+            pendingSeek = nextTime
+        }
         let nextShouldPlay = autoplay && !paused
         if playIntent != nextShouldPlay {
             userPaused = false
@@ -1184,6 +1200,7 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
             userPaused = false
             ended = false
             loops = false
+            pendingSeek = requestedTime
             // The copy `craft.media.keep` put on the phone plays in place of
             // the address, so a kept video plays with no signal.
             let kept = CraftNativeMedia.local(uri)
@@ -1200,11 +1217,13 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
                 return
             }
             let next = AVPlayer(url: url)
+            fire("onLoadStart")
             player = next
             playerController.player = next
             observe(next)
         }
         guard let player else { return }
+        applyPendingSeek()
         player.isMuted = muted
         // A muted video makes no sound, so it leaves the session as it is.
         if muted { releaseSession() } else { claimSession() }
@@ -1258,7 +1277,10 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
                 DispatchQueue.main.async {
                     guard let self, self.player?.currentItem === item else { return }
                     switch item.status {
-                    case .readyToPlay: self.fire("onLoad", ["duration": self.seconds(item.duration)])
+                    case .readyToPlay:
+                        self.applyPendingSeek()
+                        self.fire("onLoad", ["duration": self.seconds(item.duration)])
+                        self.fire("onLoadEnd")
                     case .failed: self.fire("onError", ["message": item.error?.localizedDescription ?? "The video could not be played"])
                     default: break
                     }
@@ -1306,6 +1328,8 @@ private final class CraftNativeVideoView: UIView, AVPlayerViewControllerDelegate
         playerController.player = nil
         playerController.delegate = nil
         sourceURI = ""
+        requestedTime = nil
+        pendingSeek = nil
         playIntent = nil
         userPaused = false
         ended = false
@@ -2022,6 +2046,8 @@ private struct CraftNativeLayoutStyle {
     let bottom: CGFloat?
     let left: CGFloat?
     let alignSelf: String?
+    /// CSS/Yoga order; equal values retain source order.
+    let order: Int
     let flexGrow: CGFloat
     /// Nil when the style does not say: the parent picks the default for the
     /// kind of view (text shrinks along a row, a box does not).
@@ -2059,6 +2085,7 @@ private struct CraftNativeLayoutStyle {
         left = number(raw["left"])
         let align = raw["alignSelf"] as? String
         alignSelf = align == "auto" ? nil : align
+        order = number(raw["order"]).map { Int($0.rounded(.towardZero)) } ?? 0
         // `flex: n` is the web's and React Native's shorthand: a positive
         // number grows by n, shrinks, and starts from nothing, so `flex-1`
         // siblings share a row equally whatever their content.
@@ -2516,6 +2543,7 @@ final class CraftNativeCelebration {
             group.duration = 2.2 + Double(spread) * 0.45
             group.beginTime = now + Double(index % 7) * 0.018
             group.fillMode = .backwards
+            group.atDisplayRate()
             piece.add(group, forKey: "craft.celebration.particle")
         }
 
@@ -2529,6 +2557,7 @@ final class CraftNativeCelebration {
         entrance.stiffness = 160
         entrance.mass = 1
         entrance.duration = 0.95
+        entrance.atDisplayRate()
         view.layer.add(entrance, forKey: "craft.celebration.entrance")
 
         let sheen = CAGradientLayer()
@@ -2554,6 +2583,7 @@ final class CraftNativeCelebration {
         shine.animations = [sweep, light]
         shine.duration = 1.15
         shine.beginTime = now + 0.55
+        shine.atDisplayRate()
         sheen.add(shine, forKey: "craft.celebration.sweep")
         let cleanup = DispatchWorkItem { [weak self] in self?.stop() }
         self.cleanup = cleanup
@@ -2886,7 +2916,15 @@ private class CraftNativeFlowView: UIStackView {
 
     /// Children that take part in the flow: shown, not a modal overlay.
     private var visibleChildren: [UIView] {
-        flowChildren.filter { $0.superview === self && !$0.isHidden && !($0 is CraftNativeModalView) }
+        flowChildren.enumerated()
+            .filter { $0.element.superview === self && !$0.element.isHidden && !($0.element is CraftNativeModalView) }
+            .sorted {
+                if $0.element.craftLayoutStyle.order != $1.element.craftLayoutStyle.order {
+                    return $0.element.craftLayoutStyle.order < $1.element.craftLayoutStyle.order
+                }
+                return $0.offset < $1.offset
+            }
+            .map(\.element)
     }
 
     /// Builds the eligible portion of this container for the host-neutral
@@ -3088,7 +3126,8 @@ private class CraftNativeFlowView: UIStackView {
                 frames: &frames
             )
         }
-        if place, flow.count == children.count, let sharedTree = sharedTreeFrames(flow, width: width, height: height), (sharedTree.nodes.count > flow.count + 1 || grid) {
+        if place, flow.count == children.count, let sharedTree = sharedTreeFrames(flow, width: width, height: height),
+           (sharedTree.nodes.count > flow.count + 1 || grid || reverse || wrapReverse || gridAutoRows != nil || gridRows != nil) {
             frames = []
             for index in 1..<sharedTree.nodes.count {
                 guard let view = sharedTree.nodes[index].view else { continue }
@@ -3795,6 +3834,17 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
         didSet { blocker.backgroundColor = transparent ? .clear : UIColor.black.withAlphaComponent(0.32) }
     }
 
+    /// Existing Modal nodes block by default. A non-modal popup keeps the
+    /// screen-level overlay but lets hit testing fall through outside its
+    /// interactive content.
+    var blocksBackground = true {
+        didSet { blocker.isUserInteractionEnabled = blocksBackground }
+    }
+    /// An opt-in non-modal dismissal policy. The default popup remains
+    /// pass-through; when enabled, an outside tap is consumed and routed to
+    /// onRequestClose instead of reaching the view below.
+    var dismissOnOutsideTap = false
+
     override init(frame: CGRect) {
         super.init(frame: frame)
         isUserInteractionEnabled = true
@@ -3876,10 +3926,13 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
         transform = .identity
         alpha = 0
         isUserInteractionEnabled = true
+        blocksBackground = true
+        dismissOnOutsideTap = false
         onRequestClose = nil
     }
 
     func requestClose(reason: String = "backdrop") {
+        guard blocksBackground || dismissOnOutsideTap else { return }
         guard let onRequestClose else { return }
         isUserInteractionEnabled = false
         onRequestClose(reason)
@@ -3912,6 +3965,14 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
                 candidate = view.superview
             }
         }
+        if !blocksBackground {
+            // A dismissible popup consumes its outside hit so the close event
+            // cannot also activate the screen below. Otherwise it owns the
+            // hit only when a blocking modal is underneath it; with no modal
+            // below, the screen remains pass-through.
+            if dismissOnOutsideTap { return self }
+            return craftScreenController?.hasBlockingModalBelow(self) == true ? self : nil
+        }
         return blocker.hitTest(blocker.convert(point, from: self), with: event)
     }
 
@@ -4824,6 +4885,62 @@ enum CraftNativeScriptThread {
     }
 }
 
+extension CAAnimation {
+    /// Asks for the display's full rate, up to 120Hz on ProMotion. Core
+    /// Animation otherwise picks a rate for the motion and often stays at 60;
+    /// a transition or a spring the eye follows reads smoother at 120.
+    func atDisplayRate() {
+        if #available(iOS 15.0, *) { preferredFrameRateRange = CAFrameRateRange(minimum: 80, maximum: 120, preferred: 120) }
+    }
+}
+
+/// `requestAnimationFrame` for native screens: one display link, at the
+/// display's own rate (up to 120Hz on a ProMotion iPhone, which the app
+/// allows with `CADisableMinimumFrameDurationOnPhone`), running only while a
+/// screen on display is waiting for a frame. Each frame hands every waiting
+/// screen one `__craftNativeFireFrame`, where its script runs; a screen asks
+/// again for the frame after, as a browser's page does. A screen out of sight
+/// waits until it is shown, as a browser pauses a hidden tab's frames, and as
+/// Craft's Android host does (Choreographer). Main thread only.
+final class CraftNativeFrameClock: NSObject {
+    static let shared = CraftNativeFrameClock()
+
+    private var waiting: [ObjectIdentifier: () -> Void] = [:]
+    private var link: CADisplayLink?
+
+    /// How many screens wait for the next frame.
+    var waitingCount: Int { waiting.count }
+    /// Whether the display link is counting frames now.
+    var isRunning: Bool { link.map { !$0.isPaused } ?? false }
+
+    /// `deliver` on the next frame, once. Asking again before it comes keeps one.
+    func request(_ owner: AnyObject, _ deliver: @escaping () -> Void) {
+        waiting[ObjectIdentifier(owner)] = deliver
+        if link == nil {
+            let link = CADisplayLink(target: self, selector: #selector(frame(_:)))
+            if #available(iOS 15.0, *) {
+                link.preferredFrameRateRange = CAFrameRateRange(minimum: 30, maximum: 120, preferred: 120)
+            }
+            link.add(to: .main, forMode: .common)
+            self.link = link
+        }
+        link?.isPaused = false
+    }
+
+    /// `owner` no longer waits: it went out of sight or away.
+    func cancel(_ owner: AnyObject) {
+        waiting.removeValue(forKey: ObjectIdentifier(owner))
+        if waiting.isEmpty { link?.isPaused = true }
+    }
+
+    @objc private func frame(_ link: CADisplayLink) {
+        let due = waiting
+        waiting.removeAll()
+        if waiting.isEmpty { link.isPaused = true }
+        due.values.forEach { $0() }
+    }
+}
+
 /// The native screens' JavaScript. A screen is a JavaScriptCore context of
 /// its own and evaluates the whole file it is given, so each route has a file
 /// of its own when stx wrote one (`dist/native-screens/<route>.js`, stx's
@@ -4900,6 +5017,25 @@ enum CraftNativeBundle {
     }
 }
 
+private final class CraftNativeScreenRootView: UIView {
+    weak var controller: CraftNativeScreenController?
+
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        // A popup's host frame is only its authored card, so UIKit would not
+        // ask it about an outside point. Shield that point at the screen root
+        // only when a blocking modal is underneath; ordinary non-modal
+        // overlays remain pass-through.
+        if let controller {
+            for modal in controller.view.subviews.compactMap({ $0 as? CraftNativeModalView }).reversed()
+                where !modal.blocksBackground && !modal.isHidden && modal.alpha > 0.01 {
+                let local = modal.convert(point, from: self)
+                if !modal.bounds.contains(local) && (modal.dismissOnOutsideTap || controller.hasBlockingModalBelow(modal)) { return modal }
+            }
+        }
+        return super.hitTest(point, with: event)
+    }
+}
+
 final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate, UITextFieldDelegate, UITextViewDelegate, UIPickerViewDataSource, UIPickerViewDelegate {
     private final class RenderedNode {
         /// A recycled list row's root takes the identity of the row it shows next.
@@ -4952,6 +5088,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var scrollMomentumEndHandlers: [ObjectIdentifier: String] = [:]
     private var sliderCompleteHandlers: [ObjectIdentifier: String] = [:]
     private var sliderSteps: [ObjectIdentifier: Float] = [:]
+    /// A controlled switch can be reconciled while UIKit is still animating
+    /// the user's tap. Remember that native value briefly so the echo does not
+    /// interrupt the animation and leave the thumb painted at its old edge.
+    private var switchUserValues: [ObjectIdentifier: Bool] = [:]
     private var pickerOptions: [ObjectIdentifier: [(value: String, label: String)]] = [:]
     private var modalVisibility: [ObjectIdentifier: Bool] = [:]
     private var modalFocusRestore: [ObjectIdentifier: UIView] = [:]
@@ -5026,6 +5166,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         var pending: [Int: DispatchWorkItem] = [:]
     }
     private let timers = Timers()
+    /// The script asked for an animation frame it has not had yet
+    /// (`requestAnimationFrame`, CraftNativeFrameClock). Main thread only.
+    private var frameWanted = false
     private var lifecycleObservers: [NSObjectProtocol] = []
     private var deepLinkListener: UUID?
     private var keyboardSafeAreaInset: CGFloat = 0
@@ -5056,6 +5199,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         fatalError("init(coder:) has not been implemented")
     }
 
+    override func loadView() {
+        let root = CraftNativeScreenRootView()
+        root.controller = self
+        view = root
+    }
+
     deinit {
         disposeRuntime()
         imageTasks.values.forEach { $0.cancel() }
@@ -5202,6 +5351,23 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         CraftChrome.shared.updateTabAccessory(tabAccessory, owner: self)
     }
 
+    /// `requestAnimationFrame`: the next display frame, for a screen on display
+    /// (or the app script, which is never shown). One out of sight keeps the
+    /// request until it is shown again (screenVisibilityChanged).
+    private func requestFrame() {
+        guard !runtimeDisposed, !frameWanted else { return }
+        frameWanted = true
+        guard isAppScript || reportedVisible != false else { return }
+        CraftNativeFrameClock.shared.request(self) { [weak self] in self?.fireFrame() }
+    }
+
+    private func fireFrame() {
+        guard frameWanted, !runtimeDisposed else { return }
+        frameWanted = false
+        let context = jsContext
+        CraftNativeScriptThread.run { context.objectForKeyedSubscript("__craftNativeFireFrame")?.call(withArguments: []) }
+    }
+
     /// The screen came on screen or went off it: a screen pushed over it was
     /// popped, or the hybrid shell switched to or away from its tab (which
     /// hides a stack rather than moving it, so UIKit says nothing). The first
@@ -5216,6 +5382,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // preview also restores a screen that never lost focus, so restore its
         // chrome even when no new SCREEN_FOCUS event is needed.
         if visible { restoreShellChrome() }
+        if visible, frameWanted { CraftNativeFrameClock.shared.request(self) { [weak self] in self?.fireFrame() } }
+        if !visible { CraftNativeFrameClock.shared.cancel(self) }
         guard visible != reportedVisible else { return }
         let first = reportedVisible == nil
         reportedVisible = visible
@@ -5242,6 +5410,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func disposeRuntime() {
         guard !runtimeDisposed else { return }
         runtimeDisposed = true
+        frameWanted = false
+        CraftNativeFrameClock.shared.cancel(self)
         disposeRenderedTree()
         let context = jsContext
         CraftNativeScriptThread.run { context.objectForKeyedSubscript("__stxNativeUnmount")?.call(withArguments: []) }
@@ -5312,9 +5482,58 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if bar.intersects(view.bounds) { insets.top = max(insets.top, bar.maxY) }
         }
         for modal in modals {
-            if modal.frame != view.bounds { modal.frame = view.bounds }
-            modal.contentInsets = insets
+            guard !modal.blocksBackground else {
+                if modal.frame != view.bounds { modal.frame = view.bounds }
+                modal.contentInsets = insets
+                continue
+            }
+
+            // Non-modal overlays are viewport children, not full-screen
+            // scrims. Their absolute style uses the same full screenViewport
+            // origin that View.measure returns. Safe-area-aware placement is
+            // owned by the caller (for example, STX's anchor/clamp logic), so
+            // an authored left/top is never shifted by an implicit inset.
+            let viewport = view.bounds
+            let style = modal.craftLayoutStyle
+            let width = style.left != nil && style.right != nil
+                ? max(0, viewport.width - (style.left ?? 0) - (style.right ?? 0))
+                : style.width?.resolve(viewport.width)
+                    ?? min(viewport.width, modal.contentStack.sizeThatFits(viewport.size).width)
+            let height = style.top != nil && style.bottom != nil
+                ? max(0, viewport.height - (style.top ?? 0) - (style.bottom ?? 0))
+                : style.height?.resolve(viewport.height)
+                    ?? min(viewport.height, modal.contentStack.sizeThatFits(viewport.size).height)
+            let x = viewport.minX + (style.left ?? (style.right.map { viewport.width - $0 - width } ?? 0))
+            let y = viewport.minY + (style.top ?? (style.bottom.map { viewport.height - $0 - height } ?? 0))
+            let frame = CGRect(x: x, y: y, width: width, height: height)
+            if modal.frame != frame { modal.frame = frame }
+            // The frame already excludes the safe area; inset the content no
+            // further or authored top/left coordinates would be shifted twice.
+            modal.contentInsets = .zero
+        }
+    }
+
+    /// A non-modal popup above a blocking modal must not leak its outside tap
+    /// to the modal's scrim and dismiss the wrong layer.
+    fileprivate func hasBlockingModalBelow(_ modal: CraftNativeModalView) -> Bool {
+        guard let index = view.subviews.firstIndex(where: { $0 === modal }) else { return false }
+        return view.subviews[..<index].contains { candidate in
+            guard let other = candidate as? CraftNativeModalView else { return false }
+            return other.blocksBackground && !other.isHidden && other.alpha > 0.01
+        }
+    }
+
+    /// The native route's Back button dismisses the top presented modal before
+    /// it pops the route, matching Android's activity back callback.
+    @discardableResult
+    func handleBackForModal() -> Bool {
+        let modal = view.subviews.reversed().compactMap { $0 as? CraftNativeModalView }.first {
+            !$0.isHidden && $0.alpha > 0.01 && ($0.blocksBackground || $0.dismissOnOutsideTap)
         }
+        guard let modal else { return false }
+        let hasHandler = modal.onRequestClose != nil
+        modal.requestClose(reason: "back")
+        return hasHandler
     }
 
     private static func safeJavaScriptString(_ value: JSValue?) -> String? {
@@ -5415,6 +5634,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         jsContext.setObject(scheduleTimer, forKeyedSubscript: "craftNativeScheduleTimer" as NSString)
         jsContext.setObject(cancelTimer, forKeyedSubscript: "craftNativeCancelTimer" as NSString)
+        // The next display frame, from the script's thread; the frame itself
+        // comes back there as `__craftNativeFireFrame`.
+        let requestFrame: @convention(block) () -> Void = { [weak self] in
+            CraftNativeScriptThread.toMain { self?.requestFrame() }
+        }
+        jsContext.setObject(requestFrame, forKeyedSubscript: "craftNativeRequestFrame" as NSString)
         let capabilityJSON = inputs.capabilityJSON
         // The app's site and build, as JSON strings: the site an all-native
         // app's paths and links belong to (`devServerURL`), and the version a
@@ -5450,6 +5675,41 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         jsContext.evaluateScript(Self.nativeWebAPICompatibilityPrelude)
         installHostAPIs()
         jsContext.evaluateScript("""
+            // requestAnimationFrame on the display's frames (CraftNativeFrameClock),
+            // at its own rate, 120 a second on ProMotion: a timer guessing at 60
+            // would cap every animation a screen draws itself. One request covers
+            // every callback for the frame; a callback that throws does not stop
+            // the others, and is reported after them.
+            if (typeof globalThis.requestAnimationFrame !== 'function') {
+                (function() {
+                    var frames = [];
+                    var cancelled = new Set();
+                    var nextFrame = 0;
+                    globalThis.requestAnimationFrame = function(callback) {
+                        if (typeof callback !== 'function') return 0;
+                        var id = ++nextFrame;
+                        frames.push({ id: id, callback: callback });
+                        if (frames.length === 1) craftNativeRequestFrame();
+                        return id;
+                    };
+                    globalThis.cancelAnimationFrame = function(id) {
+                        if (frames.some(function(frame) { return frame.id === id; })) cancelled.add(id);
+                    };
+                    globalThis.__craftNativeFireFrame = function() {
+                        var due = frames;
+                        var skip = cancelled;
+                        frames = [];
+                        cancelled = new Set();
+                        var now = globalThis.performance && typeof globalThis.performance.now === 'function' ? globalThis.performance.now() : Date.now();
+                        var failures = [];
+                        for (var i = 0; i < due.length; i++) {
+                            if (skip.has(due[i].id)) continue;
+                            try { due[i].callback(now); } catch (error) { failures.push(error); }
+                        }
+                        failures.forEach(function(error) { globalThis.setTimeout(function() { throw error; }, 0); });
+                    };
+                })();
+            }
             if (typeof globalThis.setTimeout !== 'function') {
                 (function() {
                     var timers = new Map();
@@ -7328,6 +7588,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let modal = result as! CraftNativeModalView
             let focusBeforeContent = firstResponder(in: rootStack) ?? lastFocusedInput
             modal.transparent = props["transparent"] as? Bool == true
+            modal.blocksBackground = props["nonModal"] as? Bool != true
+            modal.dismissOnOutsideTap = props["dismissOnOutsideTap"] as? Bool == true
             let visible: Bool
             if let propVisible = props["visible"] as? Bool {
                 // An explicit visible prop owns modal visibility. The
@@ -7385,7 +7647,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 // UIKit has already changed the value before emitting the
                 // event. Echoing it through the script must not restart its
                 // native animation.
-                if toggle.isOn != value { toggle.isOn = value }
+                let id = ObjectIdentifier(toggle)
+                if switchUserValues[id] != value, toggle.isOn != value {
+                    // Programmatic changes should settle immediately. A
+                    // native tap is handled above without touching UIKit
+                    // while its own thumb animation is in flight.
+                    toggle.setOn(value, animated: false)
+                }
             }
             toggle.isEnabled = props["disabled"] as? Bool != true
             if let track = props["trackColor"] as? [String: Any] {
@@ -7512,6 +7780,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 paused: (props["paused"] as? Bool) == true,
                 loop: (props["loop"] as? Bool) == true,
                 muted: (props["muted"] as? Bool) == true,
+                currentTime: props["currentTime"],
                 controls: (props["controls"] as? Bool) == true,
                 resizeMode: style["resizeMode"] as? String ?? props["resizeMode"] as? String,
                 pictureInPicture: (props["pictureInPicture"] as? Bool) == true
@@ -8104,6 +8373,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         imageLoadEndHandlers.removeValue(forKey: id)
         imageErrorHandlers.removeValue(forKey: id)
         checkboxIndeterminate.removeValue(forKey: id)
+        switchUserValues.removeValue(forKey: id)
         if let video = node.view as? CraftNativeVideoView { video.stop() }
         if let map = node.view as? CraftNativeMapView { map.destroy() }
         for child in node.children { forgetHandlers(child, preservingInputDrafts: preservingInputDrafts) }
@@ -9086,7 +9356,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let hasLinkTarget = ["href", "to"].contains { !(props[$0] as? String ?? "").isEmpty }
         let linkedControl = ["Link", "TouchableOpacity", "TouchableHighlight", "Pressable"].contains(type) && hasLinkTarget
         let touchable = ["TouchableOpacity", "TouchableHighlight", "Pressable"].contains(type)
-        let role = (props["accessibilityRole"] as? String) ?? (linkedControl ? "link" : touchable ? "button" : nil)
+        let role = (props["accessibilityRole"] as? String)
+            ?? (linkedControl ? "link" : touchable ? "button" : ["FlatList", "SectionList"].contains(type) ? "list" : nil)
         // A scroll view, a list or a group of controls holds what VoiceOver
         // reads: its label names the group, as a tab strip or a pager's
         // name, and never stands in for its content. As an element of its
@@ -9281,7 +9552,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     @objc private func switchChanged(_ sender: UISwitch) {
-        guard let handler = handlers[ObjectIdentifier(sender)] else { return }
+        let id = ObjectIdentifier(sender)
+        switchUserValues[id] = sender.isOn
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) { [weak self, weak sender] in
+            guard let self, let sender, self.switchUserValues[id] == sender.isOn else { return }
+            self.switchUserValues.removeValue(forKey: id)
+        }
+        guard let handler = handlers[id] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": sender.isOn]])
     }
 
@@ -9962,6 +10239,7 @@ extension CraftNativeScreenController {
             }
             animation.fromValue = from
             let key = "\(CraftNativeRunningAnimation.key).\(keyPath)"
+            animation.atDisplayRate()
             layer.add(animation, forKey: key)
             running.layers.append((layer, key))
         }