craft-native 0.0.176 → 0.0.178

package/dist/android/src/index.d.ts

@@ -25,6 +25,7 @@ export interface CraftAndroidConfig {
     enableSecureStorage?: boolean;
     enableGeolocation?: boolean;
     enableBackgroundLocation?: boolean;
+    enableBluetooth?: boolean;
     enableHealthConnect?: boolean;
     /**
      * The Health Connect data the app reads and writes, by the shared type

package/dist/android/src/index.js

@@ -183,6 +183,7 @@ var DEFAULT_CONFIG = {
   enableSecureStorage: false,
   enableGeolocation: false,
   enableBackgroundLocation: false,
+  enableBluetooth: false,
   enableHealthConnect: false,
   enableKeepAwake: false,
   enableDeepLinks: false,
@@ -371,7 +372,15 @@ function renderAndroidPermissions(config) {
     healthConnectPermissions(config).forEach((permission) => permissions.add(permission));
   if (config.renderer === "native" && config.backgroundRefresh?.enabled)
     permissions.add("android.permission.RECEIVE_BOOT_COMPLETED");
-  return [...permissions].map((permission) => `    <uses-permission android:name="${permission}" />`).join(`
+  const bluetooth = config.enableBluetooth ? [
+    '    <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />',
+    '    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />',
+    '    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation" />',
+    '    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />',
+    ...config.enableGeolocation ? [] : ['    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />']
+  ].join(`
+`) : "";
+  return [bluetooth, ...[...permissions].map((permission) => `    <uses-permission android:name="${permission}" />`)].filter(Boolean).join(`
 `);
 }
 function writeNativeShellSources(output, packagePath, packageName, config) {
@@ -380,6 +389,7 @@ function writeNativeShellSources(output, packagePath, packageName, config) {
     const source = readFileSync(join(TEMPLATES_DIR, template), "utf-8").replace(/\{\{PACKAGE_NAME\}\}/g, packageName);
     writeFileSync(join(javaDir, file), replace(source));
   };
+  write("CraftBluetooth.kt.template", "CraftBluetooth.kt");
   write("CraftNativeShell.kt.template", "CraftNativeShell.kt");
   write("CraftNativeBackground.kt.template", "CraftNativeBackground.kt");
   write(config.enableHealthConnect ? "CraftNativeHealth.kt.template" : "CraftNativeHealthStub.kt.template", "CraftNativeHealth.kt");

package/dist/android/templates/CraftBluetooth.kt.template

@@ -0,0 +1,211 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.app.Activity
+import android.bluetooth.*
+import android.bluetooth.le.*
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelUuid
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+
+/** A selected GATT channel; one request/notification exchange at a time. */
+@Suppress("MissingPermission", "DEPRECATION")
+internal class CraftBluetooth(private val context: Context) {
+    private val handler = Handler(Looper.getMainLooper())
+    private val adapter get() = (context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter
+    private val devices = linkedMapOf<String, BluetoothDevice>()
+    private val rows = linkedMapOf<String, JSONObject>()
+    private var scanDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var permissionScan: JSONObject? = null
+    private var prefix = ""
+    private var gatt: BluetoothGatt? = null
+    private var writer: BluetoothGattCharacteristic? = null
+    private var notifier: BluetoothGattCharacteristic? = null
+    private var serviceId: UUID? = null
+    private var writeId: UUID? = null
+    private var notifyId: UUID? = null
+    private var connected = false
+    private var mtu = 23
+    private var connectDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var exchangeDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var responsePrefix = byteArrayOf()
+    private var scanTimer: Runnable? = null
+    private var connectTimer: Runnable? = null
+    private var exchangeTimer: Runnable? = null
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+    private fun timer(ms: Long, action: () -> Unit) = Runnable(action).also { handler.postDelayed(it, ms) }
+    private fun permitted() = permissions().all { ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED }
+    private fun permissions() = if (Build.VERSION.SDK_INT >= 31) arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT) else arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)
+
+    fun perform(method: String, args: JSONArray, done: (CraftNativeCapabilityResult) -> Unit) {
+        handler.post {
+            val options = args.optJSONObject(0) ?: JSONObject()
+            try {
+                when (method) {
+                    "getState" -> done(CraftNativeCapabilityResult(JSONObject().put("available", adapter != null).put("connected", connected).put("scanning", scanDone != null)))
+                    "scan" -> scan(options, done)
+                    "stopScan" -> { stopScan(failure("CANCELLED", "Bluetooth scan cancelled")); done(CraftNativeCapabilityResult(true)) }
+                    "connect" -> connect(options, done)
+                    "exchange" -> exchange(options, done)
+                    "disconnect" -> { disconnect(); done(CraftNativeCapabilityResult(true)) }
+                    else -> done(failure("UNKNOWN_ACTION", "Unsupported Bluetooth method"))
+                }
+            } catch (_: SecurityException) { disconnect(); done(failure("NOT_AUTHORIZED", "Bluetooth permission is required")) }
+              catch (_: IllegalArgumentException) { done(failure("INVALID_ARGUMENT", "Invalid Bluetooth channel options")) }
+        }
+    }
+
+    private fun scan(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (scanDone != null || connectDone != null || exchangeDone != null) { done(failure("BUSY", "A Bluetooth operation is running")); return }
+        val services = options.optJSONArray("services") ?: throw IllegalArgumentException()
+        require(services.length() in 1..8)
+        (0 until services.length()).forEach { UUID.fromString(services.getString(it)) }
+        scanDone = done
+        if (!permitted()) {
+            val activity = context as? Activity
+            if (activity == null) { stopScan(failure("NEEDS_ACTIVITY", "Bluetooth setup needs a screen")); return }
+            permissionScan = options
+            ActivityCompat.requestPermissions(activity, permissions(), 4317)
+            return
+        }
+        startScan(options)
+    }
+
+    fun onPermissions(requestCode: Int) {
+        if (requestCode != 4317) return
+        val options = permissionScan ?: return
+        permissionScan = null
+        if (!permitted()) stopScan(failure("NOT_AUTHORIZED", "Allow Nearby devices to find your bottle"))
+        else try { startScan(options) } catch (_: Exception) { stopScan(failure("SCAN_FAILED", "Bluetooth scan could not start")) }
+    }
+
+    private fun startScan(options: JSONObject) {
+        val radio = adapter
+        if (radio == null || !radio.isEnabled) { stopScan(failure("BLUETOOTH_OFF", "Turn on Bluetooth")); return }
+        devices.clear(); rows.clear()
+        prefix = options.optString("namePrefix")
+        val services = options.getJSONArray("services")
+        val filters = (0 until services.length()).map { ScanFilter.Builder().setServiceUuid(ParcelUuid(UUID.fromString(services.getString(it)))).build() }
+        radio.bluetoothLeScanner.startScan(filters, ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build(), scanner)
+        scanTimer = timer(options.optLong("timeoutMs", 10000).coerceIn(1000, 20000)) {
+            stopScan(CraftNativeCapabilityResult(JSONArray(rows.values.toList())))
+        }
+    }
+    private val scanner = object : ScanCallback() {
+        override fun onScanResult(callbackType: Int, result: ScanResult) {
+            handler.post {
+                if (scanDone == null || rows.size >= 64) return@post
+                val name = result.scanRecord?.deviceName ?: ""
+                if (!name.startsWith(prefix, ignoreCase = true)) return@post
+                val id = result.device.address
+                devices[id] = result.device
+                rows[id] = JSONObject().put("id", id).put("name", name).put("rssi", result.rssi)
+            }
+        }
+        override fun onScanFailed(errorCode: Int) { handler.post { stopScan(failure("SCAN_FAILED", "Bluetooth scan failed ($errorCode)")) } }
+    }
+    private fun stopScan(result: CraftNativeCapabilityResult) {
+        if (permitted()) runCatching { adapter?.bluetoothLeScanner?.stopScan(scanner) }
+        scanTimer?.let(handler::removeCallbacks); scanTimer = null; permissionScan = null
+        val done = scanDone; scanDone = null; done?.invoke(result)
+    }
+
+    private fun connect(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (scanDone != null || connectDone != null || exchangeDone != null) { done(failure("BUSY", "A Bluetooth operation is running")); return }
+        if (!permitted()) { done(failure("NOT_AUTHORIZED", "Bluetooth permission is required")); return }
+        val device = devices[options.optString("id")] ?: throw IllegalArgumentException()
+        disconnect()
+        serviceId = UUID.fromString(options.getString("service")); writeId = UUID.fromString(options.getString("write")); notifyId = UUID.fromString(options.getString("notify"))
+        connectDone = done
+        gatt = device.connectGatt(context, false, callbacks, BluetoothDevice.TRANSPORT_LE)
+        connectTimer = timer(15000) { failConnection("TIMEOUT", "Device did not connect; wake it and try again") }
+    }
+    private fun finishConnect(result: CraftNativeCapabilityResult) {
+        connectTimer?.let(handler::removeCallbacks); connectTimer = null
+        val done = connectDone; connectDone = null; done?.invoke(result)
+    }
+    private fun failConnection(code: String, message: String) { finishConnect(failure(code, message)); disconnect() }
+    private val callbacks = object : BluetoothGattCallback() {
+        override fun onConnectionStateChange(peer: BluetoothGatt, status: Int, newState: Int) { handler.post {
+            if (peer !== gatt) return@post
+            if (status != BluetoothGatt.GATT_SUCCESS || newState == BluetoothProfile.STATE_DISCONNECTED) { failConnection("DISCONNECTED", "Bluetooth device disconnected"); return@post }
+            if (newState == BluetoothProfile.STATE_CONNECTED && !peer.requestMtu(247)) failConnection("MTU_TOO_SMALL", "Could not negotiate Bluetooth MTU")
+        } }
+        override fun onMtuChanged(peer: BluetoothGatt, value: Int, status: Int) { handler.post {
+            if (peer !== gatt) return@post
+            if (status != BluetoothGatt.GATT_SUCCESS || value < 185) { failConnection("MTU_TOO_SMALL", "Bluetooth MTU is too small for sensor history"); return@post }
+            mtu = value
+            if (!peer.discoverServices()) failConnection("CONNECT_FAILED", "Could not discover Bluetooth services")
+        } }
+        override fun onServicesDiscovered(peer: BluetoothGatt, status: Int) { handler.post {
+            if (peer !== gatt) return@post
+            val service = serviceId?.let(peer::getService)
+            writer = writeId?.let { service?.getCharacteristic(it) }; notifier = notifyId?.let { service?.getCharacteristic(it) }
+            val write = writer; val notify = notifier
+            if (status != BluetoothGatt.GATT_SUCCESS || write == null || notify == null || write.properties and (BluetoothGattCharacteristic.PROPERTY_WRITE or BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) == 0 || notify.properties and BluetoothGattCharacteristic.PROPERTY_NOTIFY == 0) { failConnection("UNSUPPORTED_DEVICE", "The selected GATT channel is missing"); return@post }
+            val descriptor = notify.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"))
+            if (descriptor == null || !peer.setCharacteristicNotification(notify, true)) { failConnection("CONNECT_FAILED", "Could not subscribe to the device"); return@post }
+            descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+            if (!peer.writeDescriptor(descriptor)) failConnection("CONNECT_FAILED", "Could not enable notifications")
+        } }
+        override fun onDescriptorWrite(peer: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) { handler.post {
+            if (peer !== gatt || descriptor.characteristic !== notifier) return@post
+            if (status != BluetoothGatt.GATT_SUCCESS) { failConnection("CONNECT_FAILED", "Could not enable notifications"); return@post }
+            connected = true
+            finishConnect(CraftNativeCapabilityResult(JSONObject().put("id", peer.device.address)))
+        } }
+        override fun onCharacteristicWrite(peer: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) { handler.post {
+            if (peer === gatt && characteristic === writer && status != BluetoothGatt.GATT_SUCCESS) finishExchange(failure("WRITE_FAILED", "Bluetooth write failed"))
+        } }
+        override fun onCharacteristicChanged(peer: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
+            val bytes = characteristic.value?.copyOf() ?: return
+            handler.post {
+                if (peer !== gatt || characteristic !== notifier || exchangeDone == null) return@post
+                if (bytes.size < responsePrefix.size || !bytes.take(responsePrefix.size).toByteArray().contentEquals(responsePrefix)) return@post
+                if (bytes.size > 4096) finishExchange(failure("INVALID_RESPONSE", "Bluetooth response is too large"))
+                else finishExchange(CraftNativeCapabilityResult(JSONArray(bytes.map { it.toInt() and 255 })))
+            }
+        }
+    }
+    private fun byteArray(options: JSONObject, name: String, max: Int): ByteArray {
+        val values = options.getJSONArray(name)
+        require(values.length() in 1..max)
+        return ByteArray(values.length()) { index ->
+            val value = values.get(index)
+            require(value is Number && value.toDouble() == value.toInt().toDouble() && value.toInt() in 0..255)
+            value.toInt().toByte()
+        }
+    }
+    private fun exchange(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (exchangeDone != null) { done(failure("BUSY", "A Bluetooth request is running")); return }
+        val peer = gatt; val write = writer
+        if (!connected || peer == null || write == null) { done(failure("DISCONNECTED", "Bluetooth device is disconnected")); return }
+        val bytes = byteArray(options, "bytes", 182)
+        require(bytes.size <= mtu - 3)
+        responsePrefix = byteArray(options, "responsePrefix", 16)
+        exchangeDone = done
+        exchangeTimer = timer(options.optLong("timeoutMs", 10000).coerceIn(1000, 20000)) { finishExchange(failure("TIMEOUT", "Bluetooth device did not answer")) }
+        write.writeType = if (write.properties and BluetoothGattCharacteristic.PROPERTY_WRITE != 0) BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT else BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+        write.value = bytes
+        if (!peer.writeCharacteristic(write)) finishExchange(failure("WRITE_FAILED", "Bluetooth write queue is busy"))
+    }
+    private fun finishExchange(result: CraftNativeCapabilityResult) {
+        exchangeTimer?.let(handler::removeCallbacks); exchangeTimer = null; responsePrefix = byteArrayOf()
+        val done = exchangeDone; exchangeDone = null; done?.invoke(result)
+    }
+    fun disconnect() {
+        stopScan(failure("CANCELLED", "Bluetooth scan cancelled"))
+        finishConnect(failure("CANCELLED", "Bluetooth connection cancelled"))
+        finishExchange(failure("DISCONNECTED", "Bluetooth device disconnected"))
+        val old = gatt; gatt = null; connected = false; writer = null; notifier = null; mtu = 23
+        runCatching { old?.disconnect(); old?.close() }
+    }
+}

package/dist/android/templates/CraftNativeCapabilities.kt.template

@@ -63,6 +63,8 @@ internal class CraftNativeCapabilities(
 ) {
     /** The screen's activity; null in a background refresh, where nothing can be shown. */
     private val activity: MainActivity? get() = context as? MainActivity
+    private val bluetooth by lazy { CraftBluetooth(context) }
+    fun onBluetoothPermissions(requestCode: Int) { if (config.optBoolean("enableBluetooth")) bluetooth.onPermissions(requestCode) }
     private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
     private val storage = context.getSharedPreferences("craft-native-storage", Context.MODE_PRIVATE)
     // The typed native renderer has no CraftNative Zig holder. Keep its
@@ -111,6 +113,7 @@ internal class CraftNativeCapabilities(
 
     fun names(): JSONArray = JSONArray().apply {
         listOf("device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "files").forEach(::put)
+        if (config.optBoolean("enableBluetooth")) put("bluetooth")
         if (config.optBoolean("enableBiometric")) put("biometric")
         if (config.optBoolean("enableSecureStorage")) put("secureStorage")
         if (config.optBoolean("enableLocalDatabase")) put("database")
@@ -132,6 +135,10 @@ internal class CraftNativeCapabilities(
             return
         }
         when (module) {
+            "Bluetooth" -> {
+                if (!config.optBoolean("enableBluetooth")) complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
+                else bluetooth.perform(method, args) { complete(requestToken, it, completion) }
+            }
             "Storage" -> complete(requestToken, storage(method, args), completion)
             "SecureStorage" -> {
                 if (!config.optBoolean("enableSecureStorage")) complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
@@ -177,6 +184,7 @@ internal class CraftNativeCapabilities(
     }
 
     fun close() {
+        if (config.optBoolean("enableBluetooth")) bluetooth.disconnect()
         databaseExecutor.shutdownNow()
         networkExecutor.shutdownNow()
         fetchConnections.values.forEach(HttpURLConnection::disconnect)

package/dist/android/templates/MainActivityNative.kt.template

@@ -856,15 +856,18 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         requestLayout()
     }
 
-    private fun invalidateMeasurementAncestors(start: ViewParent?) {
-        var ancestor = start
-        while (ancestor != null) {
-            when (ancestor) {
-                is CraftNativeFlexLayout -> ancestor.invalidateMeasurements()
-                is CraftNativeKeyboardAvoidingView -> ancestor.content.invalidateMeasurements()
-                is CraftNativeScrollView -> ancestor.invalidateContentLayout()
+    companion object {
+        /** Clears the memoized measurements of every flex host above `start`. The activity calls it too (an image whose source changed). */
+        fun invalidateMeasurementAncestors(start: ViewParent?) {
+            var ancestor = start
+            while (ancestor != null) {
+                when (ancestor) {
+                    is CraftNativeFlexLayout -> ancestor.invalidateMeasurements()
+                    is CraftNativeKeyboardAvoidingView -> ancestor.content.invalidateMeasurements()
+                    is CraftNativeScrollView -> ancestor.invalidateContentLayout()
+                }
+                ancestor = (ancestor as? View)?.parent
             }
-            ancestor = (ancestor as? View)?.parent
         }
     }
 
@@ -4086,7 +4089,7 @@ class MainActivity : AppCompatActivity() {
                 includeFontPadding = false
                 configureText(this, craftNativeOptionalString(props.opt("title")) ?: childText(children), style)
                 val linkColor = craftNativeOptionalString(props.opt("color")) ?: craftNativeOptionalString(style.opt("color"))
-                setTextColor(color(linkColor, Color.rgb(33, 150, 243)))
+                setTextColor(color(linkColor.orEmpty(), Color.rgb(33, 150, 243)))
                 paintFlags = paintFlags or Paint.UNDERLINE_TEXT_FLAG
                 isEnabled = !props.optBoolean("disabled", false)
                 isClickable = true
@@ -4369,7 +4372,7 @@ class MainActivity : AppCompatActivity() {
                     } else {
                         craftNativeOptionalString(events.opt("onDismiss"))
                     }
-                    if (lifecycleHandler.isNotBlank() && !suppressDismiss) {
+                    if (!lifecycleHandler.isNullOrBlank() && !suppressDismiss) {
                         // Deliver lifecycle callbacks after reconciliation returns to
                         // the queue; the handler may immediately schedule another
                         // render against this native view.
@@ -5452,7 +5455,7 @@ class MainActivity : AppCompatActivity() {
     private fun imageDidChange(view: ImageView) {
         view.invalidate()
         view.requestLayout()
-        invalidateMeasurementAncestors(view.parent)
+        CraftNativeFlexLayout.invalidateMeasurementAncestors(view.parent)
     }
 
     private fun emitImageEvent(screen: Screen, view: ImageView, handler: String?, nativeEvent: JSONObject = JSONObject()) {
@@ -5774,6 +5777,7 @@ class MainActivity : AppCompatActivity() {
 
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        if (::capabilities.isInitialized) capabilities.onBluetoothPermissions(requestCode)
         if (::services.isInitialized) services.onRequestPermissionsResult(requestCode)
     }
 

package/dist/cli.js

@@ -3303,7 +3303,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.176";
+var version = "0.0.178";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -310,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.176";
+var version = "0.0.178";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -58,7 +58,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.176";
+var version = "0.0.178";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/src/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/dist/ios/src/testing.d.ts

@@ -24,6 +24,11 @@ export type SimulatorStep = {
 } | {
     command: 'swipe';
     direction: 'up' | 'down' | 'left' | 'right';
+}
+/** The system back-swipe: a drag in from the left edge (or the right). */
+ | {
+    command: 'edge';
+    direction: 'left' | 'right';
 } | {
     command: 'tabbar';
     state: 'shown' | 'hidden';

package/dist/ios/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/dist/ios/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/dist/ios/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/dist/ios/templates/CraftNativeFlatList.swift

@@ -270,14 +270,24 @@ final class CraftNativeFlatList: UICollectionView, UICollectionViewDelegateFlowL
 
     @objc private func keyboardTap() {
         guard keyboardShouldPersistTaps != "always" else { return }
-        if keyboardShouldPersistTaps == "handled" {
-            let point = keyboardTapGesture.location(in: self)
-            var hit = hitTest(point, with: nil)
-            while let view = hit, view !== self {
-                if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { return }
-                hit = view.superview
-            }
+        let point = keyboardTapGesture.location(in: self)
+        var hit = hitTest(point, with: nil)
+        var onControl = false
+        var onButton = false
+        while let view = hit, view !== self {
+            if view is UIButton { onButton = true }
+            if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { onControl = true; break }
+            hit = view.superview
         }
+        if keyboardShouldPersistTaps == "handled", onControl { return }
+        // A button keeps the keyboard: its press gives the focus straight
+        // back. Ending editing first only let the keyboard's inset go while
+        // the finger was down, the button moved out from under it, and the
+        // press was lost.
+        if onButton { return }
+        // Otherwise the keyboard goes; after a tap on nothing, for good (the
+        // next render must not bring the last input back).
+        if !onControl { craftScreenController?.forgetFocusedInput() }
         window?.endEditing(true)
     }
 

package/dist/ios/templates/CraftNativeScreen.swift

@@ -1166,6 +1166,18 @@ enum CraftNativeFlexLayout {
 /// grid. It is a UIStackView in name only, so existing callers and tests keep
 /// `axis`, `alignment` and `arrangedSubviews`; the stack view's own
 /// constraints are never created, and every frame comes from `layout`.
+extension UIView {
+    /// The native screen this view is drawn on, through the responder chain.
+    var craftScreenController: CraftNativeScreenController? {
+        var responder: UIResponder? = next
+        while let current = responder {
+            if let screen = current as? CraftNativeScreenController { return screen }
+            responder = current.next
+        }
+        return nil
+    }
+}
+
 private class CraftNativeFlowView: UIStackView {
     var pressActiveOpacity: CGFloat?
     var pressBaseOpacity: CGFloat = 1
@@ -1358,6 +1370,13 @@ private class CraftNativeFlowView: UIStackView {
         craftApplyCornerRadius()
         let scale = window?.screen.scale ?? traitCollection.displayScale
         let result = layout(width: bounds.width, height: bounds.height, maxWidth: bounds.width, maxHeight: bounds.height, place: true)
+        var moved = false
+        defer {
+            // The screen reports onLayout from its own layout pass, which a
+            // change deep in a scroll view's content never runs: a view that
+            // went from 240 to 180 wide kept saying 240.
+            if moved { craftScreenController?.scheduleLayoutEvents() }
+        }
         for (child, frame) in result.frames {
             var viewportFrame = frame
             if child === viewportChild, viewportChildFillsHeight {
@@ -1372,14 +1391,14 @@ private class CraftNativeFlowView: UIStackView {
                 snapped.size = CraftNativeFlexLayout.ceiled(frame.size, scale: scale, atLeast: snapped.size)
             }
             if child.transform.isIdentity {
-                if child.frame != snapped { child.frame = snapped }
+                if child.frame != snapped { child.frame = snapped; moved = true }
             } else {
                 // A transformed child (a sticky header, a scaled spinner) is
                 // placed by bounds and center: its frame is undefined then.
                 let size = CGRect(origin: child.bounds.origin, size: snapped.size)
                 let center = CGPoint(x: snapped.midX, y: snapped.midY)
-                if child.bounds != size { child.bounds = size }
-                if child.center != center { child.center = center }
+                if child.bounds != size { child.bounds = size; moved = true }
+                if child.center != center { child.center = center; moved = true }
             }
             child.craftApplyCornerRadius()
         }
@@ -2192,6 +2211,10 @@ private final class CraftNativeModalView: UIView {
 
     required init?(coder: NSCoder) { nil }
 
+    /// Whether the modal takes touches is its own to say: shown, it takes
+    /// every one (the scrim and its controls); the screen's press and long
+    /// press bookkeeping once turned that off for a view with no handler of
+    /// its own, and a shown modal let every tap through to the screen behind.
     func setVisible(_ visible: Bool, opacity: CGFloat, animationType: String?) {
         if visible { isUserInteractionEnabled = true }
         if renderedVisible == visible && isHidden == !visible {
@@ -2273,7 +2296,27 @@ private final class CraftNativeModalView: UIView {
     override func layoutSubviews() {
         super.layoutSubviews()
         blocker.frame = bounds
-        contentStack.frame = bounds
+        // The scrim covers the whole screen; what the modal holds stays
+        // clear of the bars and the home indicator it is drawn over.
+        contentStack.frame = bounds.inset(by: UIEdgeInsets(top: contentInsets.top, left: 0, bottom: contentInsets.bottom, right: 0))
+    }
+
+    /// Where the screen's own content starts and ends: the scrim covers the
+    /// whole screen, what the modal holds stays clear of the bars.
+    var contentInsets: UIEdgeInsets = .zero {
+        didSet { if contentInsets != oldValue { setNeedsLayout() } }
+    }
+}
+
+/// 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
+/// failed whenever onPressIn or onPressOut were set too. It only watches.
+final class CraftPressFeedbackDelegate: NSObject, UIGestureRecognizerDelegate {
+    static let shared = CraftPressFeedbackDelegate()
+
+    func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        true
     }
 }
 
@@ -2545,14 +2588,24 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
 
     @objc private func keyboardTap() {
         guard keyboardShouldPersistTaps != "always" else { return }
-        if keyboardShouldPersistTaps == "handled" {
-            let point = keyboardTapGesture.location(in: self)
-            var hit = hitTest(point, with: nil)
-            while let view = hit, view !== self {
-                if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { return }
-                hit = view.superview
-            }
-        }
+        let point = keyboardTapGesture.location(in: self)
+        var hit = hitTest(point, with: nil)
+        var onControl = false
+        var onButton = false
+        while let view = hit, view !== self {
+            if view is UIButton { onButton = true }
+            if view is UIControl || !(view.gestureRecognizers ?? []).isEmpty { onControl = true; break }
+            hit = view.superview
+        }
+        if keyboardShouldPersistTaps == "handled", onControl { return }
+        // A button keeps the keyboard: its press gives the focus straight
+        // back. Ending editing first only let the keyboard's inset go while
+        // the finger was down, the button moved out from under it, and the
+        // press was lost.
+        if onButton { return }
+        // Otherwise the keyboard goes; after a tap on nothing, for good (the
+        // next render must not bring the last input back).
+        if !onControl { craftScreenController?.forgetFocusedInput() }
         window?.endEditing(true)
     }
 
@@ -3056,6 +3109,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var linkTargets: [ObjectIdentifier: String] = [:]
     private var renderedRoot: RenderedNode?
     private weak var lastFocusedInput: UIView?
+
+    /// The person put the keyboard away (Return, or a tap on nothing in a
+    /// scroll view): the last input is let go. Kept, the next render or
+    /// button press focused it again and the keyboard came straight back.
+    func forgetFocusedInput(_ input: UIView? = nil) {
+        if input == nil || lastFocusedInput === input { lastFocusedInput = nil }
+    }
     private var flatListRows: [ObjectIdentifier: [String: RenderedNode]] = [:]
     private var flatListOwners: [String: String] = [:]
     /// A drawing's shapes are not views: a change to one redraws its `Svg`.
@@ -3192,6 +3252,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         if !isAppScript, let routeName, !routeName.isEmpty {
             CraftCrashReporter.shared.screenAppeared(routeName)
         }
+        // onLayout reports views that are on screen: a pushed screen lays
+        // out before it has a window, and nothing moved again once it had
+        // one, so its rows never reported.
+        emitLayoutEvents()
     }
 
     override func viewDidDisappear(_ animated: Bool) {
@@ -3266,9 +3330,29 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     override func viewDidLayoutSubviews() {
         super.viewDidLayoutSubviews()
+        positionModals()
         emitLayoutEvents()
     }
 
+    /// Modals cover the screen; their content starts below its bars (the
+    /// status bar is all the safe area counts on a native screen, and a
+    /// modal's first control sat under the navigation bar).
+    private func positionModals() {
+        let modals = view.subviews.compactMap { $0 as? CraftNativeModalView }
+        guard !modals.isEmpty else { return }
+        var insets = view.safeAreaInsets
+        // The navigation bar floats over the screen without counting in its
+        // safe area, and it is drawn above anything the screen adds.
+        if let nav = navigationController, !nav.isNavigationBarHidden, nav.navigationBar.window != nil {
+            let bar = nav.navigationBar.convert(nav.navigationBar.bounds, to: view)
+            if bar.intersects(view.bounds) { insets.top = max(insets.top, bar.maxY) }
+        }
+        for modal in modals {
+            if modal.frame != view.bounds { modal.frame = view.bounds }
+            modal.contentInsets = insets
+        }
+    }
+
     private static func safeJavaScriptString(_ value: JSValue?) -> String? {
         guard let value, !value.isUndefined, !value.isNull, value.isString else { return nil }
         return value.toString()
@@ -4469,6 +4553,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             guard let target = drawnTarget(id) else { return false }
             guard applied.insert(target).inserted else { continue }
             guard let document = mutationDocument.node(target), let previous = renderedNode(target) else { return false }
+            // A node that needs a new view (a TextInput turned multiline) is
+            // its parent's to swap in: a targeted update only redraws in
+            // place, and the new view was made and never attached.
+            guard canReuseView(document, previous: previous) else { return false }
             let next = reconcile(document, identity: previous.identity, path: target, previous: previous)
             // A style patch is applied in place, layout included: the parent
             // reads the node's new layout style on its next pass.
@@ -4564,6 +4652,16 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         return nil
     }
 
+    /// Whether `previous`'s view can draw `node`: the same type, and for a
+    /// TextInput the same kind of field (multiline is a UITextView).
+    private func canReuseView(_ node: [String: Any], previous: RenderedNode) -> Bool {
+        let type = canonicalType(node["type"] as? String ?? "View")
+        guard previous.type == type else { return false }
+        guard type == "TextInput" else { return true }
+        let props = node["props"] as? [String: Any] ?? [:]
+        return (previous.view is UITextView) == (props["multiline"] as? Bool == true)
+    }
+
     private func restoreFocus(_ focused: UIView?) {
         guard let focused, focused.window != nil, !focused.isFirstResponder else { return }
         _ = focused.becomeFirstResponder()
@@ -4576,9 +4674,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let events = node["events"] as? [String: String] ?? [:]
         let children = node["children"] as? [Any] ?? []
         let current: RenderedNode
-        let wantsMultilineTextView = type == "TextInput" && props["multiline"] as? Bool == true
-        let canReuseInput = type != "TextInput" || ((previous?.view is UITextView) == wantsMultilineTextView)
-        if let previous = previous, previous.identity == identity, previous.type == type, canReuseInput {
+        if let previous = previous, previous.identity == identity, canReuseView(node, previous: previous) {
             current = previous
         } else {
             current = RenderedNode(identity: identity, type: type, view: makeView(type, props: props))
@@ -4796,6 +4892,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             let modalID = ObjectIdentifier(modal)
             let wasVisible = modalVisibility[modalID]
             modalVisibility[modalID] = visible
+            if visible, wasVisible != true { positionModals() }
             modal.setVisible(visible, opacity: number(style["opacity"]) ?? 1, animationType: props["animationType"] as? String)
             modal.onRequestClose = nonEmptyHandler(events["onRequestClose"]).map { handler in
                 { [weak self] in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": [:]]) }
@@ -5199,14 +5296,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         for child in next where child.type == "Modal" {
             guard let modal = child.view as? CraftNativeModalView else { continue }
-            if modal.superview !== stack {
+            // A modal covers the screen, wherever it is declared. Laid over
+            // its parent instead, one declared in a scroll view covered the
+            // whole content: its controls sat wherever the content had
+            // scrolled to, under the bar or off screen, out of reach.
+            if modal.superview !== view {
                 modal.removeFromSuperview()
-                stack.addSubview(modal)
+                view.addSubview(modal)
             }
-            modal.frame = stack.bounds
             modal.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-            stack.bringSubviewToFront(modal)
+            view.bringSubviewToFront(modal)
         }
+        positionModals()
         parent.children = next
         addJustificationSpacers(to: stack, value: style["justifyContent"] as? String)
     }
@@ -5326,7 +5427,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         if node.view is CraftNativeSvgView, let owner = node.protocolId { svgOwners = svgOwners.filter { $0.value != owner } }
         let id = ObjectIdentifier(node.view)
-        if let modal = node.view as? CraftNativeModalView { modal.resetForTeardown() }
+        if let modal = node.view as? CraftNativeModalView {
+            modal.resetForTeardown()
+            // It sits on the screen, not in its parent: leaving with the
+            // parent's subtree does not take it away.
+            modal.removeFromSuperview()
+        }
         handlers.removeValue(forKey: id)
         linkTargets.removeValue(forKey: id)
         pressInHandlers.removeValue(forKey: id)
@@ -5401,6 +5507,20 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         emitLayoutEvents(for: renderedRoot)
     }
 
+    private var layoutEventsScheduled = false
+
+    /// A view inside the screen moved: report onLayout once the pass that
+    /// moved it is over, however deep it was.
+    fileprivate func scheduleLayoutEvents() {
+        guard !layoutEventsScheduled, !layoutHandlers.isEmpty else { return }
+        layoutEventsScheduled = true
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.layoutEventsScheduled = false
+            self.emitLayoutEvents()
+        }
+    }
+
     private func emitLayoutEvents(for node: RenderedNode) {
         let id = ObjectIdentifier(node.view)
         if let handler = layoutHandlers[id], isEffectivelyVisible(node.view) {
@@ -5463,7 +5583,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         }
         // A container keeps receiving touches without a handler of its own,
         // or every control inside it (and the screen root) would be dead.
-        if !(view is UIScrollView) { view.isUserInteractionEnabled = actionable || longPressHandlers[id] != nil || view is CraftNativeFlowView }
+        if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = actionable || longPressHandlers[id] != nil || view is CraftNativeFlowView }
     }
 
     private func updatePressFeedback(_ pressIn: String?, _ pressOut: String?, for view: UIView) {
@@ -5472,7 +5592,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         if let pressOut, !pressOut.isEmpty { pressOutHandlers[id] = pressOut } else { pressOutHandlers.removeValue(forKey: id) }
         guard pressInHandlers[id] != nil || pressOutHandlers[id] != nil else {
             if let recognizer = pressFeedbackRecognizers.removeValue(forKey: id) { view.removeGestureRecognizer(recognizer) }
-            if !(view is UIScrollView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || longPressHandlers[id] != nil || view is CraftNativeFlowView }
+            if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || longPressHandlers[id] != nil || view is CraftNativeFlowView }
             return
         }
         if pressFeedbackRecognizers[id] == nil {
@@ -5480,17 +5600,18 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             recognizer.minimumPressDuration = 0
             recognizer.allowableMovement = 10
             recognizer.cancelsTouchesInView = false
+            recognizer.delegate = CraftPressFeedbackDelegate.shared
             pressFeedbackRecognizers[id] = recognizer
             view.addGestureRecognizer(recognizer)
         }
-        if !(view is UIScrollView) { view.isUserInteractionEnabled = true }
+        if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = true }
     }
 
     private func updateLongPressHandler(_ handler: String?, for view: UIView) {
         let id = ObjectIdentifier(view)
         if let handler, !handler.isEmpty {
             longPressHandlers[id] = handler
-            if !(view is UIScrollView) { view.isUserInteractionEnabled = true }
+            if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = true }
             if longPressRecognizers[id] == nil {
                 let recognizer = UILongPressGestureRecognizer(target: self, action: #selector(viewLongPressed(_:)))
                 longPressRecognizers[id] = recognizer
@@ -5501,7 +5622,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if let recognizer = longPressRecognizers.removeValue(forKey: id) {
                 view.removeGestureRecognizer(recognizer)
             }
-            if !(view is UIScrollView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || view is CraftNativeFlowView }
+            if !(view is UIScrollView || view is CraftNativeModalView) { view.isUserInteractionEnabled = handlers[id] != nil || linkTargets[id] != nil || view is CraftNativeFlowView }
         }
     }
 
@@ -6116,6 +6237,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if state["checked"] as? Bool == true { traits.insert(.selected) }
         }
         if let control = view as? UIControl, !control.isEnabled { traits.insert(.notEnabled) }
+        // A disabled Pressable or touchable takes no touches; it says so too.
+        if props["disabled"] as? Bool == true { traits.insert(.notEnabled) }
         if type == "Checkbox", let checkbox = view as? CraftNativeCheckboxButton {
             if checkbox.isSelected { traits.insert(.selected) }
             view.accessibilityValue = checkbox.indeterminate ? "mixed" : checkbox.isSelected ? "checked" : "unchecked"
@@ -6266,13 +6389,23 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         let value = snappedSliderValue(sender.value, for: sender)
         if sender.value != value { sender.value = value }
         guard let handler = handlers[ObjectIdentifier(sender)] else { return }
-        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(value)]])
+        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(value, step: sliderSteps[ObjectIdentifier(sender)])]])
     }
 
-    /// A slider's value as the script reads it: the shortest decimal that is
-    /// the same Float, so a step of 0.1 gives 0.8 and not 0.800000011920929.
-    static func sliderEventValue(_ value: Float) -> Double {
-        Double(value.description) ?? Double(value)
+    /// A slider's value as the script reads it. UISlider keeps a Float, and a
+    /// step of 0.1 counted up in Floats lands beside the decimal (0.8 read as
+    /// 0.800000011920929, nine steps as 0.90000004), so the value is the
+    /// shortest decimal for that Float, rounded to as many places as the step
+    /// has.
+    static func sliderEventValue(_ value: Float, step: Float? = nil) -> Double {
+        let decimal = Double(value.description) ?? Double(value)
+        guard let step, step > 0, step.isFinite else { return decimal }
+        // "0.1" is one place, "0.25" two, "1.0" none; a step as small as
+        // "1e-07" is held to six.
+        let fraction = step.description.split(separator: ".").dropFirst().first
+        let places = step.description.contains("e") ? 6 : min(6, fraction.map { $0 == "0" ? 0 : $0.count } ?? 0)
+        let scale = pow(10, Double(places))
+        return (decimal * scale).rounded() / scale
     }
 
     /// `@change` on a DatePicker: the value as `<input type="date|time|
@@ -6378,7 +6511,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
 
     @objc private func sliderFinished(_ sender: UISlider) {
         guard let handler = sliderCompleteHandlers[ObjectIdentifier(sender)] else { return }
-        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(snappedSliderValue(sender.value, for: sender))]])
+        send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["value": Self.sliderEventValue(snappedSliderValue(sender.value, for: sender), step: sliderSteps[ObjectIdentifier(sender)])]])
     }
 
     func numberOfComponents(in pickerView: UIPickerView) -> Int { 1 }
@@ -6423,6 +6556,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     }
 
     @objc private func textSubmitted(_ sender: UITextField) {
+        // Return put the keyboard away.
+        forgetFocusedInput(sender)
         guard let handler = submitHandlers[ObjectIdentifier(sender)] else { return }
         send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["text": sender.text ?? ""]])
     }

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -286,6 +286,14 @@ final class DriverTests: XCTestCase {
             case "left": app.swipeLeft()
             default: app.swipeRight()
             }
+        case "edge":
+            // The system back-swipe: a drag in from the left edge (or the
+            // right one with `edge right`), which a centred swipe never is.
+            let fromRight = arg == "right"
+            let start = app.coordinate(withNormalizedOffset: CGVector(dx: fromRight ? 0.995 : 0.005, dy: 0.5))
+            let end = app.coordinate(withNormalizedOffset: CGVector(dx: fromRight ? 0.15 : 0.85, dy: 0.5))
+            start.press(forDuration: 0.05, thenDragTo: end)
+            note("edge \(fromRight ? "right" : "left"): ok")
         case "audit":
             var issues: [String] = []
             do {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.176",
+  "version": "0.0.178",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",