@craft-native/ios 0.0.177 → 0.0.180

package/dist/cli.js

@@ -871,6 +871,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftNativeActions.swift"), join3(output, "Sources", "CraftNativeActions.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHealth.swift"), join3(output, "Sources", "CraftHealth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftMusic.swift"), join3(output, "Sources", "CraftMusic.swift"));
+  cpSync(join3(TEMPLATES_DIR, "CraftBluetooth.swift"), join3(output, "Sources", "CraftBluetooth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHeartRate.swift"), join3(output, "Sources", "CraftHeartRate.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftScheduledWorkouts.swift"), join3(output, "Sources", "CraftScheduledWorkouts.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeMutation.swift"), join3(output, "Sources", "CraftNativeMutation.swift"));

package/dist/index.js

@@ -1003,6 +1003,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftNativeActions.swift"), join3(output, "Sources", "CraftNativeActions.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHealth.swift"), join3(output, "Sources", "CraftHealth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftMusic.swift"), join3(output, "Sources", "CraftMusic.swift"));
+  cpSync(join3(TEMPLATES_DIR, "CraftBluetooth.swift"), join3(output, "Sources", "CraftBluetooth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHeartRate.swift"), join3(output, "Sources", "CraftHeartRate.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftScheduledWorkouts.swift"), join3(output, "Sources", "CraftScheduledWorkouts.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeMutation.swift"), join3(output, "Sources", "CraftNativeMutation.swift"));

package/package.json

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

package/templates/CraftApp.swift

@@ -2564,6 +2564,17 @@ struct CraftWebView: UIViewRepresentable {
                     rejectCallback(callbackId, error: "Local database is disabled", code: "CAPABILITY_DISABLED")
                 }
             // MARK: - Bluetooth
+            case "bluetoothChannel":
+                guard config.enableBluetooth else {
+                    rejectCallback(callbackId, error: "Bluetooth is disabled", code: "CAPABILITY_DISABLED")
+                    break
+                }
+                CraftBluetooth.shared.perform(method: body["method"] as? String ?? "", args: [body["options"] as? [String: Any] ?? [:]]) { [weak self] result in
+                    switch result {
+                    case .success(let value): self?.resolveCallback(callbackId, result: value)
+                    case .failure(let error): self?.rejectCallback(callbackId, error: error.message, code: error.code)
+                    }
+                }
             case "startBluetoothScan":
                 if config.enableBluetooth {
                     startBluetoothScan(callbackId: callbackId)
@@ -5288,6 +5299,14 @@ struct CraftWebView: UIViewRepresentable {
                 // natively, screen locked or app closed, until stopRecording().
                 (function() {
                     function heartRate(method, options) { return craft._invoke('heartRate', {method: method, options: options || {}}); }
+                    craft.bluetooth = {
+                        getState: function() { return craft._invoke('bluetoothChannel', {method: 'getState'}); },
+                        scan: function(options) { return craft._invoke('bluetoothChannel', {method: 'scan', options: options || {}}); },
+                        stopScan: function() { return craft._invoke('bluetoothChannel', {method: 'stopScan'}); },
+                        connect: function(options) { return craft._invoke('bluetoothChannel', {method: 'connect', options: options || {}}); },
+                        exchange: function(options) { return craft._invoke('bluetoothChannel', {method: 'exchange', options: options || {}}); },
+                        disconnect: function() { return craft._invoke('bluetoothChannel', {method: 'disconnect'}); }
+                    };
                     craft.heartRate = {
                         getState: function() { return heartRate('getState'); },
                         requestAuthorization: function() { return craft._invoke('heartRateRequestAuthorization'); },

package/templates/CraftBluetooth.swift

@@ -0,0 +1,243 @@
+import CoreBluetooth
+import Foundation
+
+struct CraftBluetoothError: Error {
+    let message: String
+    let code: String
+}
+
+/// One explicitly chosen GATT channel. Scanning is user initiated; no vendor API.
+final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
+    typealias Completion = (Result<Any, CraftBluetoothError>) -> Void
+    static let shared = CraftBluetooth()
+    private var central: CBCentralManager?
+    private var devices: [String: CBPeripheral] = [:]
+    private var names: [String: String] = [:]
+    private var strengths: [String: Int] = [:]
+    private var scanServices: [CBUUID] = []
+    private var namePrefix = ""
+    private var scanCompletion: Completion?
+    private var scanTimer: DispatchWorkItem?
+    private var peripheral: CBPeripheral?
+    private var serviceUUID: CBUUID?
+    private var writeUUID: CBUUID?
+    private var notifyUUID: CBUUID?
+    private var writer: CBCharacteristic?
+    private var notifier: CBCharacteristic?
+    private var connectCompletion: Completion?
+    private var connectTimer: DispatchWorkItem?
+    private var exchangeCompletion: Completion?
+    private var exchangeTimer: DispatchWorkItem?
+    private var responsePrefix = Data()
+    private var connected = false
+
+    func perform(method: String, args: [Any], completion: @escaping Completion) {
+        if !Thread.isMainThread {
+            DispatchQueue.main.async { self.perform(method: method, args: args, completion: completion) }
+            return
+        }
+        let options = args.first as? [String: Any] ?? [:]
+        switch method {
+        case "getState":
+            completion(.success(["available": true, "connected": connected, "scanning": scanCompletion != nil]))
+        case "scan": scan(options, completion)
+        case "stopScan": stopScan(); completion(.success(true))
+        case "connect": connect(options, completion)
+        case "exchange": exchange(options, completion)
+        case "disconnect": disconnect(); completion(.success(true))
+        default: reject(completion, "Unsupported Bluetooth method", "UNKNOWN_ACTION")
+        }
+    }
+
+    private func reject(_ completion: Completion, _ message: String, _ code: String) {
+        completion(.failure(CraftBluetoothError(message: message, code: code)))
+    }
+
+    private func ensureCentral() {
+        if central == nil { central = CBCentralManager(delegate: self, queue: .main) }
+    }
+
+    private func scan(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard scanCompletion == nil, connectCompletion == nil, exchangeCompletion == nil else {
+            return reject(completion, "A Bluetooth operation is already running", "BUSY")
+        }
+        guard let services = options["services"] as? [String], !services.isEmpty, services.count <= 8,
+              services.allSatisfy({ UUID(uuidString: $0) != nil }) else {
+            return reject(completion, "Scan needs full service UUIDs", "INVALID_ARGUMENT")
+        }
+        let timeout = min(20, max(1, (options["timeoutMs"] as? Double ?? 10000) / 1000))
+        scanServices = services.map(CBUUID.init(string:))
+        namePrefix = options["namePrefix"] as? String ?? ""
+        devices.removeAll(); names.removeAll(); strengths.removeAll()
+        scanCompletion = completion
+        ensureCentral()
+        if central?.state == .poweredOn { startScan() }
+        else if let state = central?.state, state != .unknown, state != .resetting { rejectRadio(state); return }
+        let timer = DispatchWorkItem { [weak self] in self?.finishScan() }
+        scanTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout, execute: timer)
+    }
+
+    private func startScan() {
+        guard scanCompletion != nil else { return }
+        central?.scanForPeripherals(withServices: scanServices, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
+    }
+
+    private func finishScan() {
+        central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
+        let completion = scanCompletion; scanCompletion = nil
+        let rows: [[String: Any]] = devices.keys.sorted().map { ["id": $0, "name": names[$0] ?? "", "rssi": strengths[$0] ?? -127] }
+        completion?(.success(rows))
+    }
+
+    private func stopScan() {
+        central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
+        let completion = scanCompletion; scanCompletion = nil
+        if let completion { reject(completion, "Bluetooth scan cancelled", "CANCELLED") }
+    }
+
+    private func rejectRadio(_ state: CBManagerState) {
+        let code = state == .unauthorized ? "NOT_AUTHORIZED" : state == .poweredOff ? "BLUETOOTH_OFF" : "UNSUPPORTED"
+        let failure = CraftBluetoothError(message: "Bluetooth is not available", code: code)
+        central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
+        let scan = scanCompletion; scanCompletion = nil; scan?(.failure(failure))
+        settleConnect(.failure(failure)); settleExchange(.failure(failure))
+        connected = false
+    }
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        if central.state == .poweredOn { startScan() }
+        else if central.state != .unknown, central.state != .resetting { rejectRadio(central.state) }
+    }
+
+    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 ?? ""
+        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
+    }
+
+    private func connect(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard scanCompletion == nil, connectCompletion == nil, exchangeCompletion == nil else {
+            return reject(completion, "A Bluetooth operation is already running", "BUSY")
+        }
+        guard let id = options["id"] as? String, let found = devices[id],
+              let service = options["service"] as? String, UUID(uuidString: service) != nil,
+              let write = options["write"] as? String, UUID(uuidString: write) != nil,
+              let notify = options["notify"] as? String, UUID(uuidString: notify) != nil else {
+            return reject(completion, "Choose a nearby device and its GATT channel", "INVALID_ARGUMENT")
+        }
+        guard central?.state == .poweredOn else { return reject(completion, "Bluetooth is off", "BLUETOOTH_OFF") }
+        disconnect()
+        peripheral = found; serviceUUID = CBUUID(string: service); writeUUID = CBUUID(string: write); notifyUUID = CBUUID(string: notify)
+        found.delegate = self; connectCompletion = completion
+        central?.connect(found, options: nil)
+        let timer = DispatchWorkItem { [weak self] in
+            guard let self else { return }
+            self.settleConnect(.failure(CraftBluetoothError(message: "Device did not connect; wake it and try again", code: "TIMEOUT")))
+            self.disconnect()
+        }
+        connectTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + 15, execute: timer)
+    }
+
+    private func settleConnect(_ result: Result<Any, CraftBluetoothError>) {
+        connectTimer?.cancel(); connectTimer = nil
+        let completion = connectCompletion; connectCompletion = nil; completion?(result)
+    }
+
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        guard peripheral === self.peripheral, let serviceUUID else { return }
+        peripheral.discoverServices([serviceUUID])
+    }
+
+    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        settleConnect(.failure(CraftBluetoothError(message: "Bluetooth connection failed", code: "CONNECT_FAILED")))
+        disconnect()
+    }
+
+    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        connected = false; writer = nil; notifier = nil
+        settleConnect(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
+        settleExchange(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        guard error == nil, let service = peripheral.services?.first(where: { $0.uuid == serviceUUID }), let writeUUID, let notifyUUID else {
+            settleConnect(.failure(CraftBluetoothError(message: "The selected GATT service is missing", code: "UNSUPPORTED_DEVICE"))); disconnect(); return
+        }
+        peripheral.discoverCharacteristics([writeUUID, notifyUUID], for: service)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        writer = service.characteristics?.first(where: { $0.uuid == writeUUID })
+        notifier = service.characteristics?.first(where: { $0.uuid == notifyUUID })
+        guard error == nil, let writer, let notifier, writer.properties.contains(.write) || writer.properties.contains(.writeWithoutResponse), notifier.properties.contains(.notify) else {
+            settleConnect(.failure(CraftBluetoothError(message: "The selected GATT channel is missing", code: "UNSUPPORTED_DEVICE"))); disconnect(); return
+        }
+        peripheral.setNotifyValue(true, for: notifier)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
+        guard peripheral === self.peripheral, characteristic === notifier else { return }
+        guard error == nil, characteristic.isNotifying else {
+            settleConnect(.failure(CraftBluetoothError(message: "Could not subscribe to the device", code: "CONNECT_FAILED"))); disconnect(); return
+        }
+        connected = true
+        let id = peripheral.identifier.uuidString
+        settleConnect(.success(["id": id, "name": names[id] ?? peripheral.name ?? ""]))
+    }
+
+    private func exchange(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard exchangeCompletion == nil else { return reject(completion, "A Bluetooth request is already running", "BUSY") }
+        guard connected, let peripheral, let writer else { return reject(completion, "Bluetooth device is disconnected", "DISCONNECTED") }
+        guard let bytes = options["bytes"] as? [Int], !bytes.isEmpty, bytes.count <= 182, bytes.allSatisfy({ (0...255).contains($0) }),
+              let prefix = options["responsePrefix"] as? [Int], !prefix.isEmpty, prefix.count <= 16, prefix.allSatisfy({ (0...255).contains($0) }) else {
+            return reject(completion, "Invalid Bluetooth request bytes", "INVALID_ARGUMENT")
+        }
+        let type: CBCharacteristicWriteType = writer.properties.contains(.write) ? .withResponse : .withoutResponse
+        guard bytes.count <= peripheral.maximumWriteValueLength(for: type) else { return reject(completion, "Bluetooth request exceeds the negotiated MTU", "MTU_TOO_SMALL") }
+        if type == .withoutResponse, !peripheral.canSendWriteWithoutResponse { return reject(completion, "Bluetooth write queue is busy; retry", "BUSY") }
+        responsePrefix = Data(prefix.map(UInt8.init)); exchangeCompletion = completion
+        let timeout = min(20, max(1, (options["timeoutMs"] as? Double ?? 10000) / 1000))
+        let timer = DispatchWorkItem { [weak self] in self?.settleExchange(.failure(CraftBluetoothError(message: "Bluetooth device did not answer", code: "TIMEOUT"))) }
+        exchangeTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout, execute: timer)
+        peripheral.writeValue(Data(bytes.map(UInt8.init)), for: writer, type: type)
+    }
+
+    private func settleExchange(_ result: Result<Any, CraftBluetoothError>) {
+        exchangeTimer?.cancel(); exchangeTimer = nil
+        let completion = exchangeCompletion; exchangeCompletion = nil; responsePrefix = Data(); completion?(result)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
+        guard peripheral === self.peripheral, characteristic === writer, error != nil else { return }
+        settleExchange(.failure(CraftBluetoothError(message: "Bluetooth write failed", code: "WRITE_FAILED")))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
+        guard peripheral === self.peripheral, characteristic === notifier, exchangeCompletion != nil else { return }
+        guard error == nil, let data = characteristic.value else {
+            settleExchange(.failure(CraftBluetoothError(message: "Bluetooth notification failed", code: "READ_FAILED"))); return
+        }
+        guard data.starts(with: responsePrefix) else { return }
+        guard data.count <= 4096 else {
+            settleExchange(.failure(CraftBluetoothError(message: "Bluetooth response is too large", code: "INVALID_RESPONSE"))); return
+        }
+        settleExchange(.success(data.map(Int.init)))
+    }
+
+    private func disconnect() {
+        stopScan()
+        settleConnect(.failure(CraftBluetoothError(message: "Bluetooth connection cancelled", code: "CANCELLED")))
+        settleExchange(.failure(CraftBluetoothError(message: "Bluetooth request cancelled", code: "CANCELLED")))
+        if let peripheral { central?.cancelPeripheralConnection(peripheral); peripheral.delegate = nil }
+        peripheral = nil; writer = nil; notifier = nil; connected = false
+    }
+}

package/templates/CraftCrashReporter.swift

@@ -189,7 +189,7 @@ private func craftCollectFrames(_ context: UnsafeMutableRawPointer?) -> Int {
         let returnAddress = craftStrip(record.1)
         // In a leaf function the caller is only in the link register: the
         // first saved return address then belongs to the caller's caller.
-        if first, lr != 0, craftStrip(lr) != returnAddress, count < craftCrashMaxFrames {
+        if first, lr != 0, craftStrip(lr) != returnAddress, craftStrip(lr) != frames[0], count < craftCrashMaxFrames {
             frames[count] = craftStrip(lr); count += 1
         }
         first = false
@@ -478,7 +478,13 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
         let frames = addresses.map { frame(for: $0, in: images) }
         let signalName = Self.signalName(signal)
         let type = exceptionName ?? signalName
-        var message = messages.first(where: { $0.contains("Fatal error") || $0.contains("fatal error") }) ?? messages.first ?? ""
+        // A runtime's own words when it trapped on purpose (Swift's "Fatal
+        // error: …", an assertion); an abort's first annotation otherwise.
+        // Never the simulator's device banner, which some image's
+        // __crash_info carries on every simulator process.
+        let deliberate = messages.first(where: { $0.localizedCaseInsensitiveContains("fatal error") || $0.contains("Assertion failed") || $0.contains("Precondition failed") })
+        let annotation = signal == SIGABRT ? messages.first(where: { !$0.hasPrefix("CoreSimulator") }) : nil
+        var message: String = deliberate ?? annotation ?? ""
         if message.isEmpty {
             message = Self.signalDescription(signal, code: code, address: faultAddress)
         }
@@ -497,7 +503,8 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
         event["timestamp"] = Self.iso(crashedAt)
         event["exception"] = exception
         event["breadcrumbs"] = Array(previousCrumbs.suffix(50))
-        event["tags"] = ["mechanism": exception["mechanism"] as? String ?? "signal"]
+        let mechanism: String = exception["mechanism"] as? String ?? "signal"
+        event["tags"] = ["mechanism": mechanism]
         if let version = previousSession["version"] as? String, let build = previousSession["build"] as? String {
             var contexts = event["contexts"] as? [String: Any] ?? [:]
             var app = contexts["app"] as? [String: Any] ?? [:]
@@ -645,7 +652,8 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
             if let last = self.lastJavaScriptError, last.key == key, Date().timeIntervalSince(last.at) < 5 { return }
             self.lastJavaScriptError = (key, Date())
             var event = self.baseEvent(release: self.release, sessionId: self.sessionId, sessionStart: Self.iso(self.sessionStart))
-            event["type"] = (name?.isEmpty == false ? name : nil) ?? "Error"
+            let type: String = name.flatMap { $0.isEmpty ? nil : $0 } ?? "Error"
+            event["type"] = type
             event["message"] = message
             if !stack.isEmpty, stack != "undefined" { event["stack"] = stack }
             event["level"] = "error"
@@ -757,6 +765,11 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
 
     private func baseEvent(release: String, sessionId: String?, sessionStart: String?) -> [String: Any] {
         let device = UIDevice.current
+        let info = Bundle.main.infoDictionary
+        let appName: String = info?["CFBundleDisplayName"] as? String ?? info?["CFBundleName"] as? String ?? ""
+        // Typed, not inline: against `Any`, `Locale.current.identifier` picks
+        // iOS 16's `identifier(_:)` method and stores a function.
+        let locale: String = Locale.current.identifier
         var event: [String: Any] = [
             "platform": "ios",
             "release": release,
@@ -768,7 +781,7 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
             "contexts": [
                 "app": [
                     "id": Bundle.main.bundleIdentifier ?? "",
-                    "name": Bundle.main.infoDictionary?["CFBundleDisplayName"] as? String ?? (Bundle.main.infoDictionary?["CFBundleName"] as? String ?? ""),
+                    "name": appName,
                     "version": appVersion,
                     "build": appBuild,
                 ],
@@ -776,7 +789,7 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
                     "model": Self.deviceModel(),
                     "family": device.model,
                     "simulator": Self.isSimulator,
-                    "locale": Locale.current.identifier,
+                    "locale": locale,
                 ],
                 "os": ["name": "iOS", "version": device.systemVersion],
             ],
@@ -789,8 +802,16 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
     private var craftVersion: String { "{{CRAFT_VERSION}}" }
 
     private func enqueue(_ endpoint: String, _ body: [String: Any]) {
-        guard let outbox, JSONSerialization.isValidJSONObject(["endpoint": endpoint, "body": body]),
-              let data = try? JSONSerialization.data(withJSONObject: ["endpoint": endpoint, "body": body]) else { return }
+        // Through jsonSafe first: a `[String: Any]` built in Swift can hold an
+        // Optional (a `??` inferred against `Any`), and a page's event can hold
+        // anything at all. Either made the whole event invalid JSON, and it was
+        // dropped without a word.
+        let item: [String: Any] = ["endpoint": endpoint, "body": Self.jsonSafe(body)]
+        guard let outbox, JSONSerialization.isValidJSONObject(item),
+              let data = try? JSONSerialization.data(withJSONObject: item) else {
+            CraftNativeConsole.write("error", category: "crash-reporter", message: "dropped an \(endpoint) event that is not JSON")
+            return
+        }
         let name = String(format: "%013.0f-%@.json", Date().timeIntervalSince1970 * 1000, UUID().uuidString)
         try? data.write(to: outbox.appendingPathComponent(name), options: .atomic)
         flush()
@@ -893,6 +914,49 @@ final class CraftCrashReporter: NSObject, MXMetricManagerSubscriber {
 
     // MARK: Helpers
 
+    /// `value` as something JSONSerialization accepts: Optionals unwrapped
+    /// (nil is null), integers of every width as numbers, dates as ISO
+    /// strings, and anything else as its description.
+    static func jsonSafe(_ value: Any) -> Any {
+        let mirror = Mirror(reflecting: value)
+        if mirror.displayStyle == .optional {
+            guard let wrapped = mirror.children.first?.value else { return NSNull() }
+            return jsonSafe(wrapped)
+        }
+        switch value {
+        case let dictionary as [String: Any]:
+            return dictionary.mapValues { jsonSafe($0) }
+        case let dictionary as NSDictionary:
+            var out: [String: Any] = [:]
+            for (key, item) in dictionary { out[String(describing: key)] = jsonSafe(item) }
+            return out
+        case let array as [Any]:
+            return array.map { jsonSafe($0) }
+        case is String, is NSString, is NSNull:
+            return value
+        case let flag as Bool:
+            return flag
+        case let number as NSNumber:
+            return number
+        case let number as UInt64:
+            return NSNumber(value: number)
+        case let number as Int64:
+            return NSNumber(value: number)
+        case let number as UInt32:
+            return NSNumber(value: number)
+        case let number as Int32:
+            return NSNumber(value: number)
+        case let number as Double:
+            return number.isFinite ? NSNumber(value: number) : NSNull()
+        case let date as Date:
+            return iso(date)
+        case let url as URL:
+            return url.absoluteString
+        default:
+            return String(describing: value)
+        }
+    }
+
     private func write(_ object: [String: Any], to name: String) {
         if let data = try? JSONSerialization.data(withJSONObject: object) {
             try? data.write(to: directory.appendingPathComponent(name), options: .atomic)

package/templates/CraftNativeActions.swift

@@ -70,6 +70,7 @@ enum CraftNativeActions {
         // A heart-rate strap is the app's own service (CraftHeartRate.swift),
         // so it needs no web view.
         if config.enableHeartRate { values.append("heartRate") }
+        if config.enableBluetooth { values.append("bluetooth") }
         // Workouts on the paired Apple Watch (CraftScheduledWorkouts.swift),
         // also the app's own service.
         if config.enableScheduledWorkouts { values.append("scheduledWorkouts") }
@@ -401,6 +402,15 @@ enum CraftNativeActions {
             }
             CraftWebServices.perform(action: action, body: args.first as? [String: Any] ?? [:]) { complete(requestToken, $0, completion) }
             return
+        case ("Bluetooth", _):
+            guard config.enableBluetooth else {
+                complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
+                return
+            }
+            CraftBluetooth.shared.perform(method: method, args: args) { result in
+                complete(requestToken, result.mapError { CraftNativeActionError(code: $0.code, message: $0.message) }, completion)
+            }
+            return
         case ("HeartRate", _):
             // A Bluetooth heart-rate strap, the same service as a page's
             // `craft.heartRate`: one connection and one recording, whichever

package/templates/CraftNativeScreen.swift

@@ -1306,11 +1306,20 @@ private class CraftNativeFlowView: UIStackView {
 
     override func insertArrangedSubview(_ view: UIView, at stackIndex: Int) {
         flowChildren.removeAll { $0 === view }
-        flowChildren.insert(view, at: min(max(0, stackIndex), flowChildren.count))
+        let index = min(max(0, stackIndex), flowChildren.count)
+        flowChildren.insert(view, at: index)
         if view.superview !== self {
             view.removeFromSuperview()
             addSubview(view)
         }
+        // Stacking follows the tree, as on the web: a later sibling draws and
+        // takes touches above an earlier one. Appending a child inserted
+        // before its siblings put it on top of all of them, so a ScrollView
+        // re-created under a floating button (absolute, after it) took the
+        // button's taps for whatever lay beneath while the button still drew.
+        if let next = flowChildren[(index + 1)...].first(where: { $0.superview === self }) {
+            insertSubview(view, belowSubview: next)
+        }
         view.translatesAutoresizingMaskIntoConstraints = true
         invalidateMeasurements()
     }
@@ -3963,6 +3972,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         // it follows light, dark and Increase Contrast by itself.
         let surface = Self.floatingSurface(diameter: 44)
         button.addSubview(surface)
+        // Pinned to the button rather than resized with it: the button starts
+        // at zero size, so a 44-point surface that grew with its superview
+        // came out 88 points, a rounded card twice the button's size that
+        // spilled off the bar's edge and covered its neighbour.
+        NSLayoutConstraint.activate([
+            surface.leadingAnchor.constraint(equalTo: button.leadingAnchor),
+            surface.trailingAnchor.constraint(equalTo: button.trailingAnchor),
+            surface.topAnchor.constraint(equalTo: button.topAnchor),
+            surface.bottomAnchor.constraint(equalTo: button.bottomAnchor),
+        ])
         // Glass lifts itself off the content; the material needs the tab
         // bar's shadow to.
         if surface.effect is UIBlurEffect {
@@ -4043,8 +4062,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         effect = UIBlurEffect(style: .systemUltraThinMaterial)
         #endif
         let surface = UIVisualEffectView(effect: effect)
-        surface.frame = CGRect(x: 0, y: 0, width: diameter, height: diameter)
-        surface.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        // The caller pins it to its button; it is exactly `diameter` across.
+        surface.translatesAutoresizingMaskIntoConstraints = false
         surface.isUserInteractionEnabled = false
         surface.layer.cornerRadius = diameter / 2
         surface.layer.cornerCurve = .circular