@craft-native/ios 0.0.497 → 0.0.500

package/package.json

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

package/templates/CraftApp.swift

@@ -822,6 +822,9 @@ final class CraftChrome: ObservableObject {
         /// A shared material capsule; nil keeps separate floating buttons.
         var accessoryLayout: String? = nil
         var companions: [Tab] = []
+        /// A floating action that is on: a mode it switched (tracking in
+        /// Maps), drawn in the tint whatever screen is showing.
+        var active = false
         /// A tap opens these destinations in a compact menu instead of navigating.
         var menu: [TabMenuItem] = []
     }
@@ -835,6 +838,23 @@ final class CraftChrome: ObservableObject {
     @Published var tabs: [Tab] = []
     @Published var tabAccessory: Tab?
     private weak var tabAccessoryOwner: AnyObject?
+
+    /// Where the compact tab actions float over the page, in window
+    /// coordinates, and the shell that drew them; nil when nothing floats.
+    /// They cover the trailing end of whatever scrolls behind them, so a
+    /// screen gives its scroll views that much room at the end (#523): the
+    /// last row can be brought clear without the app knowing this geometry.
+    private(set) var floatingActions: CGRect?
+    private(set) weak var floatingActionsHost: UIView?
+    static let floatingActionsDidMove = Notification.Name("CraftFloatingActionsDidMove")
+
+    func floatingActionsMoved(to frame: CGRect?, in host: UIView?) {
+        let next = frame.flatMap { $0.isNull || $0.isEmpty ? nil : $0.integral }
+        guard next != floatingActions || (next != nil && host !== floatingActionsHost) else { return }
+        floatingActions = next
+        floatingActionsHost = next == nil ? nil : host
+        NotificationCenter.default.post(name: Self.floatingActionsDidMove, object: self)
+    }
     @Published var selected: String?
     /// The visible destination may be the accessory, independently of its owning stack.
     @Published var visiblePath: String?
@@ -846,6 +866,8 @@ final class CraftChrome: ObservableObject {
         guard let path = visiblePath else { return false }
         return path == accessory.id || path.hasPrefix(accessory.id + "/")
     }
+    /// Drawn in the tint: its destination is showing, or the app says it is on.
+    func accessoryActive(_ accessory: Tab) -> Bool { accessory.active || accessorySelected(accessory) }
     var highlightedTab: String? { accessorySelected ? nil : selected }
     let tabSwipeProgress = CraftTabSwipeProgress()
     private(set) var tabSwipePosition: CGFloat? {
@@ -977,13 +999,15 @@ final class CraftChrome: ObservableObject {
                           let companionTitle = action["title"] as? String else { return nil }
                     return Tab(id: companionPath, title: companionTitle, symbol: action["symbol"] as? String ?? "circle",
                         accessibilityLabel: action["accessibilityLabel"] as? String, iconOnly: true,
+                        active: action["selected"] as? Bool ?? false,
                         menu: ((action["menu"] as? [[String: Any]]) ?? []).prefix(12).compactMap { choice in
                             guard let destination = choice["path"] as? String,
                                   destination.hasPrefix("/"), !destination.hasPrefix("//"),
                                   let label = choice["title"] as? String, !label.isEmpty else { return nil }
                             return TabMenuItem(id: destination, title: label, symbol: choice["symbol"] as? String ?? "circle")
                         })
-                })
+                },
+                active: item["selected"] as? Bool ?? false)
         } else {
             next = nil
         }

package/templates/CraftHybrid.swift

@@ -1483,12 +1483,10 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
                 let button = UIButton(type: .system)
                 var configuration = UIButton.Configuration.plain()
                 configuration.image = UIImage(systemName: action.symbol)
-                configuration.preferredSymbolConfigurationForImage = UIImage.SymbolConfiguration(pointSize: 22, weight: .regular)
                 button.configuration = configuration
                 button.accessibilityIdentifier = "craft-tab-companion:" + action.id
                 button.accessibilityLabel = action.accessibilityLabel ?? action.title
                 button.accessibilityValue = action.badge
-                button.accessibilityTraits = chrome.accessorySelected(action) ? [.button, .selected] : [.button]
                 if action.menu.isEmpty {
                     button.addAction(UIAction { [weak self] _ in self?.hybrid.open(action.id) }, for: .touchUpInside)
                 } else {
@@ -1512,9 +1510,6 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
                 companionButtons.append(button)
             }
         }
-        for (index, action) in companionModels.enumerated() {
-            companionButtons[index].accessibilityTraits = chrome.accessorySelected(action) ? [.button, .selected] : [.button]
-        }
         let grouped = model?.accessoryLayout != nil
         // A group is one control, as the map controls in Maps are: its
         // actions live inside the shared surface, so the glass lights the
@@ -1522,16 +1517,12 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         // Separate actions stay in the shell, each on its own surface.
         let actionHost: UIView = grouped ? accessoryGlass.contentView : view
         for glass in companionGlasses { glass.isHidden = grouped }
-        for button in companionButtons {
+        for (index, button) in companionButtons.enumerated() {
             if button.superview !== actionHost { actionHost.addSubview(button) }
-            button.tintColor = grouped ? .label : nil
-            button.configuration?.preferredSymbolConfigurationForImage = Self.accessorySymbol(grouped: grouped)
+            styleAccessory(button, for: companionModels[index], grouped: grouped)
         }
-        accessoryButton.tintColor = grouped ? .label : nil
         if let model {
             var configuration = UIButton.Configuration.plain()
-            configuration.image = UIImage(systemName: model.symbol)
-            configuration.preferredSymbolConfigurationForImage = Self.accessorySymbol(grouped: grouped)
             configuration.title = model.iconOnly ? nil : model.displayTitle
             configuration.subtitle = model.iconOnly ? nil : model.badge
             configuration.imagePadding = model.iconOnly ? 0 : 8
@@ -1539,7 +1530,7 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
                 button.configuration = configuration
                 button.accessibilityLabel = model.accessibilityLabel ?? model.displayTitle
                 button.accessibilityValue = model.badge
-                button.accessibilityTraits = chrome.accessorySelected(model) ? [.button, .selected] : [.button]
+                styleAccessory(button, for: model, grouped: grouped)
             }
         }
 #if compiler(>=6.2)
@@ -1597,10 +1588,32 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         view.setNeedsLayout()
     }
 
-    /// Symbols in a group carry the weight of the system's own map controls;
-    /// a separate action keeps the lighter bar-button weight.
+    /// Symbols in a group carry the weight of the system's own map controls,
+    /// and their size: at 20 points a symbol filled its 48-point action
+    /// where the ones in Maps leave half of theirs clear. The control and
+    /// its touch targets keep their size; only the symbol is smaller. A
+    /// separate action keeps the lighter bar-button weight.
     private static func accessorySymbol(grouped: Bool) -> UIImage.SymbolConfiguration {
-        UIImage.SymbolConfiguration(pointSize: grouped ? 20 : 22, weight: grouped ? .medium : .regular)
+        UIImage.SymbolConfiguration(pointSize: grouped ? 15 : 22, weight: grouped ? .medium : .regular)
+    }
+
+    /// One action's symbol, tint and state. An action that is on (its
+    /// destination is showing, or the app says so) is drawn in the tint and,
+    /// where the symbol has one, filled: Maps' location arrow while tracking.
+    /// Off, a grouped action is the label colour, as the map controls are.
+    private func styleAccessory(_ button: UIButton, for action: CraftChrome.Tab, grouped: Bool) {
+        let active = CraftChrome.shared.accessoryActive(action)
+        let filled = active && !action.symbol.hasSuffix(".fill") ? UIImage(systemName: action.symbol + ".fill") : nil
+        let tint: UIColor = CraftChrome.shared.tint ?? config.tintColor.flatMap { UIColor(hex: $0) } ?? view.tintColor
+        button.configuration?.image = filled ?? UIImage(systemName: action.symbol)
+        button.configuration?.preferredSymbolConfigurationForImage = Self.accessorySymbol(grouped: grouped)
+        // Said to the configuration as well as the view: glass draws its
+        // content in the label colour unless the content names its own.
+        button.configuration?.baseForegroundColor = active ? tint : grouped ? .label : nil
+        // A group places each symbol itself, when it lays out.
+        if !grouped { button.configuration?.contentInsets = .zero }
+        button.tintColor = active ? tint : grouped ? .label : nil
+        button.accessibilityTraits = active ? [.button, .selected] : [.button]
     }
 
     /// The surface under the floating actions. A group is a capsule of
@@ -1639,10 +1652,11 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         }
     }
 
-    /// A group's breadth, and each action's length along it: the system map
-    /// controls' proportions, every target at least 48 points.
+    /// A group's breadth, and the distance from one symbol to the next. As
+    /// in Maps, the first and last symbols sit at the centres of the
+    /// capsule's round ends, so two actions make a 48 by 103 point control.
     static let accessoryGroupBreadth: CGFloat = 48
-    static let accessoryGroupStep: CGFloat = 52
+    static let accessoryGroupStep: CGFloat = 55
 
     @objc private func openTabAccessory() {
         if let accessoryModel { hybrid.open(accessoryModel.id) }
@@ -1651,6 +1665,8 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
     override func viewDidLayoutSubviews() {
         super.viewDidLayoutSubviews()
         guard hybrid.controller === self else { return }
+        // Once the actions are where this pass puts them.
+        defer { CraftChrome.shared.floatingActionsMoved(to: floatingActionsFrame(), in: view) }
 #if compiler(>=6.2)
         if #available(iOS 26.0, *), accessoryModel?.iconOnly != true {
             // UIKit already supplies the native safe area. This measurement is
@@ -1687,6 +1703,20 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         CraftChrome.shared.layoutChanged(tabBar.isHidden ? 0 : max(0, view.bounds.maxY - tabBar.frame.minY) + accessoryInset)
     }
 
+    /// The compact actions' frame in the window, or nil when none float over
+    /// the page: a full-width shelf is reserved for through the safe area,
+    /// and a hidden tab bar takes its actions with it. A group is its one
+    /// capsule; separate actions are the row of them.
+    private func floatingActionsFrame() -> CGRect? {
+        guard let model = accessoryModel, model.iconOnly, view.window != nil,
+              accessoryGlass.superview === view, !accessoryGlass.isHidden, !tabBar.isHidden else { return nil }
+        var frame = accessoryGlass.frame
+        if model.accessoryLayout == nil {
+            for glass in companionGlasses where !glass.isHidden { frame = frame.union(glass.frame) }
+        }
+        return view.convert(frame, to: view.window)
+    }
+
     /// One capsule above the trailing end of the tab bar, companions first
     /// and the primary action last. Nothing divides the actions: the glass
     /// is one control, and each action is found by its place and its symbol.
@@ -1694,7 +1724,7 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         let breadth = Self.accessoryGroupBreadth
         let step = Self.accessoryGroupStep
         let buttons = companionButtons + [accessoryButton]
-        let length = step * CGFloat(buttons.count)
+        let length = breadth + step * CGFloat(buttons.count - 1)
         let size = vertical ? CGSize(width: breadth, height: length) : CGSize(width: length, height: breadth)
         let rightToLeft = view.effectiveUserInterfaceLayoutDirection == .rightToLeft
         // The tab bar's own platter sits this far in from the screen's edge.
@@ -1702,10 +1732,21 @@ final class CraftHybridController: UITabBarController, UITabBarControllerDelegat
         let x = rightToLeft ? view.safeAreaInsets.left + margin : view.bounds.maxX - view.safeAreaInsets.right - size.width - margin
         accessoryGlass.frame = CGRect(x: x, y: tabBar.frame.minY - size.height - 10, width: size.width, height: size.height)
         for (index, button) in buttons.enumerated() {
-            let place = CGFloat(rightToLeft && !vertical ? buttons.count - 1 - index : index) * step
+            // Every point of the capsule belongs to the nearest action; its
+            // symbol stays where Maps puts it, at the centre of a round end
+            // for the first and the last.
+            let place = rightToLeft && !vertical ? buttons.count - 1 - index : index
+            let centre = breadth / 2 + CGFloat(place) * step
+            let from = place == 0 ? 0 : centre - step / 2
+            let to = place == buttons.count - 1 ? length : centre + step / 2
             button.frame = vertical
-                ? CGRect(x: 0, y: place, width: breadth, height: step)
-                : CGRect(x: place, y: 0, width: step, height: breadth)
+                ? CGRect(x: 0, y: from, width: breadth, height: to - from)
+                : CGRect(x: from, y: 0, width: to - from, height: breadth)
+            let shift = 2 * (centre - from) - (to - from)
+            let before = max(0, shift), after = max(0, -shift)
+            button.configuration?.contentInsets = vertical
+                ? NSDirectionalEdgeInsets(top: before, leading: 0, bottom: after, trailing: 0)
+                : NSDirectionalEdgeInsets(top: 0, leading: rightToLeft ? after : before, bottom: 0, trailing: rightToLeft ? before : after)
         }
         let badgeWidth = max(18, accessoryBadge.intrinsicContentSize.width + 8)
         let primary = accessoryButton.convert(accessoryButton.bounds, to: view)

package/templates/CraftNativeActions.swift

@@ -391,7 +391,7 @@ enum CraftNativeActions {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Local database is disabled"), completion)
                 return
             }
-            databaseQueue.async { complete(requestToken, database(method: method, args: args), completion) }
+            databaseQueue.async { complete(requestToken, database(requestToken: requestToken, method: method, args: args), completion) }
             return
         case ("Browser", "open"):
             // SFSafariViewController, or for `mode: 'auth'` the system's web
@@ -1275,7 +1275,47 @@ enum CraftNativeActions {
         #endif
     }
 
-    private static func database(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
+    /// A screen has gone. A transaction it began and never finished is rolled
+    /// back.
+    ///
+    /// The database is one connection shared by every screen, and a
+    /// transaction left open on it does not end with the screen that began
+    /// it: every later write joins it, reads back as written, and is gone
+    /// when the process exits, since nobody is left to commit; every later
+    /// `beginTransaction` is refused. Rolling back loses what the closed
+    /// screen had not committed, which is what closing mid-transaction means,
+    /// and gives every later write its own fate back. Queued behind whatever
+    /// that screen had already asked for.
+    static func endScope(_ scope: String) {
+        databaseQueue.async {
+            guard transactionScope == scope else { return }
+            transactionScope = nil
+            guard let database, sqlite3_get_autocommit(database) == 0 else { return }
+            _ = execute(sql: "ROLLBACK", params: [])
+        }
+    }
+
+    /// Which screen's transaction is open, read off the database around each
+    /// call rather than off the method's name, so a `BEGIN` sent through
+    /// `execute` is owned like one sent through `beginTransaction`: a call
+    /// that leaves a transaction open where there was none began it, and one
+    /// that leaves none ended it. The scope is the part of a request token
+    /// before its last `/`. Only touched on `databaseQueue`.
+    private static var transactionScope: String?
+
+    private static func database(requestToken: String, method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
+        let before = database.map { sqlite3_get_autocommit($0) == 0 } ?? false
+        let answer = databaseCall(method: method, args: args)
+        let after = database.map { sqlite3_get_autocommit($0) == 0 } ?? false
+        if after && !before {
+            transactionScope = requestToken.range(of: "/", options: .backwards).map { String(requestToken[..<$0.lowerBound]) } ?? ""
+        } else if !after {
+            transactionScope = nil
+        }
+        return answer
+    }
+
+    private static func databaseCall(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
         guard openDatabase() else { return failure("DATABASE_ERROR", "Could not open the local database") }
         switch method {
         case "execute":
@@ -1497,7 +1537,11 @@ enum CraftNativeActions {
             "host": url.host ?? "",
             "path": url.path,
             "query": url.query ?? "",
-            "queryParams": Dictionary(uniqueKeysWithValues: (components?.queryItems ?? []).map { ($0.name, $0.value ?? "") }),
+            // A link is whatever its sender wrote, and may name a parameter
+            // twice. Built with unique keys this trapped, and the app closed
+            // on being opened by such a link. The first value is kept, which
+            // is the one Android gives.
+            "queryParams": Dictionary((components?.queryItems ?? []).map { ($0.name, $0.value ?? "") }, uniquingKeysWith: { first, _ in first }),
         ]
     }
 

package/templates/CraftNativeFiles.swift

@@ -85,6 +85,84 @@ final class CraftNotificationAttachments {
 // memory. `fetch` and the share sheet take the path; only files made here are
 // read back for a form, so a screen cannot post an arbitrary file of the app's.
 
+/// A request waiting on a system picker, as the one picker slot sees it.
+protocol CraftPickerRequest: AnyObject {
+    /// Where its picker is.
+    var presence: CraftPickerPresence { get }
+    /// It has neither been answered by its picker nor finished.
+    var isWaiting: Bool { get }
+    /// The picker went without a choice or a cancel reaching its delegate.
+    /// One that was on screen answers as a cancel; one that never appeared
+    /// answers that it could not be presented.
+    func pickerLeft(shown: Bool)
+}
+
+extension CraftPickerRequest {
+    /// Still waiting on a picker that can no longer answer.
+    var lostItsPicker: Bool { isWaiting && presence.lost }
+}
+
+/// Where a request's picker is: on its way to the screen, on it, or gone.
+///
+/// UIKit tells a picker's delegate about a choice and about a cancel. It
+/// says nothing when the picker goes because what presented it did (an app
+/// closing the sheet the picker was on), or when it gives a presentation up
+/// before it began: a system picker runs in another process and is presented
+/// once that process answers, and by then the sheet it was to appear on may
+/// have closed ("whose view is not in the window hierarchy", in the console
+/// only). The request then never answered and kept the one picker slot:
+/// every later pick was refused as BUSY until the app was restarted.
+final class CraftPickerPresence {
+    weak var picker: UIViewController?
+    /// What the picker was handed to for presenting.
+    weak var presenter: UIViewController?
+    weak var watch: CraftPickerWatch?
+
+    /// The picker has been on screen.
+    var shown: Bool { watch?.shown ?? false }
+
+    /// The picker cannot answer any more.
+    var lost: Bool {
+        guard let picker else { return true }
+        if picker.presentingViewController != nil { return false }
+        // It was on screen, is not now, and nothing presents it.
+        if shown { return picker.viewIfLoaded?.window == nil }
+        // It has not appeared yet, and what was to present it has gone.
+        guard let presenter else { return true }
+        return presenter.viewIfLoaded?.window == nil
+    }
+}
+
+/// A view inside a system picker that says when the picker has been seen
+/// and when it is gone: it leaves the window when the picker does and is
+/// released when the picker is, whichever way that happens.
+final class CraftPickerWatch: UIView {
+    private(set) var shown = false
+    private var left: ((_ shown: Bool) -> Void)?
+
+    static func attach(to picker: UIViewController, left: @escaping (_ shown: Bool) -> Void) -> CraftPickerWatch {
+        let watch = CraftPickerWatch(frame: .zero)
+        watch.isHidden = true
+        watch.isUserInteractionEnabled = false
+        watch.left = left
+        picker.view.addSubview(watch)
+        return watch
+    }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil { shown = true } else if shown { report() }
+    }
+
+    deinit { report() }
+
+    private func report() {
+        guard let left else { return }
+        let shown = shown
+        DispatchQueue.main.async { left(shown) }
+    }
+}
+
 enum CraftNativeFiles {
     /// The longest side of a picked photo unless the screen asks otherwise:
     /// sharp on any phone screen and in a share card, a few hundred kilobytes
@@ -104,6 +182,40 @@ enum CraftNativeFiles {
     /// The picker on screen, kept alive until it answers. One at a time.
     private static var activePicker: NSObject?
 
+    /// The slot is free when nothing holds it, or when what holds it is
+    /// waiting on a picker that can no longer answer.
+    private static func pickerSlotIsFree() -> Bool {
+        guard let request = activePicker as? CraftPickerRequest else { return activePicker == nil }
+        guard request.lostItsPicker else { return false }
+        activePicker = nil
+        request.pickerLeft(shown: request.presence.shown)
+        return true
+    }
+
+    /// Follow `picker` for the request that is waiting on it.
+    private static func watch(_ picker: UIViewController, for request: CraftPickerRequest) {
+        let presence = request.presence
+        presence.picker = picker
+        presence.presenter = CraftPresenter.topViewController()
+        presence.watch = CraftPickerWatch.attach(to: picker) { [weak request] shown in request?.pickerLeft(shown: shown) }
+        awaitAppearance(of: request, checks: 60)
+    }
+
+    /// Until the picker is on screen nothing of its own can say it never
+    /// will be, and UIKit may hold a presentation it cannot make for as long
+    /// as the picker's process takes to answer. Look twice a second, for half
+    /// a minute at most, and answer for a picker whose presenter has gone.
+    private static func awaitAppearance(of request: CraftPickerRequest, checks: Int) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak request] in
+            guard let request, request.isWaiting, !request.presence.shown else { return }
+            if request.presence.lost {
+                request.pickerLeft(shown: false)
+            } else if checks > 1 {
+                awaitAppearance(of: request, checks: checks - 1)
+            }
+        }
+    }
+
     // MARK: Files of our own
 
     /// A new file called `name`, in a folder of its own so two files can share
@@ -208,7 +320,7 @@ enum CraftNativeFiles {
             .map { $0.doubleValue }
             .flatMap { $0.isFinite ? $0 : nil } ?? defaultQuality))
         let source = options["source"] as? String ?? "library"
-        guard activePicker == nil else {
+        guard pickerSlotIsFree() else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
@@ -245,6 +357,7 @@ enum CraftNativeFiles {
         picker.delegate = delegate
         delegate.controller = picker
         activePicker = delegate
+        watch(picker, for: delegate)
         if !CraftPresenter.present(picker, from: nil) {
             delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the photo picker")))
         }
@@ -291,7 +404,7 @@ enum CraftNativeFiles {
         return "\(base).jpg"
     }
 
-    final class LibraryDelegate: NSObject, PHPickerViewControllerDelegate {
+    final class LibraryDelegate: NSObject, PHPickerViewControllerDelegate, CraftPickerRequest {
         let maxPixels: Int
         let quality: Double
         let videoLimit: Int?
@@ -353,8 +466,18 @@ enum CraftNativeFiles {
             }
         }
 
+        let presence = CraftPickerPresence()
+        var isWaiting: Bool { !answered && !finished }
+
+        func pickerLeft(shown: Bool) {
+            guard lostItsPicker else { return }
+            answered = true
+            finish(shown ? .success(NSNull()) : .failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the \(videoLimit == nil ? "photo" : "video") picker")))
+        }
+
         func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
-            guard !answered else { return }
+            // A picker whose request was already answered still closes.
+            guard !answered else { picker.dismiss(animated: true); return }
             picker.dismiss(animated: true)
             guard let provider = results.first?.itemProvider else {
                 answered = true
@@ -403,12 +526,13 @@ enum CraftNativeFiles {
         picker.delegate = delegate
         delegate.controller = picker
         activePicker = delegate
+        watch(picker, for: 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 {
+    final class CameraDelegate: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate, CraftPickerRequest {
         let maxPixels: Int
         let quality: Double
         let requestToken: String?
@@ -483,6 +607,15 @@ enum CraftNativeFiles {
             answered = true
             finish(.success(NSNull()))
         }
+
+        let presence = CraftPickerPresence()
+        var isWaiting: Bool { !answered && !finished }
+
+        func pickerLeft(shown: Bool) {
+            guard lostItsPicker else { return }
+            answered = true
+            finish(shown ? .success(NSNull()) : .failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the camera")))
+        }
     }
 
     #endif
@@ -493,7 +626,7 @@ enum CraftNativeFiles {
     /// the provider's URL is valid; no movie bytes cross JavaScriptCore.
     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 {
+        guard pickerSlotIsFree() else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
@@ -512,6 +645,7 @@ enum CraftNativeFiles {
             picker.delegate = delegate
             delegate.controller = picker
             activePicker = delegate
+            watch(picker, for: delegate)
             if !CraftPresenter.present(picker, from: nil) {
                 delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
             }
@@ -525,6 +659,7 @@ enum CraftNativeFiles {
             picker.delegate = delegate
             delegate.controller = picker
             activePicker = delegate
+            watch(picker, for: delegate)
             if !CraftPresenter.present(picker, from: nil) {
                 delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the video picker")))
             }
@@ -538,7 +673,7 @@ enum CraftNativeFiles {
     /// UTIs, or filename extensions; an empty list means any document.
     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 {
+        guard pickerSlotIsFree() else {
             done(.failure(CraftNativeActionError(code: "BUSY", message: "A picker is already open")))
             return
         }
@@ -567,6 +702,7 @@ enum CraftNativeFiles {
         picker.delegate = delegate
         delegate.controller = picker
         activePicker = delegate
+        watch(picker, for: delegate)
         if !CraftPresenter.present(picker, from: nil) {
             delegate.finish(.failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the file picker")))
         }
@@ -727,7 +863,7 @@ enum CraftNativeFiles {
         }
     }
 
-    final class DocumentDelegate: NSObject, UIDocumentPickerDelegate {
+    final class DocumentDelegate: NSObject, UIDocumentPickerDelegate, CraftPickerRequest {
         let limit: Int
         let video: Bool
         let requestToken: String?
@@ -768,6 +904,15 @@ enum CraftNativeFiles {
             finish(.success(video ? NSNull() : []))
         }
 
+        let presence = CraftPickerPresence()
+        var isWaiting: Bool { !answered && !finished }
+
+        func pickerLeft(shown: Bool) {
+            guard lostItsPicker else { return }
+            answered = true
+            finish(shown ? .success(video ? NSNull() : []) : .failure(CraftNativeActionError(code: "PICKER_ERROR", message: "Unable to present the \(video ? "video" : "file") picker")))
+        }
+
         func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
             guard !answered else { return }
             answered = true
@@ -902,8 +1047,15 @@ enum CraftNativeFiles {
         guard let text = data as? String else {
             return .failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "files.write needs its contents as a string"))
         }
+        // Absent or null is utf8. Anything else that is not one of the two
+        // names is refused, a number included, rather than read as utf8.
+        let encoding: String?
+        switch options["encoding"] {
+        case nil, is NSNull: encoding = "utf8"
+        case let named: encoding = named as? String
+        }
         let bytes: Data
-        switch options["encoding"] as? String ?? "utf8" {
+        switch encoding {
         case "utf8":
             bytes = Data(text.utf8)
         case "base64":