@craft-native/ios 0.0.387 → 0.0.392

package/package.json

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

package/templates/CraftHybrid.swift

@@ -1,6 +1,13 @@
 import Foundation
 import SwiftUI
 import UIKit
+
+/// Includes deceleration, which runs in default mode after tracking ends.
+func craftHybridHasActiveScroll(in view: UIView) -> Bool {
+    if let scroll = view as? UIScrollView,
+       scroll.isTracking || scroll.isDragging || scroll.isDecelerating { return true }
+    return view.subviews.contains { craftHybridHasActiveScroll(in: $0) }
+}
 import WebKit
 import Combine
 
@@ -1261,9 +1268,14 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
             item.accessibilityLabel = tab.accessibilityLabel ?? tab.displayTitle
         }
         if let committed = stacks[currentTab], controllers.contains(where: { $0 === committed }), selectedViewController !== committed {
-            UIView.performWithoutAnimation {
-                selectedViewController = committed
-                view.layoutIfNeeded()
+            // UIKit owns the Liquid Glass selection pill. Suppressing this
+            // transaction made a completed page swipe snap its indicator.
+            // Keep native selection animation and honour Reduce Motion.
+            let duration = UIAccessibility.isReduceMotionEnabled ? 0 : 0.22
+            UIView.animate(withDuration: duration, delay: 0,
+                           options: [.beginFromCurrentState, .allowUserInteraction]) {
+                self.selectedViewController = committed
+                self.tabBar.layoutIfNeeded()
             }
         }
         tabBar.tintColor = chrome.tint ?? config.tintColor.flatMap { UIColor(hex: $0) } ?? view.tintColor
@@ -1950,6 +1962,7 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
             guard self.currentTab == owner, self.view.window != nil else { return }
             let quietFor = neighbour ? 0.3 : 1.0
             guard self.activeTabSwipeTarget == nil, !self.tabSwipeSettling,
+                  !craftHybridHasActiveScroll(in: self.view),
                   !self.stacks.values.contains(where: { $0.transitionCoordinator != nil }),
                   CACurrentMediaTime() - self.lastNavigation >= quietFor else {
                 self.prepareAdjacentNativeTabs()

package/templates/CraftNativeActions.swift

@@ -272,19 +272,19 @@ enum CraftNativeActions {
             // A person picks, so the bridge never times it out.
             let options = args.first as? [String: Any] ?? [:]
             DispatchQueue.main.async {
-                CraftNativeFiles.pickImage(options, cameraEnabled: config.enableCamera) { completeFile(requestToken, $0, completion) }
+                CraftNativeFiles.pickImage(options, cameraEnabled: config.enableCamera, requestToken: requestToken, isCancelled: { isCancelled(requestToken) }) { completeFile(requestToken, $0, completion) }
             }
             return
         case ("Files", "pickVideo"):
             let options = args.first as? [String: Any] ?? [:]
             DispatchQueue.main.async {
-                CraftNativeFiles.pickVideo(options, isCancelled: { isCancelled(requestToken) }) { completeFile(requestToken, $0, completion) }
+                CraftNativeFiles.pickVideo(options, requestToken: requestToken, isCancelled: { isCancelled(requestToken) }) { completeFile(requestToken, $0, completion) }
             }
             return
         case ("Files", "pickFile"):
             let options = args.first as? [String: Any] ?? [:]
             DispatchQueue.main.async {
-                CraftNativeFiles.pickFile(options, isCancelled: { isCancelled(requestToken) }) { completeFile(requestToken, $0, completion) }
+                CraftNativeFiles.pickFile(options, requestToken: requestToken, isCancelled: { isCancelled(requestToken) }) { completeFile(requestToken, $0, completion) }
             }
             return
         case ("Files", "download"):
@@ -719,6 +719,7 @@ enum CraftNativeActions {
         context?.invalidate()
         #endif
         task?.cancel()
+        CraftNativeFiles.cancelPicker(requestToken: requestToken)
         CraftNativePasskeys.shared.cancel(requestToken: requestToken)
     }
 

package/templates/CraftNativeFiles.swift

@@ -121,7 +121,8 @@ enum CraftNativeFiles {
     /// larger than `maxPixels` on its longest side, upright, with no metadata
     /// (no location) left in it. Answers the file, or null when the person
     /// closed the picker. Main thread.
-    static func pickImage(_ options: [String: Any], cameraEnabled: Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+    static func pickImage(_ options: [String: Any], cameraEnabled: Bool, requestToken: String? = nil, isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        guard !isCancelled() else { done(.failure(importCancelled())); return }
         let maxPixels = craftNativeNumber(options["maxPixels"])
             .map { $0.doubleValue }
             .flatMap { value in
@@ -136,13 +137,6 @@ enum CraftNativeFiles {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
-        let finish: (Result<Any, CraftNativeActionError>) -> Void = { result in
-            DispatchQueue.main.async {
-                activePicker = nil
-                done(result)
-            }
-        }
-
         if source == "camera" {
             #if CRAFT_PERMISSION_CAMERA
             guard cameraEnabled else {
@@ -153,15 +147,9 @@ enum CraftNativeFiles {
                 done(.failure(CraftNativeActionError(code: "UNAVAILABLE", message: "This device has no camera")))
                 return
             }
-            let delegate = CameraDelegate(maxPixels: maxPixels, quality: quality, done: finish)
             let picker = UIImagePickerController()
             picker.sourceType = .camera
-            picker.delegate = delegate
-            activePicker = delegate
-            if !CraftPresenter.present(picker, from: nil) {
-                activePicker = nil
-                done(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the camera")))
-            }
+            presentCamera(picker, maxPixels: maxPixels, quality: quality, requestToken: requestToken, isCancelled: isCancelled, done: done)
             #else
             done(.failure(CraftNativeActionError(code: "CAPABILITY_DISABLED", message: "The camera was not enabled when this app was built")))
             #endif
@@ -177,13 +165,13 @@ enum CraftNativeFiles {
         configuration.selectionLimit = 1
         // The file as it is (HEIC stays HEIC): it is decoded once, below, at the size wanted.
         configuration.preferredAssetRepresentationMode = .current
-        let delegate = LibraryDelegate(maxPixels: maxPixels, quality: quality, done: finish)
+        let delegate = LibraryDelegate(maxPixels: maxPixels, quality: quality, requestToken: requestToken, isCancelled: isCancelled, done: done)
         let picker = PHPickerViewController(configuration: configuration)
         picker.delegate = delegate
+        delegate.controller = picker
         activePicker = delegate
         if !CraftPresenter.present(picker, from: nil) {
-            activePicker = nil
-            done(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the photo picker")))
+            delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the photo picker")))
         }
     }
 
@@ -228,56 +216,174 @@ enum CraftNativeFiles {
         return "\(base).jpg"
     }
 
-    private final class LibraryDelegate: NSObject, PHPickerViewControllerDelegate {
+    final class LibraryDelegate: NSObject, PHPickerViewControllerDelegate {
         let maxPixels: Int
         let quality: Double
+        let videoLimit: Int?
+        let requestToken: String?
+        let isCancelled: () -> Bool
         let done: (Result<Any, CraftNativeActionError>) -> Void
-
-        init(maxPixels: Int, quality: Double, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        weak var controller: PHPickerViewController?
+        private let stateLock = NSLock()
+        private var cancelled = false
+        private var answered = false
+        private var finished = false
+        private var progress: Progress?
+
+        init(maxPixels: Int = defaultMaxPixels, quality: Double = defaultQuality, videoLimit: Int? = nil, requestToken: String?, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
             self.maxPixels = maxPixels
             self.quality = quality
+            self.videoLimit = videoLimit
+            self.requestToken = requestToken
+            self.isCancelled = isCancelled
             self.done = done
         }
 
+        private func cancellationRequested() -> Bool {
+            stateLock.lock()
+            let value = cancelled
+            stateLock.unlock()
+            return value || isCancelled()
+        }
+
+        func cancel() {
+            guard !finished else { return }
+            stateLock.lock()
+            cancelled = true
+            stateLock.unlock()
+            answered = true
+            progress?.cancel()
+            controller?.dismiss(animated: false)
+            // A provider may ignore Progress.cancel or never answer. Release
+            // the UI now, retaining our own cancellation flag after the bridge
+            // drains its token so a late callback cannot resurrect the import.
+            finish(.failure(importCancelled()))
+        }
+
+        func finish(_ result: Result<Any, CraftNativeActionError>) {
+            DispatchQueue.main.async {
+                let cancelled = self.cancellationRequested()
+                if self.finished || cancelled {
+                    if case .success(let value) = result,
+                       let file = value as? [String: Any], let path = file["path"] as? String {
+                        CraftNativeFiles.remove(path)
+                    }
+                }
+                guard !self.finished else { return }
+                self.finished = true
+                self.progress = nil
+                self.controller?.dismiss(animated: false)
+                if activePicker === self { activePicker = nil }
+                self.done(cancelled ? .failure(importCancelled()) : result)
+            }
+        }
+
         func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
+            guard !answered else { return }
             picker.dismiss(animated: true)
             guard let provider = results.first?.itemProvider else {
-                done(.success(NSNull()))
+                answered = true
+                finish(.success(NSNull()))
                 return
             }
-            guard provider.hasItemConformingToTypeIdentifier(UTType.image.identifier) else {
-                done(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: "That is not a photo")))
+            load(provider)
+        }
+
+        func load(_ provider: NSItemProvider) {
+            guard !answered else { return }
+            answered = true
+            guard !cancellationRequested() else { finish(.failure(importCancelled())); return }
+            let type = videoLimit == nil ? UTType.image.identifier : UTType.movie.identifier
+            guard provider.hasItemConformingToTypeIdentifier(type) else {
+                finish(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: "The selected media has an unsupported type")))
                 return
             }
             let name = CraftNativeFiles.jpegName(provider.suggestedName)
-            let (maxPixels, quality, done) = (self.maxPixels, self.quality, self.done)
             // The file is only there for the length of this callback.
-            provider.loadFileRepresentation(forTypeIdentifier: UTType.image.identifier) { url, error in
+            progress = provider.loadFileRepresentation(forTypeIdentifier: type) { url, error in
+                guard !self.cancellationRequested() else { self.finish(.failure(importCancelled())); return }
+                if let limit = self.videoLimit {
+                    guard let url else {
+                        self.finish(.failure(CraftNativeActionError(code: "READ_ERROR", message: error?.localizedDescription ?? "The video could not be read")))
+                        return
+                    }
+                    self.finish(CraftNativeFiles.copyVideo(url, limit: limit, isCancelled: self.cancellationRequested))
+                    return
+                }
                 guard let url, let source = CGImageSourceCreateWithURL(url as CFURL, nil) else {
-                    done(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: error?.localizedDescription ?? "The photo could not be read")))
+                    self.finish(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: error?.localizedDescription ?? "The photo could not be read")))
                     return
                 }
-                done(CraftNativeFiles.writeJPEG(from: source, maxPixels: maxPixels, quality: quality, name: name))
+                self.finish(CraftNativeFiles.writeJPEG(from: source, maxPixels: self.maxPixels, quality: self.quality, name: name))
             }
         }
     }
 
     #if CRAFT_PERMISSION_CAMERA
-    private final class CameraDelegate: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+    /// The caller checks camera permission configuration and device availability
+    /// before constructing a camera picker. Keep presentation ownership here so
+    /// failure and cancellation use the same exactly-once settlement path.
+    static func presentCamera(_ picker: UIImagePickerController, maxPixels: Int, quality: Double, requestToken: String?, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        let delegate = CameraDelegate(maxPixels: maxPixels, quality: quality, requestToken: requestToken, isCancelled: isCancelled, done: done)
+        picker.delegate = delegate
+        delegate.controller = picker
+        activePicker = delegate
+        if !CraftPresenter.present(picker, from: nil) {
+            delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the camera")))
+        }
+    }
+
+    final class CameraDelegate: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
         let maxPixels: Int
         let quality: Double
+        let requestToken: String?
+        let isCancelled: () -> Bool
         let done: (Result<Any, CraftNativeActionError>) -> Void
+        weak var controller: UIImagePickerController?
+        private var answered = false
+        private var finished = false
+        private var cancelled = false
 
-        init(maxPixels: Int, quality: Double, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        init(maxPixels: Int, quality: Double, requestToken: String?, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
             self.maxPixels = maxPixels
             self.quality = quality
+            self.requestToken = requestToken
+            self.isCancelled = isCancelled
             self.done = done
         }
 
+        func cancel() {
+            guard !finished else { return }
+            cancelled = true
+            answered = true
+            controller?.dismiss(animated: false)
+            finish(.failure(importCancelled()))
+        }
+
+        func finish(_ result: Result<Any, CraftNativeActionError>) {
+            DispatchQueue.main.async {
+                let cancelled = self.cancelled || self.isCancelled()
+                if self.finished || cancelled {
+                    if case .success(let value) = result,
+                       let file = value as? [String: Any], let path = file["path"] as? String {
+                        CraftNativeFiles.remove(path)
+                    }
+                }
+                guard !self.finished else { return }
+                self.finished = true
+                self.controller?.dismiss(animated: false)
+                if activePicker === self { activePicker = nil }
+                self.done(cancelled ? .failure(importCancelled()) : result)
+            }
+        }
+
         func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
+            guard !answered else { return }
+            answered = true
+            guard !cancelled, !isCancelled() else { finish(.failure(importCancelled())); return }
             picker.dismiss(animated: true)
             guard let image = info[.originalImage] as? UIImage else {
-                done(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: "The photo could not be read")))
+                finish(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: "The photo could not be read")))
                 return
             }
             // Drawn at the size wanted, which also turns it upright.
@@ -289,17 +395,18 @@ enum CraftNativeFiles {
             format.opaque = true
             let drawn = UIGraphicsImageRenderer(size: size, format: format).image { _ in image.draw(in: CGRect(origin: .zero, size: size)) }
             guard let cgImage = drawn.cgImage else {
-                done(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: "The photo could not be read")))
+                finish(.failure(CraftNativeActionError(code: "DECODE_ERROR", message: "The photo could not be read")))
                 return
             }
             let formatter = DateFormatter()
             formatter.dateFormat = "yyyyMMdd_HHmmss"
-            done(CraftNativeFiles.writeJPEG(cgImage, quality: quality, name: "IMG_\(formatter.string(from: Date())).jpg"))
+            finish(CraftNativeFiles.writeJPEG(cgImage, quality: quality, name: "IMG_\(formatter.string(from: Date())).jpg"))
         }
 
         func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
-            picker.dismiss(animated: true)
-            done(.success(NSNull()))
+            guard !answered else { return }
+            answered = true
+            finish(.success(NSNull()))
         }
     }
 
@@ -309,7 +416,7 @@ enum CraftNativeFiles {
 
     /// System pickers grant access to just the selected video. Copy it while
     /// the provider's URL is valid; no movie bytes cross JavaScriptCore.
-    static func pickVideo(_ options: [String: Any], isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+    static func pickVideo(_ options: [String: Any], requestToken: String? = nil, isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         guard !isCancelled() else { done(.failure(importCancelled())); return }
         guard activePicker == nil else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
@@ -321,33 +428,30 @@ enum CraftNativeFiles {
                 guard value.isFinite else { return nil }
                 return Int(max(1, min(Double(512 * 1024 * 1024), value)))
             } ?? 512 * 1024 * 1024
-        let finish: (Result<Any, CraftNativeActionError>) -> Void = { result in
-            DispatchQueue.main.async { activePicker = nil; done(result) }
-        }
         if options["source"] as? String == "files" {
-            let delegate = VideoDocumentDelegate(limit: limit, isCancelled: isCancelled, done: finish)
+            let delegate = DocumentDelegate(limit: limit, video: true, requestToken: requestToken, isCancelled: isCancelled, done: done)
             var types: [UTType] = [.movie]
             if let webm = UTType(filenameExtension: "webm") { types.append(webm) }
             let picker = UIDocumentPickerViewController(forOpeningContentTypes: types, asCopy: true)
             picker.allowsMultipleSelection = false
             picker.delegate = delegate
+            delegate.controller = picker
             activePicker = delegate
             if !CraftPresenter.present(picker, from: nil) {
-                activePicker = nil
-                done(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
+                delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
             }
         } else {
             var configuration = PHPickerConfiguration()
             configuration.filter = .videos
             configuration.selectionLimit = 1
             configuration.preferredAssetRepresentationMode = .current
-            let delegate = VideoLibraryDelegate(limit: limit, isCancelled: isCancelled, done: finish)
+            let delegate = LibraryDelegate(videoLimit: limit, requestToken: requestToken, isCancelled: isCancelled, done: done)
             let picker = PHPickerViewController(configuration: configuration)
             picker.delegate = delegate
+            delegate.controller = picker
             activePicker = delegate
             if !CraftPresenter.present(picker, from: nil) {
-                activePicker = nil
-                done(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
+                delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
             }
         }
     }
@@ -357,7 +461,7 @@ enum CraftNativeFiles {
     /// Pick one or more documents and copy them into app-owned storage while
     /// the security-scoped URLs are valid. `contentTypes` accepts MIME types,
     /// UTIs, or filename extensions; an empty list means any document.
-    static func pickFile(_ options: [String: Any], isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+    static func pickFile(_ options: [String: Any], requestToken: String? = nil, isCancelled: @escaping () -> Bool = { false }, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         guard !isCancelled() else { done(.failure(importCancelled())); return }
         guard activePicker == nil else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
@@ -382,17 +486,14 @@ enum CraftNativeFiles {
             done(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "files.pickFile contentTypes are invalid")))
             return
         }
-        let finish: (Result<Any, CraftNativeActionError>) -> Void = { result in
-            DispatchQueue.main.async { activePicker = nil; done(result) }
-        }
-        let delegate = FileDocumentDelegate(limit: limit, isCancelled: isCancelled, done: finish)
+        let delegate = DocumentDelegate(limit: limit, video: false, requestToken: requestToken, isCancelled: isCancelled, done: done)
         let picker = UIDocumentPickerViewController(forOpeningContentTypes: types, asCopy: true)
         picker.allowsMultipleSelection = selectionLimit > 1
         picker.delegate = delegate
+        delegate.controller = picker
         activePicker = delegate
         if !CraftPresenter.present(picker, from: nil) {
-            activePicker = nil
-            done(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the file picker")))
+            delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the file picker")))
         }
     }
 
@@ -531,17 +632,85 @@ enum CraftNativeFiles {
         }
     }
 
-    private final class FileDocumentDelegate: NSObject, UIDocumentPickerDelegate {
+    /// Screen disposal can cancel a request while its system picker is open.
+    /// A stale request must never dismiss a newer request's picker.
+    static func cancelPicker(requestToken: String) {
+        DispatchQueue.main.async {
+            #if CRAFT_PERMISSION_CAMERA
+            if let picker = activePicker as? CameraDelegate, picker.requestToken == requestToken {
+                picker.cancel()
+                return
+            }
+            #endif
+            if let picker = activePicker as? LibraryDelegate, picker.requestToken == requestToken {
+                picker.cancel()
+                return
+            }
+            guard let picker = activePicker as? DocumentDelegate,
+                  picker.requestToken == requestToken else { return }
+            picker.cancel()
+        }
+    }
+
+    final class DocumentDelegate: NSObject, UIDocumentPickerDelegate {
         let limit: Int
+        let video: Bool
+        let requestToken: String?
         let isCancelled: () -> Bool
         let done: (Result<Any, CraftNativeActionError>) -> Void
-        init(limit: Int, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) { self.limit = limit; self.isCancelled = isCancelled; self.done = done }
-        func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) { done(.success([])) }
+        weak var controller: UIDocumentPickerViewController?
+        private var answered = false
+        private var finished = false
+        private var importing = false
+
+        init(limit: Int, video: Bool, requestToken: String?, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+            self.limit = limit; self.video = video; self.requestToken = requestToken
+            self.isCancelled = isCancelled; self.done = done
+        }
+
+        func cancel() {
+            guard !finished else { return }
+            answered = true
+            controller?.dismiss(animated: false)
+            // Do not drain the cancellation token while a worker still polls
+            // it: that would let the remainder of a cancelled copy succeed.
+            if !importing { finish(.failure(importCancelled())) }
+        }
+
+        func finish(_ result: Result<Any, CraftNativeActionError>) {
+            DispatchQueue.main.async {
+                guard !self.finished else { return }
+                self.finished = true
+                self.controller?.dismiss(animated: false)
+                if activePicker === self { activePicker = nil }
+                self.done(result)
+            }
+        }
+
+        func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+            guard !answered else { return }
+            answered = true
+            finish(.success(video ? NSNull() : []))
+        }
+
         func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
-            guard !urls.isEmpty else { done(.success([])); return }
-            let (limit, isCancelled, done) = (self.limit, self.isCancelled, self.done)
+            guard !answered else { return }
+            answered = true
+            guard !isCancelled() else { finish(.failure(importCancelled())); return }
+            guard !urls.isEmpty else { finish(.success(video ? NSNull() : [])); return }
+            importing = true
+            let (limit, isCancelled, video) = (self.limit, self.isCancelled, self.video)
             DispatchQueue.global(qos: .userInitiated).async {
-                done(CraftNativeFiles.copyFiles(urls, limit: limit, isCancelled: isCancelled))
+                let result: Result<Any, CraftNativeActionError>
+                if video {
+                    let url = urls[0]
+                    let granted = url.startAccessingSecurityScopedResource()
+                    defer { if granted { url.stopAccessingSecurityScopedResource() } }
+                    result = CraftNativeFiles.copyVideo(url, limit: limit, isCancelled: isCancelled)
+                } else {
+                    result = CraftNativeFiles.copyFiles(urls, limit: limit, isCancelled: isCancelled)
+                }
+                self.finish(result)
             }
         }
     }
@@ -555,42 +724,6 @@ enum CraftNativeFiles {
         return copyImport(source, limit: limit, type: type, isCancelled: isCancelled)
     }
 
-    private final class VideoLibraryDelegate: NSObject, PHPickerViewControllerDelegate {
-        let limit: Int
-        let isCancelled: () -> Bool
-        let done: (Result<Any, CraftNativeActionError>) -> Void
-        init(limit: Int, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) { self.limit = limit; self.isCancelled = isCancelled; self.done = done }
-        func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
-            picker.dismiss(animated: true)
-            guard let provider = results.first?.itemProvider else { done(.success(NSNull())); return }
-            let (limit, isCancelled, done) = (self.limit, self.isCancelled, self.done)
-            provider.loadFileRepresentation(forTypeIdentifier: UTType.movie.identifier) { url, error in
-                guard let url else {
-                    done(.failure(CraftNativeActionError(code: "READ_ERROR", message: error?.localizedDescription ?? "The video could not be read")))
-                    return
-                }
-                done(CraftNativeFiles.copyVideo(url, limit: limit, isCancelled: isCancelled))
-            }
-        }
-    }
-
-    private final class VideoDocumentDelegate: NSObject, UIDocumentPickerDelegate {
-        let limit: Int
-        let isCancelled: () -> Bool
-        let done: (Result<Any, CraftNativeActionError>) -> Void
-        init(limit: Int, isCancelled: @escaping () -> Bool, done: @escaping (Result<Any, CraftNativeActionError>) -> Void) { self.limit = limit; self.isCancelled = isCancelled; self.done = done }
-        func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) { done(.success(NSNull())) }
-        func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
-            guard let url = urls.first else { done(.success(NSNull())); return }
-            let (limit, isCancelled, done) = (self.limit, self.isCancelled, self.done)
-            DispatchQueue.global(qos: .userInitiated).async {
-                let granted = url.startAccessingSecurityScopedResource()
-                defer { if granted { url.stopAccessingSecurityScopedResource() } }
-                done(CraftNativeFiles.copyVideo(url, limit: limit, isCancelled: isCancelled))
-            }
-        }
-    }
-
     // MARK: Sending files
 
     /// A multipart/form-data body from a screen's `FormData`: parts are

package/templates/CraftNativeScreen.swift

@@ -7367,6 +7367,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         if options.keys.contains("backgroundColor") || options.keys.contains("navigationBarSolid") {
             applyNavigationBarAppearance()
+            trackContentScrollView()
         }
         // Asked for after the bar was hidden for a bare root screen.
         if navigationBarHidden == nil, wantsNavigationBar, navigationController?.topViewController === self,
@@ -7589,7 +7590,14 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// title collapses as it scrolls, and the bar's background follows it.
     private func trackContentScrollView() {
         guard let renderedRoot else { return }
+        // UIKit can resize the root before nested flex wrappers lay out.
+        // Resolve their frames before checking empty siblings or edges so
+        // old child frames cannot toggle the root constraints each pass.
+        rootStack.layoutIfNeeded()
         func find(_ node: RenderedNode) -> UIScrollView? {
+            // Modal content belongs to a separate presentation. Hidden
+            // branches must not steal tracking from the visible screen.
+            guard node.type != "Modal", !node.view.isHidden else { return nil }
             if let scroll = node.view as? CraftNativeScrollView, scroll.isVertical, scroll.isScrollEnabled { return scroll }
             if let list = node.view as? CraftNativeFlatList, list.isScrollEnabled,
                (list.collectionViewLayout as? UICollectionViewFlowLayout)?.scrollDirection != .horizontal { return list }
@@ -7606,12 +7614,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 return list.isScrollEnabled && (list.collectionViewLayout as? UICollectionViewFlowLayout)?.scrollDirection != .horizontal ? node : nil
             }
             guard paddingInsets(node.style).top == 0,
-                  let first = node.children.first(where: { $0.type != "Modal" && !$0.view.isHidden }) else { return nil }
+                  let first = node.children.first(where: { $0.type != "Modal" && !$0.view.isHidden && $0.view.bounds.height > 0 }) else { return nil }
             return leading(first)
         }
         let scroll = find(renderedRoot)
         let leadingScroll = leading(renderedRoot)
-        // Only the screen's leading scroller draws beneath floating chrome.
+        // The leading scroller may overflow beneath navigation chrome.
         // A bounded list inside a form must clip its rows to its viewport.
         if let leadingScroll, leadingScroll.style["overflow"] as? String != "hidden" {
             leadingScroll.view.clipsToBounds = false
@@ -7626,13 +7634,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let edgeToEdge = scroll != nil && (prefersLargeTitle == true || scroll === leadingScroll?.view)
         let fullEdgeToEdge = rootIsSafeAreaView
         let topEdgeToEdge = fullEdgeToEdge || edgeToEdge
-        // Only a leading vertical scroller that reaches the root's bottom
-        // can paint beneath a visible tab bar. A bounded list, fixed footer,
-        // plain screen or presented sheet must retain its safe-area bottom.
+        // Bottom clearance does not depend on the leading-scroll rule for
+        // navigation titles. Follow the visible scroller through wrappers,
+        // even after a header or empty sibling. Its laid-out viewport must
+        // reach the root's bottom; zero-size/hidden siblings do not shorten
+        // it. A bounded list, fixed footer, plain screen or presented sheet
+        // must retain its safe-area bottom.
         // Use UIKit's automatic inset for tab/accessory clearance, rather
         // than adding a second explicit inset (also owned by keyboard code).
         var tabbedScroll = false
-        if let scroll, scroll === leadingScroll?.view, scroll.bounds.height > 0,
+        if let scroll, scroll.bounds.height > 0,
            let tabBar = tabBarController?.tabBar, !tabBar.isHidden, tabBar.alpha > 0,
            let window = view.window, tabBar.window === window,
            tabBar.convert(tabBar.bounds, to: view).intersects(view.bounds) {
@@ -7653,12 +7664,28 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         rootLeadingToView?.isActive = fullEdgeToEdge
         rootTrailingToSafeArea?.isActive = !fullEdgeToEdge
         rootTrailingToView?.isActive = fullEdgeToEdge
-        scroll?.contentInsetAdjustmentBehavior = edgeToEdge ? .automatic : .never
-        guard scroll !== trackedScrollView else { return }
-        trackedScrollView = scroll
-        // The same primary vertical scroller drives the navigation bar and
-        // the system tab bar's scroll-edge/minimization behavior.
-        setContentScrollView(scroll, for: [.top, .bottom])
+        scroll?.contentInsetAdjustmentBehavior = (edgeToEdge || tabbedScroll) ? .automatic : .never
+        if scroll !== trackedScrollView {
+            #if compiler(>=6.2)
+            if #available(iOS 26.0, *) {
+                trackedScrollView?.topEdgeEffect.isHidden = false
+                trackedScrollView?.bottomEdgeEffect.isHidden = false
+            }
+            #endif
+            trackedScrollView = scroll
+            // Keep UIKit's title collapse, tab selection and minimization
+            // tracking; only the full-width edge backdrop changes below.
+            setContentScrollView(scroll, for: [.top, .bottom])
+        }
+        #if compiler(>=6.2)
+        if #available(iOS 26.0, *) {
+            // Floating button groups carry their own material. UIKit's
+            // separate scroll-edge wash would cover the content behind
+            // and beyond them even with a transparent bar appearance.
+            scroll?.topEdgeEffect.isHidden = topEdgeToEdge && !navigationBarSolid
+            scroll?.bottomEdgeEffect.isHidden = tabbedScroll
+        }
+        #endif
     }
 
     private func observeNativeEvents() {