@craft-native/ios 0.0.358 → 0.0.360

package/README.md

@@ -2,6 +2,11 @@
 
 Build native iOS apps with web technologies using Craft.
 
+Bluetooth GATT discovery includes iOS-connected peripherals matching the requested
+services as well as new advertisements. A watch connected through another app can
+therefore appear without changing its system pairing. Discovery still requires
+Bluetooth permission and does not prove that the device accepts the app's protocol.
+
 ## Native celebration
 
 Any native `View` may opt into a finite card entrance, light sweep and confetti
@@ -174,7 +179,7 @@ and linear gradients are applied by UIKit with the same style keys as Android;
 `elevation` remains Android-specific. Gradient layers follow the native view's
 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`, `SegmentedControl`, `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).
+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`, `SegmentedControl`, `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. Dynamic `craft.shortcuts.set`/`clear` are not installed by the all-native host yet; configure static `appShortcuts` in `craft.config.json` to publish home-screen quick actions. Runtime shortcut registration remains tracked in #412. 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.

package/package.json

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

package/templates/CraftApp.swift

@@ -412,7 +412,9 @@ class CraftEventManager {
     /// The app script's delivery, once its bundle has run.
     private var appScriptSink: ((String, [String: Any]) -> Void)?
 
-    private init() {}
+    // Internal construction also allows isolated event-delivery tests without
+    // replacing the running app's singleton listener.
+    init() {}
 
     func setWebView(_ webView: WKWebView) {
         self.webView = webView
@@ -668,7 +670,6 @@ struct CraftApp: App {
                         CraftColorSchemeObserver()
                         CraftHybridRoot(config: appState.config)
                             .ignoresSafeArea()
-                        CraftTabBarView()
                         CraftSplashView(background: appState.config.resolvedBackgroundColor)
                     }
                     // The keyboard covers the tab bar, as it does UIKit's: the

package/templates/CraftBluetooth.swift

@@ -88,8 +88,13 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     private func startScan() {
-        guard scanCompletion != nil else { return }
-        central?.scanForPeripherals(withServices: scanServices, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
+        guard scanCompletion != nil, let central else { return }
+        // A device connected by another app may have stopped advertising.
+        // This lookup does not change its system pairing or connection.
+        for found in central.retrieveConnectedPeripherals(withServices: scanServices) {
+            remember(found, name: found.name ?? "", rssi: nil)
+        }
+        central.scanForPeripherals(withServices: scanServices, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
     }
 
     private func finishScan() {
@@ -122,11 +127,18 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
-        guard scanCompletion != nil, devices.count < 64 else { return }
         let name = advertisementData[CBAdvertisementDataLocalNameKey] as? String ?? peripheral.name ?? ""
+        remember(peripheral, name: name, rssi: RSSI.intValue)
+    }
+
+    private func remember(_ peripheral: CBPeripheral, name: String, rssi: Int?) {
+        guard scanCompletion != nil else { return }
         guard namePrefix.isEmpty || name.lowercased().hasPrefix(namePrefix.lowercased()) else { return }
         let id = peripheral.identifier.uuidString
-        devices[id] = peripheral; names[id] = name; strengths[id] = RSSI.intValue
+        guard devices[id] != nil || devices.count < 64 else { return }
+        devices[id] = peripheral
+        if !name.isEmpty || names[id] == nil { names[id] = name }
+        if let rssi { strengths[id] = rssi }
     }
 
     private func connect(_ options: [String: Any], _ completion: @escaping Completion) {

package/templates/CraftHybrid.swift

@@ -2,6 +2,7 @@ import Foundation
 import SwiftUI
 import UIKit
 import WebKit
+import Combine
 
 // MARK: - Hybrid: web plus native screens
 //
@@ -1098,7 +1099,7 @@ final class CraftNativeNavigationController: UINavigationController {
     }
 }
 
-final class CraftHybridController: UIViewController, UINavigationControllerDelegate, UIGestureRecognizerDelegate, CraftHybridScreenEvents {
+final class CraftHybridController: UITabBarController, UITabBarControllerDelegate, UINavigationControllerDelegate, UIGestureRecognizerDelegate, CraftHybridScreenEvents {
     private let config: CraftConfig
     private let hybrid = CraftHybrid.shared
     /// The web view's host; nil in an all-native app, which never makes one.
@@ -1107,6 +1108,15 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private let parking = UIView()
     private var stacks: [String: UINavigationController] = [:]
     private var currentTab = ""
+    private var tabPlaceholders: [String: UIViewController] = [:]
+    private var systemTabItems: [String: UITabBarItem] = [:]
+    private var chromeSubscription: AnyCancellable?
+    private var chromeUpdatePending = false
+    private var synchronizingTabs = false
+    private var accessoryModel: CraftChrome.Tab?
+    private let accessoryButton = UIButton(type: .system)
+    private static let tabPictures = NSCache<NSURL, UIImage>()
+    private var requestedTabPictures = Set<URL>()
     /// The path each native entry opened at.
     private var nativePaths: [ObjectIdentifier: String] = [:]
     /// Each stack as it was after its last transition, to see what a pop removed.
@@ -1159,10 +1169,30 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     override func viewDidLoad() {
         super.viewDidLoad()
+        hybrid.controller = self
+        delegate = self
+        if #available(iOS 18.0, *) { mode = .tabBar }
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) { tabBarMinimizeBehavior = .onScrollDown }
+#endif
+        accessoryButton.accessibilityIdentifier = "craft-tab-accessory"
+        accessoryButton.addTarget(self, action: #selector(openTabAccessory), for: .touchUpInside)
+        chromeSubscription = CraftChrome.shared.objectWillChange.sink { [weak self] in
+            guard let self, !self.chromeUpdatePending else { return }
+            self.chromeUpdatePending = true
+            // Published sends before its value changes; coalesce the complete
+            // chrome transaction before updating UIKit's retained tab items.
+            DispatchQueue.main.async { [weak self] in
+                guard let self else { return }
+                self.chromeUpdatePending = false
+                guard self.hybrid.controller === self else { return }
+                self.synchronizeSystemTabs()
+            }
+        }
         view.backgroundColor = config.resolvedBackgroundColor
         parking.frame = view.bounds
         parking.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        view.addSubview(parking)
+        view.insertSubview(parking, at: 0)
 
         // A native start screen draws first; the web view, whose creation
         // costs a frame or more, starts loading straight after it. An
@@ -1185,6 +1215,165 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         prepareAdjacentNativeTabs()
     }
 
+    /// UIKit owns the bar, selection indicator, badges and content safe area.
+    /// Placeholders preserve lazy screen creation without inventing a second
+    /// navigation stack when a tab is first selected or prepared for a swipe.
+    private func synchronizeSystemTabs() {
+        guard isViewLoaded, !synchronizingTabs else { return }
+        synchronizingTabs = true
+        defer { synchronizingTabs = false }
+        let chrome = CraftChrome.shared
+        let ids = hybrid.tabIds.isEmpty ? [currentTab] : hybrid.tabIds
+        let controllers = ids.map { id -> UIViewController in
+            let controller: UIViewController
+            if let stack = stacks[id] { controller = stack }
+            else if let placeholder = tabPlaceholders[id] { controller = placeholder }
+            else {
+                controller = UIViewController()
+                tabPlaceholders[id] = controller
+            }
+            // An explicit retained item prevents UINavigationController from
+            // adopting a newly loaded root screen's default tab item later.
+            let item = systemTabItems[id] ?? UITabBarItem(title: nil, image: nil, tag: 0)
+            systemTabItems[id] = item
+            if controller.tabBarItem !== item { controller.tabBarItem = item }
+            return controller
+        }
+        let existing = viewControllers ?? []
+        if existing.count != controllers.count || zip(existing, controllers).contains(where: { $0 !== $1 }) {
+            setViewControllers(controllers, animated: false)
+            customizableViewControllers = []
+        }
+        // UIKit rebuilds item presentation when a lazy placeholder is replaced.
+        // Apply accessibility metadata after installing the retained stacks so
+        // the last prepared tab keeps the same identifier as every other tab.
+        for (id, controller) in zip(ids, controllers) {
+            guard let tab = chrome.tabs.first(where: { $0.id == id }) else { continue }
+            let item = controller.tabBarItem!
+            item.title = tab.displayTitle
+            item.image = systemTabImage(tab, selected: false)
+            item.selectedImage = systemTabImage(tab, selected: true)
+            item.badgeValue = tab.badge
+            item.accessibilityIdentifier = "craft-tab-\(tab.id)"
+            item.accessibilityLabel = tab.accessibilityLabel ?? tab.displayTitle
+        }
+        if let committed = stacks[currentTab], controllers.contains(where: { $0 === committed }), selectedViewController !== committed {
+            UIView.performWithoutAnimation {
+                selectedViewController = committed
+                view.layoutIfNeeded()
+            }
+        }
+        tabBar.tintColor = chrome.tint ?? view.tintColor
+        let hidden = !chrome.tabBarVisible || chrome.tabs.isEmpty
+        if #available(iOS 18.0, *) { setTabBarHidden(hidden, animated: false) }
+        else { tabBar.isHidden = hidden }
+        updateSystemAccessory(hidden: hidden)
+    }
+
+    private func systemTabImage(_ tab: CraftChrome.Tab, selected: Bool) -> UIImage? {
+        if let address = tab.image, let url = URL(string: address), url.scheme == "https" {
+            if let image = Self.tabPictures.object(forKey: url as NSURL) { return image }
+            if requestedTabPictures.insert(url).inserted {
+                URLSession.shared.dataTask(with: url) { [weak self] data, response, _ in
+                    guard let data, let response = response as? HTTPURLResponse,
+                          (200..<300).contains(response.statusCode), let image = UIImage(data: data) else { return }
+                    DispatchQueue.main.async { [weak self] in
+                        let fitted = UIGraphicsImageRenderer(size: CGSize(width: 26, height: 26)).image { _ in
+                            UIBezierPath(ovalIn: CGRect(x: 0, y: 0, width: 26, height: 26)).addClip()
+                            let scale = max(26 / max(1, image.size.width), 26 / max(1, image.size.height))
+                            let size = CGSize(width: image.size.width * scale, height: image.size.height * scale)
+                            image.draw(in: CGRect(x: (26 - size.width) / 2, y: (26 - size.height) / 2, width: size.width, height: size.height))
+                        }.withRenderingMode(.alwaysOriginal)
+                        Self.tabPictures.countLimit = 16
+                        Self.tabPictures.setObject(fitted, forKey: url as NSURL)
+                        guard let self, self.hybrid.controller === self else { return }
+                        self.synchronizeSystemTabs()
+                    }
+                }.resume()
+            }
+        } else if let text = tab.iconText {
+            let attributes: [NSAttributedString.Key: Any] = [
+                .font: UIFont.monospacedDigitSystemFont(ofSize: 16, weight: .semibold), .foregroundColor: UIColor.systemRed,
+            ]
+            let label = text as NSString
+            let size = label.size(withAttributes: attributes)
+            return UIGraphicsImageRenderer(size: CGSize(width: min(48, max(1, size.width)), height: 26)).image { _ in
+                label.draw(in: CGRect(x: 0, y: (26 - size.height) / 2, width: 48, height: size.height), withAttributes: attributes)
+            }.withRenderingMode(.alwaysOriginal)
+        }
+        let appearance = tab.iconAppearance(selected: selected, motionAllowed: false)
+        let filled = selected && tab.selectedSymbol == nil && !appearance.symbol.hasSuffix(".fill")
+            ? UIImage(systemName: appearance.symbol + ".fill") : nil
+        let image = filled ?? UIImage(systemName: appearance.symbol)
+        if let color = appearance.tint.flatMap({ UIColor(hex: $0) }) {
+            return image?.withTintColor(color, renderingMode: .alwaysOriginal)
+        }
+        return image
+    }
+
+    func tabBarController(_ tabBarController: UITabBarController, shouldSelect viewController: UIViewController) -> Bool {
+        let ids = hybrid.tabIds
+        guard let index = viewControllers?.firstIndex(where: { $0 === viewController }), ids.indices.contains(index),
+              let tab = CraftChrome.shared.tabs.first(where: { $0.id == ids[index] }) else { return false }
+        // Craft may wait for the shared web page. Its committed stack decides
+        // selection, including reselect-to-root and interruption of a swipe.
+        CraftChrome.shared.tap(tab)
+        return false
+    }
+
+    private func updateSystemAccessory(hidden: Bool) {
+        let chrome = CraftChrome.shared
+        let model = hidden ? nil : chrome.tabAccessory
+        if let model {
+            var configuration = UIButton.Configuration.plain()
+            configuration.image = UIImage(systemName: model.symbol)
+            configuration.title = model.displayTitle
+            configuration.subtitle = model.badge
+            configuration.imagePadding = 8
+            accessoryButton.configuration = configuration
+            accessoryButton.accessibilityLabel = model.accessibilityLabel ?? model.displayTitle
+            accessoryButton.accessibilityValue = model.badge
+            accessoryButton.accessibilityTraits = chrome.accessorySelected ? [.button, .selected] : [.button]
+        }
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) {
+            if (model == nil) != (bottomAccessory == nil) {
+                bottomAccessory = model.map { _ in UITabAccessory(contentView: accessoryButton) }
+            }
+            accessoryModel = model
+            return
+        }
+#endif
+        // Older systems have no bottom-accessory container. Keep the action
+        // available above the system bar, without recreating the tab control.
+        if model != nil, accessoryButton.superview == nil { view.addSubview(accessoryButton) }
+        accessoryButton.isHidden = model == nil
+        accessoryButton.backgroundColor = config.resolvedBackgroundColor
+        accessoryModel = model
+        for nav in stacks.values { nav.additionalSafeAreaInsets.bottom = safeAreaForTabBar() }
+        view.setNeedsLayout()
+    }
+
+    @objc private func openTabAccessory() {
+        if let accessoryModel { hybrid.open(accessoryModel.id) }
+    }
+
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+        guard hybrid.controller === self else { return }
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) {
+            // UIKit already supplies the native safe area. This measurement is
+            // only the web CSS contract, not another native bottom inset.
+            let top = bottomAccessory.map { $0.contentView.convert($0.contentView.bounds, to: view).minY } ?? tabBar.frame.minY
+            CraftChrome.shared.layoutChanged(tabBar.isHidden ? 0 : max(0, view.bounds.maxY - top))
+            return
+        }
+#endif
+        accessoryButton.frame = CGRect(x: 16, y: tabBar.frame.minY - 44, width: max(0, view.bounds.width - 32), height: 44)
+        CraftChrome.shared.layoutChanged(tabBar.isHidden ? 0 : max(0, view.bounds.maxY - tabBar.frame.minY) + (accessoryModel == nil ? 0 : 44))
+    }
+
     private var webAttached = false
 
     private func installTabSwipeGestures() {
@@ -1304,6 +1493,9 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
                 self.reveal(slot)
             }
         }
+        if let container = current.view.superview, target.view.superview !== container {
+            container.addSubview(target.view)
+        }
         target.view.isHidden = false
         let width = view.bounds.width
         tabSwipeFrom = -direction * width
@@ -1321,7 +1513,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             }
         }
         target.view.frame = view.bounds.offsetBy(dx: tabSwipeFrom + tabSwipeBase, dy: 0)
-        view.bringSubviewToFront(target.view)
+        target.view.superview?.bringSubviewToFront(target.view)
         CraftChrome.shared.beginTabSwipe(to: id, from: currentTab)
         lastNavigation = CACurrentMediaTime()
         CraftFramePacing.shared.begin("tab swipe")
@@ -1416,10 +1608,18 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         let completing = settleCompleting
         CraftFramePacing.shared.end("tab swipe")
         finish()
+        // The two pages are exactly one viewport apart. UIKit can reparent
+        // the outgoing layer when selection commits; its presentation frame
+        // then uses the new container's coordinates, not the old swipe's.
         let (stay, stayX, other, otherId, otherX) = completing
-            ? (target, targetX, current, outgoing, currentX)
-            : (current, currentX, target, targetId, targetX)
+            ? (target, targetX, current, outgoing, targetX - tabSwipeFrom)
+            : (current, currentX, target, targetId, currentX + tabSwipeFrom)
         guard abs(stayX) > 0.5 else { return }
+        // Selection removes UIKit's outgoing view. A caught interactive swipe
+        // needs it beside the new selected view again, in the same container.
+        if let container = stay.view.superview, other.view.superview !== container {
+            container.addSubview(other.view)
+        }
         stay.view.frame = view.bounds.offsetBy(dx: stayX, dy: 0)
         other.view.isHidden = false
         other.view.frame = view.bounds.offsetBy(dx: otherX, dy: 0)
@@ -1604,17 +1804,18 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         nav.view.backgroundColor = config.resolvedBackgroundColor
         nav.additionalSafeAreaInsets.bottom = safeAreaForTabBar()
         nav.setNavigationBarHidden(true, animated: false)
-        addChild(nav)
         nav.view.frame = view.bounds
         nav.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
         nav.view.isHidden = hidden
-        view.addSubview(nav.view)
-        nav.didMove(toParent: self)
         // Only once the stack's view has loaded: the recognizer is made then,
         // and before it is nil, so the delegate never took.
         for recognizer in popRecognizers(of: nav) { recognizer.delegate = self }
         stacks[tab] = nav
         shownStacks[ObjectIdentifier(nav)] = nav.viewControllers
+        synchronizeSystemTabs()
+        if hidden, nav.view.superview == nil, let container = visibleStack?.view.superview {
+            container.addSubview(nav.view)
+        }
         return nav
     }
 
@@ -1664,10 +1865,11 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             (nav.topViewController as? CraftNativeScreenController)?.screenVisibilityChanged(true)
         }
         currentTab = id
+        synchronizeSystemTabs()
         if let top = nav.topViewController { CraftChrome.shared.visiblePath = nativePaths[ObjectIdentifier(top)] }
         for (key, other) in stacks { other.view.isHidden = key != id }
         nav.view.frame = view.bounds
-        view.bringSubviewToFront(nav.view)
+        nav.view.superview?.bringSubviewToFront(nav.view)
         prepareAdjacentNativeTabs()
         if let slot = nav.topViewController as? CraftHybridWebSlot, slot.isViewLoaded {
             adoptWeb(into: slot)
@@ -2028,15 +2230,16 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     func tabBarCovers(_ height: CGFloat) {
         tabBarHeight = height
-        let inset = safeAreaForTabBar()
-        for nav in stacks.values where nav.additionalSafeAreaInsets.bottom != inset {
-            nav.additionalSafeAreaInsets.bottom = inset
-        }
     }
 
     private func safeAreaForTabBar() -> CGFloat {
-        let bottom = view.window?.safeAreaInsets.bottom ?? view.safeAreaInsets.bottom
-        return max(0, tabBarHeight - bottom)
+        // UIKit supplies the bar (and on iOS 26, its accessory) inset. Only
+        // the older-system accessory above that bar needs an extra inset.
+#if compiler(>=6.2)
+        if #available(iOS 26.0, *) { return 0 }
+#endif
+        let chrome = CraftChrome.shared
+        return chrome.tabBarVisible && !chrome.tabs.isEmpty && chrome.tabAccessory != nil ? 44 : 0
     }
 
     override func viewSafeAreaInsetsDidChange() {
@@ -2157,6 +2360,12 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
         if tabSwipeRecognizers.contains(where: { $0 === gestureRecognizer }) {
+            // System tab-bar tracking owns touches on the bar and accessory;
+            // Craft's content swipe must not steal their drag/hold gestures.
+            let point = gestureRecognizer.location(in: view)
+            if !tabBar.isHidden, tabBar.frame.contains(point) { return false }
+            if !accessoryButton.isHidden, accessoryButton.window != nil,
+               accessoryButton.convert(accessoryButton.bounds, to: view).contains(point) { return false }
             // A swipe may begin while the last one settles: it catches it.
             guard activeTabSwipeTarget == nil || tabSwipeSettling,
                   hybrid.tabIds.count > 1, let nav = visibleStack, let top = nav.topViewController else { return false }

package/templates/CraftNativeActions.swift

@@ -49,6 +49,7 @@ enum CraftNativeActions {
         values.append("storageSetIfAbsent")
         values.append("viewScroll")
         values.append("crypto")
+        values.append("shortcuts")
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -212,6 +213,17 @@ enum CraftNativeActions {
                 complete(requestToken, storage(method: method, args: args), completion)
             }
             return
+        case ("Shortcuts", _):
+            // UIKit quick actions belong to the app, not the calling route.
+            // A queued call from a disposed screen must not change that menu.
+            DispatchQueue.main.async {
+                cancellationLock.lock()
+                let cancelled = cancelledRequests.remove(requestToken) != nil
+                cancellationLock.unlock()
+                guard !cancelled else { return }
+                complete(requestToken, shortcuts(method: method, args: args), completion)
+            }
+            return
         case ("SecureStorage", _):
             guard config.enableSecureStorage else {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
@@ -950,6 +962,44 @@ enum CraftNativeActions {
         }
     }
 
+    private static func shortcuts(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
+        if method == "clear" {
+            guard args.isEmpty else { return failure("INVALID_ARGUMENT", "Shortcuts.clear takes no arguments") }
+            UIApplication.shared.shortcutItems = nil
+            return .success(true)
+        }
+        guard method == "set" else { return failure("UNSUPPORTED_METHOD", "Unknown Shortcuts method") }
+        guard args.count == 1, let items = args.first as? [[String: Any]], items.count <= 4 else {
+            return failure("INVALID_ARGUMENT", "Shortcuts.set needs a list of at most four shortcuts")
+        }
+        var types = Set<String>()
+        var shortcuts: [UIApplicationShortcutItem] = []
+        for item in items {
+            guard let type = item["type"] as? String, !type.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                  let title = item["title"] as? String, !title.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
+                  types.insert(type).inserted else {
+                return failure("INVALID_ARGUMENT", "Every shortcut needs a unique type and a non-empty title")
+            }
+            for name in ["subtitle", "iconName"] where item[name] != nil {
+                guard item[name] is String else { return failure("INVALID_ARGUMENT", "Shortcut \(name) must be a string") }
+            }
+            var userInfo: [String: NSSecureCoding]?
+            if let raw = item["userInfo"] {
+                guard let info = raw as? [String: Any], PropertyListSerialization.propertyList(info, isValidFor: .binary),
+                      let secure = info as? [String: NSSecureCoding] else {
+                    return failure("INVALID_ARGUMENT", "Shortcut userInfo must contain property-list values")
+                }
+                userInfo = secure
+            }
+            shortcuts.append(UIApplicationShortcutItem(type: type, localizedTitle: title,
+                localizedSubtitle: item["subtitle"] as? String,
+                icon: (item["iconName"] as? String).map { UIApplicationShortcutIcon(systemImageName: $0) }, userInfo: userInfo))
+        }
+        // Validate the whole list before replacing the previously valid menu.
+        UIApplication.shared.shortcutItems = shortcuts
+        return .success(["count": shortcuts.count])
+    }
+
     private static func storage(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
         do {
             if method == "clear" { try CraftPersistentStorage.clear(prefix: storagePrefix); return .success(true) }

package/templates/CraftNativeFiles.swift

@@ -192,10 +192,12 @@ enum CraftNativeFiles {
         do {
             let url = try newFile(named: name)
             guard let destination = CGImageDestinationCreateWithURL(url as CFURL, UTType.jpeg.identifier as CFString, 1, nil) else {
+                try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
                 return .failure(CraftNativeActionError(code: "WRITE_ERROR", message: "The photo could not be saved"))
             }
             CGImageDestinationAddImage(destination, image, [kCGImageDestinationLossyCompressionQuality: quality] as CFDictionary)
             guard CGImageDestinationFinalize(destination) else {
+                try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
                 return .failure(CraftNativeActionError(code: "WRITE_ERROR", message: "The photo could not be saved"))
             }
             return .success(describe(url, type: "image/jpeg", extra: ["width": image.width, "height": image.height]))
@@ -731,11 +733,11 @@ enum CraftNativeMedia {
         lock.lock()
         defer { lock.unlock() }
         if let flight, inFlight[address]?.id != flight {
-            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))
         }
         // A background transfer from before the cache was cleared (sign-out).
         if let stillWanted, !stillWanted() {
-            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))
         }
         let staging = root.appendingPathComponent(UUID().uuidString + ".part")
         defer { try? fm.removeItem(at: staging) }
@@ -784,7 +786,7 @@ enum CraftNativeMedia {
             catch { failure = error }
         }
         lock.unlock()
-        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))) }
+        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))) }
         if let failure { throw failure }
         return removed
     }

package/templates/CraftNativeScreen.swift

@@ -1443,6 +1443,16 @@ enum CraftBasemap: String {
     static let outdoorCredit = "Topography: Esri, USGS, NOAA, OpenStreetMap contributors"
 }
 
+private final class CraftMarkerPhotoRedirects: NSObject, URLSessionTaskDelegate {
+    static let session = URLSession(configuration: .ephemeral, delegate: CraftMarkerPhotoRedirects(), delegateQueue: nil)
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
+                    newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
+        let url = request.url
+        completionHandler(url?.scheme?.lowercased() == "https" && url?.user == nil && url?.password == nil ? request : nil)
+    }
+}
+
 private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var annotationsByID: [String: MKPointAnnotation] = [:]
     private var overlaysByID: [String: MKPolyline] = [:]
@@ -1467,6 +1477,26 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     private var edgePadding = UIEdgeInsets(top: 24, left: 24, bottom: 24, right: 24)
     private var markerBearings: [String: Double] = [:]
     private var markerPinColors: [String: UIColor] = [:]
+    private struct MarkerPhoto: Equatable {
+        let url: URL
+        let size: CGFloat
+        let circle: Bool
+
+        init?(_ props: [String: Any]) {
+            guard let raw = props["image"] as? String, let url = URL(string: raw),
+                  url.scheme?.lowercased() == "https", let host = url.host, !host.isEmpty,
+                  url.user == nil, url.password == nil else { return nil }
+            self.url = url
+            // Current STX releases preserve unknown HTML/binding spellings.
+            let value = CraftNativeMapView.numeric(props["imageSize"] ?? props["imagesize"] ?? props["image-size"]) ?? 30
+            size = CGFloat(value.isFinite ? min(96, max(16, value)) : 30)
+            circle = (props["imageShape"] ?? props["imageshape"] ?? props["image-shape"]) as? String != "square"
+        }
+    }
+    private var markerPhotos: [String: MarkerPhoto] = [:]
+    private var markerPhotoImages: [String: UIImage] = [:]
+    private var markerPhotoTasks: [String: URLSessionDataTask] = [:]
+    private var markerPhotoRequests: [String: UUID] = [:]
     private var tileOverlay: MKTileOverlay?
     private var tileTemplate: String?
     private var tileReplacesMap = true
@@ -1552,6 +1582,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         edgePadding = UIEdgeInsets(top: inset("top"), left: inset("left"), bottom: inset("bottom"), right: inset("right"))
         var nextBearings: [String: Double] = [:]
         var nextPinColors: [String: UIColor] = [:]
+        var nextPhotos: [String: MarkerPhoto] = [:]
         // Showing the user dot must not trigger a permission prompt from a
         // renderer pass. The app's existing location capability owns that
         // prompt; a map only opts in after authorization is already granted.
@@ -1580,6 +1611,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
                 guard let id = (overlay["id"] as? CustomStringConvertible)?.description,
                       let point = points.first else { continue }
                 nextMarkers[id] = (point, overlay["title"] as? String)
+                nextPhotos[id] = MarkerPhoto(overlay)
                 if let color = overlay["pinColor"] as? String { nextPinColors[id] = Self.color(color) }
                 if let bearing = Self.numeric(overlay["bearing"]), bearing.isFinite {
                     nextBearings[id] = bearing.truncatingRemainder(dividingBy: 360)
@@ -1598,6 +1630,7 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             if type == "mapmarker" || type == "marker" {
                 guard let point = points.first else { continue }
                 nextMarkers[id] = (point, childProps["title"] as? String)
+                nextPhotos[id] = MarkerPhoto(childProps)
                 if let color = childProps["pinColor"] as? String { nextPinColors[id] = Self.color(color) }
                 if let bearing = Self.numeric(childProps["bearing"]), bearing.isFinite {
                     nextBearings[id] = bearing.truncatingRemainder(dividingBy: 360)
@@ -1626,6 +1659,12 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
 
         markerBearings = nextBearings
         markerPinColors = nextPinColors
+        for id in markerPhotos.keys where markerPhotos[id] != nextPhotos[id] {
+            markerPhotoTasks.removeValue(forKey: id)?.cancel()
+            markerPhotoRequests.removeValue(forKey: id)
+            markerPhotoImages.removeValue(forKey: id)
+        }
+        markerPhotos = nextPhotos
         let staleMarkers = annotationsByID.keys.filter { nextMarkers[$0] == nil }
         removeAnnotations(staleMarkers.compactMap { annotationsByID.removeValue(forKey: $0) })
         for (id, value) in nextMarkers {
@@ -1642,6 +1681,9 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
             }
         }
         markerHandlers = nextHandlers
+        for (id, photo) in markerPhotos where markerPhotoRequests[id] == nil {
+            loadMarkerPhoto(photo, id: id)
+        }
 
         let staleOverlays = overlaysByID.keys.filter { nextPolylines[$0] == nil }
         for id in staleOverlays {
@@ -1773,6 +1815,11 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         markerHandlers.removeAll()
         markerBearings.removeAll()
         markerPinColors.removeAll()
+        markerPhotoTasks.values.forEach { $0.cancel() }
+        markerPhotoTasks.removeAll()
+        markerPhotoRequests.removeAll()
+        markerPhotoImages.removeAll()
+        markerPhotos.removeAll()
         removeAnnotations(Array(annotationsByID.values))
         annotationsByID.removeAll()
         removeOverlays(Array(overlaysByID.values))
@@ -1890,7 +1937,15 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
     }
 
     private func configureMarkerView(_ view: MKAnnotationView, id: String) {
-        if let bearing = markerBearings[id] {
+        if let photo = markerPhotoImages[id] {
+            view.image = photo
+            view.transform = .identity
+            view.displayPriority = .required
+            view.collisionMode = markerPhotos[id]?.circle == true ? .circle : .rectangle
+            if #available(iOS 14.0, *) { view.zPriority = .max }
+            view.isAccessibilityElement = true
+            view.accessibilityTraits = .button
+        } else if let bearing = markerBearings[id] {
             let color = (markerPinColors[id] ?? .systemGreen).resolvedColor(with: traitCollection)
             view.tintColor = color
             view.image = Self.markerImage(color: color, direction: true)
@@ -1919,6 +1974,45 @@ private final class CraftNativeMapView: MKMapView, MKMapViewDelegate {
         }
     }
 
+    private func loadMarkerPhoto(_ photo: MarkerPhoto, id: String) {
+        let request = UUID()
+        markerPhotoRequests[id] = request
+        let scale = window?.screen.scale ?? UIScreen.main.scale
+        let finish: (Data?) -> Void = { [weak self] data in
+            let pixels = CGSize(width: photo.size * scale, height: photo.size * scale)
+            let decoded = data.flatMap { $0.count <= 8 * 1024 * 1024 ? CraftNativeScreenController.decodeImage($0, fitting: (pixels, scale), fill: true) : nil }
+            DispatchQueue.main.async { [weak self] in
+                guard let self, self.markerPhotoRequests[id] == request else { return }
+                self.markerPhotoTasks.removeValue(forKey: id)
+                guard let decoded, decoded.size.width > 0, decoded.size.height > 0 else { return }
+                let size = CGSize(width: photo.size, height: photo.size)
+                let format = UIGraphicsImageRendererFormat()
+                format.scale = scale
+                self.markerPhotoImages[id] = UIGraphicsImageRenderer(size: size, format: format).image { _ in
+                    let bounds = CGRect(origin: .zero, size: size)
+                    if photo.circle { UIBezierPath(ovalIn: bounds).addClip() }
+                    let factor = max(photo.size / decoded.size.width, photo.size / decoded.size.height)
+                    let drawn = CGSize(width: decoded.size.width * factor, height: decoded.size.height * factor)
+                    decoded.draw(in: CGRect(x: (photo.size - drawn.width) / 2, y: (photo.size - drawn.height) / 2,
+                                            width: drawn.width, height: drawn.height))
+                }.withRenderingMode(.alwaysOriginal)
+                if let annotation = self.annotationsByID[id], let view = self.view(for: annotation) {
+                    self.configureMarkerView(view, id: id)
+                }
+            }
+        }
+        if let local = CraftNativeMedia.local(photo.url.absoluteString) {
+            DispatchQueue.global(qos: .userInitiated).async { finish(try? Data(contentsOf: local)) }
+        } else {
+            let task = CraftMarkerPhotoRedirects.session.dataTask(with: photo.url) { data, response, _ in
+                let response = response as? HTTPURLResponse
+                finish(response?.statusCode == 200 && response?.url?.scheme?.lowercased() == "https" ? data : nil)
+            }
+            markerPhotoTasks[id] = task
+            task.resume()
+        }
+    }
+
     private static let markerImages: NSCache<NSString, UIImage> = {
         let cache = NSCache<NSString, UIImage>()
         cache.countLimit = 64
@@ -4343,6 +4437,36 @@ final class CraftMapTapDelegate: NSObject, UIGestureRecognizerDelegate {
     }
 }
 
+/// A pressable wrapper must yield to an actionable descendant. Without this
+/// ordering UIKit may let the ancestor's tap recognizer win the same touch,
+/// so a nested Button never receives its physical action. A descendant
+/// control or tap recognizer is the source of the event; STX handles the
+/// logical bubbling from there.
+final class CraftPressGestureDelegate: NSObject, UIGestureRecognizerDelegate {
+    static let shared = CraftPressGestureDelegate()
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRequireFailureOf otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        guard let parent = gestureRecognizer.view,
+              let child = otherGestureRecognizer.view,
+              child !== parent else { return false }
+        return child.isDescendant(of: parent)
+    }
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
+        guard let container = gestureRecognizer.view else { return true }
+        let hitView = container.hitTest(touch.location(in: container), with: nil)
+        guard var candidate = hitView ?? touch.view else { return true }
+        while candidate !== container {
+            if candidate is UIControl { return false }
+            if candidate.gestureRecognizers?.contains(where: { $0 !== gestureRecognizer && $0 is UITapGestureRecognizer }) == true {
+                return false
+            }
+            candidate = candidate.superview ?? container
+        }
+        return true
+    }
+}
+
 /// The delegate of a Pressable's press-in/out feedback. That recognizer is
 /// a long press of no duration, so it begins the moment a finger lands; on its
 /// own it would claim the touch, and the tap that is the Pressable's onPress
@@ -6538,15 +6662,25 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let snapshotGet: @convention(block) (String) -> String? = { name in
             CraftSnapshots.read(name)
         }
-        let snapshotSet: @convention(block) (String, JSValue, JSValue) -> Void = { name, value, done in
-            CraftSnapshots.write(name, json: value.isNull || value.isUndefined ? nil : value.toString()) { ok in
-                CraftNativeScriptThread.run { done.call(withArguments: [ok]) }
+        // JavaScriptCore retains these outer host blocks. A weak capture only
+        // on the nested completion still makes the host block retain self,
+        // forming controller -> JSContext -> host block -> controller.
+        let snapshotSet: @convention(block) (String, JSValue, JSValue) -> Void = { [weak self] name, value, done in
+            CraftSnapshots.write(name, json: value.isNull || value.isUndefined ? nil : value.toString()) { [weak self] ok in
+                CraftNativeScriptThread.run {
+                    // A writer can finish after UIKit has disposed this
+                    // screen. Resolve the pending promise as a cancellation,
+                    // never as a successful write into a dead runtime.
+                    done.call(withArguments: [self?.runtimeDisposed != false ? false : ok])
+                }
             }
         }
-        let snapshotClear: @convention(block) (JSValue, JSValue) -> Void = { keep, done in
+        let snapshotClear: @convention(block) (JSValue, JSValue) -> Void = { [weak self] keep, done in
             let names = (keep.isUndefined || keep.isNull ? [] : (keep.toArray() ?? [])).compactMap { $0 as? String }
-            CraftSnapshots.clear(keeping: Set(names)) { ok in
-                CraftNativeScriptThread.run { done.call(withArguments: [ok]) }
+            CraftSnapshots.clear(keeping: Set(names)) { [weak self] ok in
+                CraftNativeScriptThread.run {
+                    done.call(withArguments: [self?.runtimeDisposed != false ? false : ok])
+                }
             }
         }
         let config = self.config
@@ -6608,34 +6742,35 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                     if (runtimeCallback) runtimeCallback(raw);
                 };
                 var nextRequest = 0;
-                function request(method, args) {
+                function request(module, method, args, untimed) {
                     return new Promise(function(resolve, reject) {
-                        var id = 'craft-dialog-' + (++nextRequest);
+                        var id = 'craft-host-' + (++nextRequest);
                         var remove = bridge.addMessageListener(function(raw) {
                             var message;
                             try { message = typeof raw === 'string' ? JSON.parse(raw) : raw; } catch (error) { return; }
                             var payload = message && message.payload;
                             if (!payload || payload.requestId !== id) return;
+                            if (message.type !== 'API_ERROR' && message.type !== 'API_RESPONSE') return;
                             remove();
                             if (message.type === 'API_ERROR') {
-                                var failure = new Error(payload.message || 'Native dialog failed');
+                                var failure = new Error(payload.message || 'Native capability failed');
                                 failure.code = payload.code || 'NATIVE_CALL_FAILED';
                                 reject(failure);
                             } else if (message.type === 'API_RESPONSE') {
                                 resolve(payload.data === undefined ? null : payload.data);
                             }
                         });
-                        bridge.postMessage(JSON.stringify({
+                        try { bridge.postMessage(JSON.stringify({
                             type: 'API_REQUEST',
                             id: id,
                             payload: {
                                 version: bridge.capabilityProtocolVersion || 1,
-                                module: 'Dialog',
+                                module: module,
                                 method: method,
                                 args: args,
-                                untimed: true
+                                untimed: untimed === true
                             }
-                        }));
+                        })); } catch (error) { remove(); reject(error); }
                     });
                 }
                 // Native capability ownership wins over any browser-shaped
@@ -6646,11 +6781,29 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                     var craft = globalThis.craft = globalThis.craft || {};
                     if (Array.isArray(bridge.capabilities) && bridge.capabilities.indexOf('dialog') >= 0) {
                         craft.dialog = {
-                            alert: function(options) { return request('alert', [options || {}]).then(function() {}); },
-                            confirm: function(options) { return request('confirm', [options || {}]).then(Boolean); },
-                            actionSheet: function(options) { return request('actionSheet', [options || {}]).then(function(id) { return typeof id === 'string' ? id : null; }); }
+                            alert: function(options) { return request('Dialog', 'alert', [options || {}], true).then(function() {}); },
+                            confirm: function(options) { return request('Dialog', 'confirm', [options || {}], true).then(Boolean); },
+                            actionSheet: function(options) { return request('Dialog', 'actionSheet', [options || {}], true).then(function(id) { return typeof id === 'string' ? id : null; }); }
                         };
                     }
+                    if (Array.isArray(bridge.capabilities) && bridge.capabilities.indexOf('shortcuts') >= 0) {
+                        var shortcuts = {
+                            set: function(items) { return request('Shortcuts', 'set', [items]); },
+                            clear: function() { return request('Shortcuts', 'clear', []); }
+                        };
+                        // An older STX bundle may install a browser-only
+                        // namespace. Preserve extras, but keep set/clear native.
+                        Object.defineProperty(craft, 'shortcuts', {
+                            configurable: true, enumerable: true,
+                            get: function() { return shortcuts; },
+                            set: function(value) {
+                                if (!value || typeof value !== 'object') return;
+                                value.set = shortcuts.set;
+                                value.clear = shortcuts.clear;
+                                shortcuts = value;
+                            }
+                        });
+                    }
                 }
                 globalThis.__craftInstallNativeDialog = installNativeDialog;
                 installNativeDialog();
@@ -7304,7 +7457,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         scroll?.contentInsetAdjustmentBehavior = edgeToEdge ? .automatic : .never
         guard scroll !== trackedScrollView else { return }
         trackedScrollView = scroll
-        setContentScrollView(scroll, for: .top)
+        // The same primary vertical scroller drives the navigation bar and
+        // the system tab bar's scroll-edge/minimization behavior.
+        setContentScrollView(scroll, for: [.top, .bottom])
     }
 
     private func observeNativeEvents() {
@@ -7915,20 +8070,15 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             screenRequestCancellers[requestToken] = { [weak self] in self?.sounds.stop(id: id, fadeOut: 0) }
             sounds.play(id: id, url: url, options: args.count > 2 ? args[2] as? [String: Any] ?? [:] : [:], answer: reply)
         case ("Audio", "pause"):
-            sounds.pause(id: id)
-            reply(.success(true))
+            reply(.success(sounds.pause(id: id)))
         case ("Audio", "resume"):
-            sounds.resume(id: id)
-            reply(.success(true))
+            reply(.success(sounds.resume(id: id)))
         case ("Audio", "setVolume"):
-            sounds.setVolume(id: id, volume: number(1), fade: number(2, "fade") / 1000)
-            reply(.success(true))
+            reply(.success(sounds.setVolume(id: id, volume: number(1), fade: number(2, "fade") / 1000)))
         case ("Audio", "stop"):
-            sounds.stop(id: id, fadeOut: number(1, "fadeOut") / 1000)
-            reply(.success(true))
+            reply(.success(sounds.stop(id: id, fadeOut: number(1, "fadeOut") / 1000)))
         case ("Audio", "stopAll"):
-            sounds.stopAll(fadeOut: number(0, "fadeOut") / 1000)
-            reply(.success(true))
+            reply(.success(sounds.stopAll(fadeOut: number(0, "fadeOut") / 1000)))
         default:
             return false
         }
@@ -8082,6 +8232,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private func clearRenderedTree() {
         if let root = renderedRoot { detach(root, from: rootStack) }
         renderedRoot = nil
+        trackedScrollView = nil
+        setContentScrollView(nil, for: [.top, .bottom])
         rootIsSafeAreaView = false
         rootStack.setViewportChild(nil, fillsHeight: false)
         rootTopToSafeArea?.isActive = true
@@ -9339,6 +9491,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let actionable = handler != nil || linkTargets[id] != nil
         if actionable, tapRecognizers[id] == nil {
             let recognizer = UITapGestureRecognizer(target: self, action: #selector(viewPressed(_:)))
+            recognizer.cancelsTouchesInView = false
+            recognizer.delegate = CraftPressGestureDelegate.shared
             tapRecognizers[id] = recognizer
             view.addGestureRecognizer(recognizer)
         } else if !actionable, let recognizer = tapRecognizers.removeValue(forKey: id) {
@@ -10111,6 +10265,26 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             // Decoded at the size it is drawn, when the style fixes that size.
             let pixels = Self.displayPixels(of: view)
             let fill = view.contentMode == .scaleAspectFill
+            // media.keep owns private/offline copies keyed by the authored URL.
+            // Read before the decoded/network cache, without retaining private
+            // pixels there after the app clears its media on sign-out.
+            if let local = CraftNativeMedia.local(uri) {
+                DispatchQueue.global(qos: .userInitiated).async { [weak self, weak view] in
+                    let decoded = (try? Data(contentsOf: local)).flatMap { Self.decodeImage($0, fitting: pixels, fill: fill) }
+                    DispatchQueue.main.async { [weak self, weak view] in
+                        guard let self, let view, self.imageSources[ObjectIdentifier(view)] == requestKey else { return }
+                        guard let image = decoded, CraftNativeMedia.local(uri) == local else {
+                            self.imageFailure(view, uri: uri, message: "Kept image is unavailable or invalid")
+                            return
+                        }
+                        view.image = self.imageForDisplay(image, view: view)
+                        self.imageDidChange(view)
+                        self.emitImageEvent(view, handler: self.imageLoadHandlers[ObjectIdentifier(view)])
+                        self.emitImageEvent(view, handler: self.imageLoadEndHandlers[ObjectIdentifier(view)])
+                    }
+                }
+                return
+            }
             let cacheKey = pixels.map { "\(requestKey)@\(Int($0.size.width))x\(Int($0.size.height))\(fill ? "f" : "")" } ?? requestKey
             // Shown before: on screen in this same frame, already decoded.
             if let decoded = Self.decodedImages.object(forKey: cacheKey as NSString) {
@@ -10239,7 +10413,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let controlledVideo = type == "Video" && (props["controls"] as? Bool) == true
         // UIPickerView exposes adjustable component wheels. Making the
         // picker itself a leaf hides those wheels and their selected values.
-        let container = ["ScrollView", "FlatList", "SectionList", "Picker", "SegmentedControl"].contains(type)
+        let container = ["ScrollView", "FlatList", "SectionList", "Picker", "SegmentedControl", "Modal", "Drawer"].contains(type)
             || ["tablist", "radiogroup", "list", "menu", "menubar", "toolbar"].contains(role ?? "")
             || controlledVideo
         view.isAccessibilityElement = !container && role != "none" && (view.accessibilityLabel != nil || role != nil || ["Text", "Button", "Link", "Checkbox", "Image", "ImageBackground", "Video", "TextInput", "Picker", "DatePicker", "Switch", "Slider"].contains(type))

package/templates/CraftNativeServices.swift

@@ -279,6 +279,7 @@ final class CraftNativeSounds {
         /// The volume asked for; a fade in or out moves toward or away from it.
         var volume: Float
         var paused = false
+        var interrupted = false
 
         init(player: AVQueuePlayer, volume: Float) {
             self.player = player
@@ -306,9 +307,44 @@ final class CraftNativeSounds {
     private static var category: AVAudioSession.Category = .ambient
 
     private var sounds: [String: Sound] = [:]
+    private var interruptionObserver: NSObjectProtocol?
     /// `{ id, event: "ended" | "error", message? }` to the screen's script.
     var emit: (([String: Any]) -> Void)?
 
+    init() {
+        interruptionObserver = NotificationCenter.default.addObserver(
+            forName: AVAudioSession.interruptionNotification,
+            object: nil,
+            queue: .main,
+        ) { [weak self] note in
+            guard let self else { return }
+            let type = (note.userInfo?[AVAudioSessionInterruptionTypeKey] as? NSNumber)?.uintValue
+            if type == AVAudioSession.InterruptionType.began.rawValue {
+                self.sounds.values.forEach { sound in
+                    guard !sound.paused else { return }
+                    sound.interrupted = true
+                    sound.player.pause()
+                }
+                return
+            }
+            guard type == AVAudioSession.InterruptionType.ended.rawValue else { return }
+            let options = (note.userInfo?[AVAudioSessionInterruptionOptionKey] as? NSNumber)?.uintValue ?? 0
+            let shouldResume = options & AVAudioSession.InterruptionOptions.shouldResume.rawValue != 0
+            self.sounds.values.forEach { sound in
+                guard sound.interrupted else { return }
+                sound.interrupted = false
+                // Without permission to auto-resume, keep a resumable paused
+                // handle. A later unrelated interruption must not restart it.
+                sound.paused = !shouldResume
+                if shouldResume { sound.player.play() }
+            }
+        }
+    }
+
+    deinit {
+        if let interruptionObserver { NotificationCenter.default.removeObserver(interruptionObserver) }
+    }
+
     /// Starts `url`. `answer` hears once it plays (or could not be loaded).
     func play(id: String, url: URL, options: [String: Any], answer: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
         stop(id: id, fadeOut: 0)
@@ -362,40 +398,52 @@ final class CraftNativeSounds {
         if fadeIn > 0 { ramp(sound, to: volume, over: fadeIn) }
     }
 
-    func pause(id: String) {
-        guard let sound = sounds[id] else { return }
+    @discardableResult
+    func pause(id: String) -> Bool {
+        guard let sound = sounds[id] else { return false }
         sound.paused = true
+        sound.interrupted = false
         sound.fade?.invalidate()
         sound.player.pause()
+        return true
     }
 
-    func resume(id: String) {
-        guard let sound = sounds[id], sound.paused else { return }
+    @discardableResult
+    func resume(id: String) -> Bool {
+        guard let sound = sounds[id], sound.paused else { return false }
         sound.paused = false
+        sound.interrupted = false
         sound.player.volume = sound.volume
         sound.player.play()
+        return true
     }
 
     /// Changes the volume, over `fade` seconds when given.
-    func setVolume(id: String, volume: Double, fade: Double) {
-        guard let sound = sounds[id] else { return }
+    @discardableResult
+    func setVolume(id: String, volume: Double, fade: Double) -> Bool {
+        guard let sound = sounds[id] else { return false }
         sound.volume = Float(min(max(volume, 0), 1))
         if fade > 0, !sound.paused { ramp(sound, to: sound.volume, over: fade) }
         else { sound.fade?.invalidate(); sound.player.volume = sound.volume }
+        return true
     }
 
     /// Stops the sound, fading it out over `fadeOut` seconds first.
-    func stop(id: String, fadeOut: Double) {
-        guard let sound = sounds[id] else { return }
-        guard fadeOut > 0, !sound.paused else { remove(id); return }
+    @discardableResult
+    func stop(id: String, fadeOut: Double) -> Bool {
+        guard let sound = sounds[id] else { return false }
+        guard fadeOut > 0, !sound.paused else { remove(id); return true }
         ramp(sound, to: 0, over: fadeOut) { [weak self, weak sound] in
             guard let self, let sound, self.sounds[id] === sound else { return }
             self.remove(id)
         }
+        return true
     }
 
-    func stopAll(fadeOut: Double) {
+    @discardableResult
+    func stopAll(fadeOut: Double) -> Bool {
         for id in Array(sounds.keys) { stop(id: id, fadeOut: fadeOut) }
+        return true
     }
 
     /// The screen closed: everything stops at once.