craft-native 0.0.237 → 0.0.241

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

@@ -110,17 +110,7 @@ import androidx.javascriptengine.Message
 import androidx.javascriptengine.MessagePort
 import androidx.javascriptengine.MessagePortClient
 import com.craft.runtime.CraftNative
-import com.google.android.gms.maps.CameraUpdateFactory
-import com.google.android.gms.maps.GoogleMap
-import com.google.android.gms.maps.MapView
-import com.google.android.gms.maps.OnMapReadyCallback
-import com.google.android.gms.maps.model.BitmapDescriptorFactory
-import com.google.android.gms.maps.model.LatLng
-import com.google.android.gms.maps.model.LatLngBounds
-import com.google.android.gms.maps.model.Marker
-import com.google.android.gms.maps.model.MarkerOptions
-import com.google.android.gms.maps.model.Polyline
-import com.google.android.gms.maps.model.PolylineOptions
+{{NATIVE_MAP_IMPORTS}}
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
@@ -597,422 +587,7 @@ private class CraftNativeSvgView(context: Context) : View(context) {
     private data class Quadruple<T1, T2, T3, T4>(val first: T1, val second: T2, val third: T3, val fourth: T4)
 }
 
-/** The Android host for the small, host-neutral native trail map contract. */
-private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMapReadyCallback {
-    private val mapView = MapView(context)
-    private val scaleView = LinearLayout(context).apply {
-        orientation = LinearLayout.VERTICAL
-        setPadding(4, 2, 4, 2)
-        background = GradientDrawable().apply { setColor(Color.argb(230, 255, 255, 255)); cornerRadius = 4f }
-        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
-    }
-    private val scaleLabel = TextView(context).apply { textSize = 11f; setTextColor(Color.rgb(37, 51, 33)) }
-    private val scaleLine = View(context).apply { setBackgroundColor(Color.rgb(37, 51, 33)) }
-    private var googleMap: GoogleMap? = null
-    private var tileOverlay: com.google.android.gms.maps.model.TileOverlay? = null
-    private var tileTemplate: String? = null
-    private val tileAttribution = TextView(context).apply { textSize = 9f; setTextColor(Color.DKGRAY); setBackgroundColor(Color.argb(220, 255, 255, 255)); maxLines = 2; visibility = View.GONE }
-    private var pendingProps = JSONObject()
-    private var pendingChildren = JSONArray()
-    private val markers = mutableMapOf<String, Marker>()
-    private val polylines = mutableMapOf<String, Polyline>()
-    private val markerHandlers = mutableMapOf<String, String>()
-    private var onMarkerTap: ((String) -> Unit)? = null
-    var onMapPress: ((LatLng) -> Unit)? = null
-    var onRegionChangeComplete: ((JSONObject) -> Unit)? = null
-    private var userChangingCamera = false
-    private var markerBearings = mutableMapOf<String, Float>()
-    private var directionIcon: com.google.android.gms.maps.model.BitmapDescriptor? = null
-    private var lifecycleStarted = false
-    private var destroyed = false
-    private var initialCameraKey: String? = null
-
-    init {
-        addView(mapView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
-        scaleView.addView(scaleLabel)
-        scaleView.addView(scaleLine, LinearLayout.LayoutParams(1, 2))
-        addView(scaleView, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.START).apply {
-            leftMargin = (8 * resources.displayMetrics.density).roundToInt()
-            bottomMargin = (24 * resources.displayMetrics.density).roundToInt()
-        })
-        scaleView.visibility = View.GONE
-        addView(tileAttribution, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.END).apply { rightMargin = (8 * resources.displayMetrics.density).roundToInt(); bottomMargin = (8 * resources.displayMetrics.density).roundToInt() })
-        mapView.onCreate(null)
-        mapView.getMapAsync(this)
-    }
-
-    override fun onMapReady(map: GoogleMap) {
-        if (destroyed) return
-        googleMap = map
-        map.setOnMapClickListener { point -> onMapPress?.invoke(point) }
-        map.setOnCameraMoveStartedListener { reason ->
-            if (reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE) userChangingCamera = true
-        }
-        map.setOnCameraMoveListener { updateScale() }
-        map.setOnCameraIdleListener {
-            updateScale()
-            if (userChangingCamera) {
-                userChangingCamera = false
-                val bounds = map.projection.visibleRegion.latLngBounds
-                val position = map.cameraPosition
-                val longitudeDelta = (bounds.northeast.longitude - bounds.southwest.longitude + 360) % 360
-                onRegionChangeComplete?.invoke(JSONObject()
-                    .put("center", JSONObject().put("latitude", position.target.latitude).put("longitude", position.target.longitude))
-                    .put("span", JSONObject().put("latitudeDelta", bounds.northeast.latitude - bounds.southwest.latitude).put("longitudeDelta", longitudeDelta))
-                    .put("heading", position.bearing).put("pitch", position.tilt))
-            }
-        }
-        map.setOnMarkerClickListener { marker ->
-            val id = markers.entries.firstOrNull { it.value == marker }?.key ?: return@setOnMarkerClickListener false
-            onMarkerTap?.invoke(id)
-            // The native contract dispatches the marker event itself. Consume
-            // the click so Google Maps does not also show an unsolicited info
-            // window for the marker title.
-            true
-        }
-        applyPending()
-    }
-
-    fun configure(props: JSONObject, children: JSONArray, markerHandler: (String) -> Unit) {
-        pendingProps = props
-        pendingChildren = children
-        onMarkerTap = markerHandler
-        applyPending()
-    }
-
-    fun markerHandler(id: String): String? = markerHandlers[id]
-
-    private fun applyPending() {
-        val map = googleMap ?: return
-        applyMapPadding()
-        map.uiSettings.isCompassEnabled = craftNativeBoolean(pendingProps.opt("showsCompass"))
-        // The toolbar is replaced by authored actions; the scale uses the native projection.
-        map.uiSettings.isMapToolbarEnabled = false
-        map.uiSettings.isScrollGesturesEnabled = craftNativeBoolean(pendingProps.opt("scrollEnabled"), true)
-        map.uiSettings.isZoomGesturesEnabled = craftNativeBoolean(pendingProps.opt("zoomEnabled"), true)
-        map.uiSettings.isRotateGesturesEnabled = craftNativeBoolean(pendingProps.opt("rotateEnabled"))
-        map.mapType = when (craftNativeOptionalString(pendingProps.opt("mapType")).orEmpty().lowercase()) {
-            "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
-            "hybrid" -> GoogleMap.MAP_TYPE_HYBRID
-            "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
-            else -> GoogleMap.MAP_TYPE_NORMAL
-        }
-        applyTileOverlay()
-        val showUserLocation = craftNativeBoolean(pendingProps.opt("showsUserLocation")) && hasLocationPermission()
-        runCatching { map.isMyLocationEnabled = showUserLocation }
-        val nextMarkers = mutableMapOf<String, Pair<LatLng, String?>>()
-        val nextBearings = mutableMapOf<String, Float>()
-        val nextHandlers = mutableMapOf<String, String>()
-        val nextPolylines = mutableMapOf<String, Triple<List<LatLng>, Int, Float>>()
-        for (index in 0 until pendingChildren.length()) {
-            val child = pendingChildren.optJSONObject(index) ?: continue
-            val type = child.optString("type").lowercase()
-            val props = child.optJSONObject("props") ?: JSONObject()
-            val events = child.optJSONObject("events") ?: JSONObject()
-            val id = craftNativeOptionalString(props.opt("id"))
-                ?: craftNativeOptionalString(child.opt("id"))
-                ?: "overlay-$index"
-            val points = coordinates(props.optJSONArray("geometry"))
-            if (type == "mapmarker" || type == "marker") {
-                points.firstOrNull()?.let { point ->
-                    nextMarkers[id] = point to (props.opt("title") as? String)
-                    (props.opt("bearing") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.let { nextBearings[id] = (it % 360).toFloat() }
-                    listOf(events.opt("onPress"), events.opt("onMarkerPress"))
-                        .firstNotNullOfOrNull(::craftNativeOptionalString)
-                        ?.let { nextHandlers[id] = it }
-                }
-            } else if (type == "mappolyline" || type == "polyline") {
-                if (points.size > 1) {
-                    // Keep malformed authored widths inert, matching the iOS
-                    // host. An omitted or null width still gets the shared
-                    // default; an attacker-controlled NaN, infinity, zero,
-                    // or negative value must not become a valid overlay.
-                    val rawWidth = props.opt("strokeWidth")
-                    val authoredWidth = when (rawWidth) {
-                        null, JSONObject.NULL -> 3.0
-                        is Number -> rawWidth.toDouble()
-                        else -> 3.0
-                    }
-                    // MapKit's lineWidth is expressed in points, while the
-                    // Google Maps SDK consumes screen pixels. Keep the
-                    // protocol in logical points and convert only at this
-                    // Android host boundary so dense displays stay in parity.
-                    val width = (authoredWidth * resources.displayMetrics.density).toFloat()
-                    if (!authoredWidth.isFinite() || !width.isFinite() || width <= 0f) continue
-                    nextPolylines[id] = Triple(points, color(craftNativeOptionalString(props.opt("strokeColor")).orEmpty()), width)
-                }
-            }
-        }
-        markerBearings = nextBearings
-        markers.keys.filter { nextMarkers[it] == null }.forEach { markers.remove(it)?.remove() }
-        for ((id, value) in nextMarkers) {
-            val marker = markers[id]
-            if (marker != null) {
-                marker.position = value.first
-                marker.title = value.second
-                marker.setIcon(if (markerBearings.containsKey(id)) directionMarkerIcon() else BitmapDescriptorFactory.defaultMarker())
-                marker.isFlat = markerBearings.containsKey(id)
-                marker.rotation = markerBearings[id] ?: 0f
-                marker.setAnchor(0.5f, if (markerBearings.containsKey(id)) 0.5f else 1f)
-            } else {
-                map.addMarker(MarkerOptions().position(value.first).title(value.second).icon(if (markerBearings.containsKey(id)) directionMarkerIcon() else BitmapDescriptorFactory.defaultMarker()).flat(markerBearings.containsKey(id)).rotation(markerBearings[id] ?: 0f).anchor(0.5f, if (markerBearings.containsKey(id)) 0.5f else 1f))?.let { markers[id] = it }
-            }
-        }
-        markerHandlers.clear()
-        markerHandlers.putAll(nextHandlers)
-        polylines.keys.filter { nextPolylines[it] == null }.forEach { id ->
-            polylines.remove(id)?.remove()
-        }
-        for ((id, value) in nextPolylines) {
-            val polyline = polylines[id]
-            if (polyline != null) {
-                polyline.points = value.first
-                polyline.color = value.second
-                polyline.width = value.third
-            } else {
-                map.addPolyline(PolylineOptions().addAll(value.first).color(value.second).width(value.third))?.let { polylines[id] = it }
-            }
-        }
-        val explicitRegion = region(pendingProps.optJSONObject("region"))
-        val initialRegion = region(pendingProps.optJSONObject("initialRegion"))
-        if (explicitRegion != null) {
-            // A controlled region is an exact camera request. The padding
-            // used for fitToBounds is framing chrome, not part of the region
-            // contract, and would otherwise zoom every Android screen out.
-            moveCamera(explicitRegion, padding = 0)
-            initialCameraKey = null
-        } else if (initialRegion != null) {
-            val key = "region:${pendingProps.optJSONObject("initialRegion")}"
-            if (initialCameraKey != key) {
-                moveCamera(initialRegion, padding = 0)
-                initialCameraKey = key
-            }
-        } else if (craftNativeBoolean(pendingProps.opt("fitToBounds"))) {
-            val key = "fit:${overlayKey(nextMarkers, nextPolylines)}:${pendingProps.optJSONObject("edgePadding")}"
-            if (initialCameraKey != key) {
-                if (fitToBounds()) initialCameraKey = key
-            }
-        } else {
-            initialCameraKey = null
-        }
-        applyCameraOrientation()
-        updateScale()
-    }
-
-    private fun applyTileOverlay() {
-        val map = googleMap ?: return
-        val options = pendingProps.optJSONObject("tileOverlay")
-        val template = options?.optString("urlTemplate").orEmpty()
-        val credit = options?.optString("attribution").orEmpty()
-        val next = template.takeIf { it.startsWith("https://") && listOf("{z}", "{x}", "{y}").all { key -> it.contains(key) } && credit.isNotBlank() }
-        if (next != tileTemplate) {
-            tileOverlay?.remove(); tileOverlay = null; tileTemplate = next
-            if (next != null) {
-                val provider = object : com.google.android.gms.maps.model.UrlTileProvider(256, 256) {
-                    override fun getTileUrl(x: Int, y: Int, zoom: Int): java.net.URL? = runCatching { java.net.URL(next.replace("{x}", x.toString()).replace("{y}", y.toString()).replace("{z}", zoom.toString())) }.getOrNull()
-                }
-                tileOverlay = map.addTileOverlay(com.google.android.gms.maps.model.TileOverlayOptions().tileProvider(provider).zIndex(-1f))
-            }
-        }
-        if (next != null) map.mapType = GoogleMap.MAP_TYPE_NONE
-        tileAttribution.text = credit
-        tileAttribution.visibility = if (next == null) View.GONE else View.VISIBLE
-    }
-
-    private fun applyMapPadding() {
-        val authored = pendingProps.optJSONObject("edgePadding")
-        fun inset(name: String): Double = (authored?.opt(name) as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 10_000.0)?.times(resources.displayMetrics.density) ?: 0.0
-        var left = inset("left"); var top = inset("top"); var right = inset("right"); var bottom = inset("bottom")
-        val horizontal = left + right
-        val vertical = top + bottom
-        val availableWidth = (width - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
-        val availableHeight = (height - 40 * resources.displayMetrics.density).coerceAtLeast(0f).toDouble()
-        if (horizontal > availableWidth && horizontal > 0) { left *= availableWidth / horizontal; right *= availableWidth / horizontal }
-        if (vertical > availableHeight && vertical > 0) { top *= availableHeight / vertical; bottom *= availableHeight / vertical }
-        googleMap?.setPadding(left.roundToInt(), top.roundToInt(), right.roundToInt(), bottom.roundToInt())
-    }
-
-    private fun updateScale() {
-        val map = googleMap ?: return
-        if (!craftNativeBoolean(pendingProps.opt("showsScale")) || width <= 0 || height <= 0) { scaleView.visibility = View.GONE; return }
-        val maximumWidth = (80 * resources.displayMetrics.density).roundToInt()
-        val origin = map.projection.fromScreenLocation(android.graphics.Point(width / 2, height / 2))
-        val end = map.projection.fromScreenLocation(android.graphics.Point(width / 2 + maximumWidth, height / 2))
-        val distance = FloatArray(1)
-        android.location.Location.distanceBetween(origin.latitude, origin.longitude, end.latitude, end.longitude, distance)
-        val metres = distance[0].toDouble()
-        if (!metres.isFinite() || metres <= 0) { scaleView.visibility = View.GONE; return }
-        val magnitude = Math.pow(10.0, kotlin.math.floor(kotlin.math.log10(metres)))
-        val length = listOf(5.0, 2.0, 1.0).firstOrNull { it * magnitude <= metres }?.times(magnitude) ?: magnitude
-        scaleLabel.text = if (length >= 1000) "${length / 1000} km" else "${length.roundToInt()} m"
-        scaleLine.layoutParams = LinearLayout.LayoutParams((maximumWidth * length / metres).roundToInt().coerceAtLeast(1), 2)
-        scaleView.visibility = View.VISIBLE
-    }
-
-    private fun applyCameraOrientation() {
-        val map = googleMap ?: return
-        val camera = map.cameraPosition
-        val pitch = (pendingProps.opt("cameraPitch") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.coerceIn(0.0, 60.0)?.toFloat() ?: camera.tilt
-        val heading = (pendingProps.opt("cameraHeading") as? Number)?.toDouble()?.takeIf { it.isFinite() }?.toFloat() ?: camera.bearing
-        if (kotlin.math.abs(camera.tilt - pitch) > 0.01f || kotlin.math.abs(camera.bearing - heading) > 0.01f) {
-            map.moveCamera(CameraUpdateFactory.newCameraPosition(com.google.android.gms.maps.model.CameraPosition.Builder(camera).tilt(pitch).bearing(heading).build()))
-        }
-    }
-
-    private fun directionMarkerIcon(): com.google.android.gms.maps.model.BitmapDescriptor {
-        directionIcon?.let { return it }
-        val size = (26 * resources.displayMetrics.density).roundToInt().coerceAtLeast(24)
-        val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(bitmap)
-        val paint = Paint(Paint.ANTI_ALIAS_FLAG)
-        paint.color = Color.WHITE
-        canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
-        paint.color = Color.rgb(36, 114, 75)
-        canvas.drawCircle(size / 2f, size / 2f, size * 0.43f, paint)
-        paint.color = Color.WHITE
-        paint.textSize = size * 0.76f
-        paint.textAlign = Paint.Align.CENTER
-        paint.typeface = Typeface.DEFAULT_BOLD
-        canvas.drawText("↑", size / 2f, size / 2f - (paint.ascent() + paint.descent()) / 2, paint)
-        return BitmapDescriptorFactory.fromBitmap(bitmap).also { directionIcon = it }
-    }
-
-    override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
-        super.onSizeChanged(width, height, oldWidth, oldHeight)
-        applyMapPadding()
-        updateScale()
-        // MapView can become ready before its host has a usable viewport. Do
-        // not mark a fit as complete until the camera update can be issued.
-        if (width > 0 && height > 0 && craftNativeBoolean(pendingProps.opt("fitToBounds")) && initialCameraKey == null) {
-            applyPending()
-        }
-    }
-
-    private fun moveCamera(bounds: LatLngBounds, padding: Int = 24) {
-        post {
-            if (width > 0 && height > 0) {
-                googleMap?.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, padding))
-                applyCameraOrientation()
-            }
-        }
-    }
-
-    private fun overlayKey(
-        markers: Map<String, Pair<LatLng, String?>>,
-        polylines: Map<String, Triple<List<LatLng>, Int, Float>>,
-    ): String {
-        val markerKey = markers.toSortedMap().entries.joinToString("|") { (id, value) ->
-            "$id:${value.first.latitude},${value.first.longitude}"
-        }
-        val polylineKey = polylines.toSortedMap().entries.joinToString("|") { (id, value) ->
-            "$id:" + value.first.joinToString(";") { point -> "${point.latitude},${point.longitude}" }
-        }
-        return "m[$markerKey]p[$polylineKey]"
-    }
-
-    private fun fitToBounds(): Boolean {
-        val map = googleMap ?: return false
-        if (width <= 0 || height <= 0) return false
-        val builder = LatLngBounds.Builder()
-        var count = 0
-        markers.values.forEach { builder.include(it.position); count++ }
-        polylines.values.flatMap { it.points }.forEach { builder.include(it); count++ }
-        if (count == 0) return false
-        post {
-            if (width > 0 && height > 0) {
-                applyMapPadding()
-                val padding = if (pendingProps.has("edgePadding")) 0 else (24 * resources.displayMetrics.density).roundToInt()
-                map.moveCamera(CameraUpdateFactory.newLatLngBounds(builder.build(), padding))
-                applyCameraOrientation()
-            }
-        }
-        return true
-    }
-
-    override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        if (destroyed) return
-        mapView.onStart()
-        mapView.onResume()
-        lifecycleStarted = true
-    }
-
-    override fun onDetachedFromWindow() {
-        if (lifecycleStarted) {
-            mapView.onPause()
-            mapView.onStop()
-            lifecycleStarted = false
-        }
-        super.onDetachedFromWindow()
-    }
-
-    fun destroy() {
-        if (destroyed) return
-        destroyed = true
-        if (lifecycleStarted) {
-            mapView.onPause()
-            mapView.onStop()
-            lifecycleStarted = false
-        }
-        onMarkerTap = null
-        onMapPress = null
-        onRegionChangeComplete = null
-        directionIcon = null
-        tileOverlay?.remove(); tileOverlay = null
-        markerHandlers.clear()
-        markers.values.forEach { it.remove() }
-        markers.clear()
-        polylines.values.forEach { it.remove() }
-        polylines.clear()
-        mapView.onDestroy()
-        googleMap = null
-    }
-
-    fun lowMemory() {
-        if (!destroyed) mapView.onLowMemory()
-    }
-
-    private fun hasLocationPermission(): Boolean =
-        ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED ||
-            ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
-
-    private fun coordinates(geometry: JSONArray?): List<LatLng> {
-        if (geometry == null) return emptyList()
-        return (0 until geometry.length() - 1 step 2).mapNotNull { index ->
-            val latitude = finiteNumber(geometry.opt(index)) ?: return@mapNotNull null
-            val longitude = finiteNumber(geometry.opt(index + 1)) ?: return@mapNotNull null
-            if (latitude.isFinite() && longitude.isFinite() &&
-                latitude >= -90.0 && latitude <= 90.0 &&
-                longitude >= -180.0 && longitude <= 180.0
-            ) LatLng(latitude, longitude) else null
-        }
-    }
-
-    private fun region(value: JSONObject?): LatLngBounds? {
-        val center = value?.optJSONObject("center") ?: return null
-        val span = value.optJSONObject("span") ?: return null
-        val latitude = finiteNumber(center.opt("latitude")) ?: return null
-        val longitude = finiteNumber(center.opt("longitude")) ?: return null
-        val latitudeDelta = finiteNumber(span.opt("latitudeDelta"))
-            ?: finiteNumber(span.opt("latitude_delta"))
-            ?: return null
-        val longitudeDelta = finiteNumber(span.opt("longitudeDelta"))
-            ?: finiteNumber(span.opt("longitude_delta"))
-            ?: return null
-        if (!latitude.isFinite() || !longitude.isFinite() || !latitudeDelta.isFinite() || !longitudeDelta.isFinite() ||
-            latitude < -90.0 || latitude > 90.0 || longitude < -180.0 || longitude > 180.0 ||
-            latitudeDelta <= 0.0 || latitudeDelta > 180.0 ||
-            longitudeDelta <= 0.0 || longitudeDelta > 360.0 ||
-            latitude - latitudeDelta / 2.0 < -90.0 || latitude + latitudeDelta / 2.0 > 90.0
-        ) return null
-        return LatLngBounds(LatLng(latitude - latitudeDelta / 2, longitude - longitudeDelta / 2), LatLng(latitude + latitudeDelta / 2, longitude + longitudeDelta / 2))
-    }
-
-    private fun finiteNumber(value: Any?): Double? =
-        (value as? Number)?.toDouble()?.takeIf { it.isFinite() }
-
-    private fun color(value: String): Int = runCatching { craftNativeColor(value) }.getOrDefault(Color.BLUE)
-}
+{{NATIVE_MAP_HOST}}
 
 /** A finite celebration owned by a View, never by the JavaScript frame loop. */
 internal class CraftNativeCelebration(private val view: View) {
@@ -1882,7 +1457,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             putEnum(base, 16, if (root) sharedAlignItemsCode(alignItems) else 3)
             putEnum(base, 17, if (root) 0 else sharedAlignSelfCode(style.alignSelf))
             putEnum(base, 18, if (root && wrap) 1 else 0)
-            putEnum(base, 19, if (root) alignContentCode() else 6)
+            putEnum(base, 19, if (root) alignContentCode() else 5)
             put(base, 20, margins[2].toFloat())
             put(base, 21, margins[1].toFloat())
             put(base, 22, margins[3].toFloat())
@@ -7000,6 +6575,7 @@ class MainActivity : AppCompatActivity() {
         val label = craftNativeOptionalString(props.opt("accessibilityLabel"))
             ?: craftNativeOptionalString(props.opt("alt"))?.takeIf { type == "Image" || type == "ImageBackground" }
         val value = craftNativeOptionalString(props.opt("accessibilityValue"))
+        val testId = craftNativeOptionalString(props.opt("testID"))
         view.contentDescription = when {
             label != null && value != null -> "$label, $value"
             label != null -> label
@@ -7024,6 +6600,9 @@ class MainActivity : AppCompatActivity() {
         ViewCompat.setAccessibilityDelegate(view, object : AccessibilityDelegateCompat() {
             override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
                 super.onInitializeAccessibilityNodeInfo(host, info)
+                // Expose STX test identities to Android's native automation
+                // tree without replacing the label read by TalkBack.
+                info.viewIdResourceName = testId
                 info.className = when (role) {
                     "button" -> Button::class.java.name
                     "image" -> ImageView::class.java.name

package/dist/android/templates/build.gradle.kts.app.template

@@ -99,7 +99,7 @@ dependencies {
     // Google Play Location Services (for geolocation)
     implementation("com.google.android.gms:play-services-location:21.1.0")
 
-{{GOOGLE_MAPS_DEPENDENCY}}
+{{NATIVE_MAP_DEPENDENCY}}
 
     // Google Play In-App Review
     implementation("com.google.android.play:review:2.0.1")

package/dist/android/templates/build.gradle.kts.project.template

@@ -1,6 +1,6 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
     id("com.android.application") version "8.9.1" apply false
-    id("org.jetbrains.kotlin.android") version "2.0.21" apply false
+    id("org.jetbrains.kotlin.android") version "2.2.10" apply false
 {{GOOGLE_SERVICES_PLUGIN}}
 }

package/dist/android-adb.d.ts

@@ -0,0 +1,2 @@
+/** Restart adbd once and require a rooted, explicitly selected disposable emulator. */
+export declare function requireAndroidEmulatorRoot(adb: string, serial: string, timeoutMs?: number): Promise<void>;

package/dist/api/index.d.ts

@@ -17,7 +17,7 @@ export type { HttpClientOptions, RequestOptions, HttpResponse, WebSocketOptions
 export { crypto, uuid, randomString, hmac, timingSafeEqual, hashPassword, verifyPassword } from './crypto.js';
 export { env, getPlatform, isDesktop, isMobile, isCraft, getSystemInfo, exec, spawn, ChildProcess, cwd, homeDir, tempDir, exit, argv, open } from './process.js';
 export type { Platform, SystemInfo, ExecOptions, ExecResult, SpawnOptions } from './process.js';
-export { device, haptics, permissions, camera, biometrics, secureStorage, location, share, lifecycle, notifications, notifications as notification } from './mobile.js';
+export { device, haptics, permissions, camera, biometrics, secureStorage, storage, location, share, lifecycle, notifications, notifications as notification } from './mobile.js';
 export type { DeviceInfo, DeviceCapabilities, HapticStyle, HapticNotificationType, PermissionType, PermissionStatus, CameraOptions as MobileCameraOptions, PhotoResult, BiometricType, Location, LocationOptions, ShareOptions, AppState, NotificationOptions as MobileNotificationOptions } from './mobile.js';
 export { carplay, appClips, liveActivities, sharePlay, storeKit, appIntents, tipKit, focusFilters } from './ios-advanced.js';
 export type { CarPlayTemplateType, CarPlayListItem, CarPlayGridItem, CarPlayTemplate, AppClipInvocation, LiveActivityContentState, LiveActivityAttributes, LiveActivityConfig, LiveActivityHandle, SharePlaySessionState, SharePlayParticipant, SharePlayActivity, ProductType, Product, Transaction, IntentParameterType, IntentParameter, AppIntent, TipDisplayFrequency, Tip, FocusStatus, FocusFilter } from './ios-advanced.js';

package/dist/api/mobile.d.ts

@@ -459,6 +459,8 @@ export declare const secureStorage: {
  * Location coordinates.
  */
 export interface Location {
+    /** Owner captured when a native recording emits this sample. */
+    recordingId?: string;
     latitude: number;
     longitude: number;
     altitude?: number;
@@ -478,6 +480,30 @@ export interface LocationOptions {
     /** Maximum age of cached position in milliseconds */
     maximumAge?: number;
 }
+/** Persist this ID with the owning intent before starting a native recording. */
+export interface RecordingStartOptions {
+    recordingId?: string;
+}
+/** Fence a recording operation to the ID returned by start or explicit recovery. */
+export interface RecordingOwnershipOptions {
+    expectedId: string;
+}
+/** Secure IDs supplied by the platform, including WebView-free mobile hosts. */
+export declare const crypto: {
+    randomUUID(): Promise<string>;
+};
+/** Native storage, including an existing-key atomic checkpoint. */
+export declare const storage: {
+    supportsSetIfAbsent(): boolean;
+    supportsCompareAndSet(): boolean;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set(key: string, value: unknown): Promise<boolean>;
+    remove(key: string): Promise<boolean>;
+    clear(): Promise<boolean>;
+    keys(): Promise<string[]>;
+    setIfAbsent(key: string, value: unknown): Promise<boolean>;
+    compareAndSet(key: string, expectedValue: unknown, nextValue: unknown): Promise<boolean>;
+};
 export interface LocationRecordingState {
     id: string | null;
     active: boolean;
@@ -507,6 +533,8 @@ export interface LocationRecordingResult extends LocationRecordingState {
  * ```
  */
 export declare const location: {
+    supportsRecordingOwnership: () => boolean;
+    supportsRecordingIntentIdentity: () => boolean;
     /**
      * Get current position.
      *
@@ -528,12 +556,13 @@ export declare const location: {
      * @param watchId - Watch ID returned from watchPosition
      */
     clearWatch(watchId: number): void;
-    startRecording(options?: LocationOptions): Promise<LocationRecordingState>;
-    pauseRecording(): Promise<LocationRecordingState>;
-    resumeRecording(): Promise<LocationRecordingState>;
-    stopRecording(): Promise<LocationRecordingResult>;
-    getRecordingState(): Promise<LocationRecordingState>;
-    readRecording(): Promise<Location[]>;
+    startRecording(options?: LocationOptions & RecordingStartOptions): Promise<LocationRecordingState>;
+    pauseRecording(options?: RecordingOwnershipOptions): Promise<LocationRecordingState>;
+    resumeRecording(options?: RecordingOwnershipOptions): Promise<LocationRecordingState>;
+    stopRecording(options?: RecordingOwnershipOptions): Promise<LocationRecordingResult>;
+    getRecordingState(options?: RecordingOwnershipOptions): Promise<LocationRecordingState>;
+    acknowledgeRecording(options: RecordingOwnershipOptions): Promise<boolean>;
+    readRecording(options?: RecordingOwnershipOptions): Promise<Location[]>;
 };
 /**
  * Share options.
@@ -914,7 +943,7 @@ export interface HeartRateSample {
     /** Milliseconds between beats, when the strap sent them. */
     rr?: number[];
 }
-export type HeartRateMethod = 'getState' | 'requestAuthorization' | 'scan' | 'stopScan' | 'getDevices' | 'connect' | 'reconnect' | 'disconnect' | 'startRecording' | 'pauseRecording' | 'resumeRecording' | 'stopRecording' | 'getRecordingState' | 'readRecording';
+export type HeartRateMethod = 'getState' | 'requestAuthorization' | 'scan' | 'stopScan' | 'getDevices' | 'connect' | 'reconnect' | 'disconnect' | 'startRecording' | 'pauseRecording' | 'resumeRecording' | 'stopRecording' | 'getRecordingState' | 'readRecording' | 'acknowledgeRecording';
 export declare function normalizeHeartRateDevice(value: unknown): HeartRateDevice | null;
 /** A state from native, made safe to render whatever an older or newer build sent. */
 export declare function normalizeHeartRateState(value: unknown): HeartRateState;
@@ -923,6 +952,8 @@ export declare function normalizeHeartRateReading(value: unknown): HeartRateRead
 /** A recording's samples, oldest first, one per timestamp, implausible ones left out. */
 export declare function normalizeHeartRateSamples(value: unknown): HeartRateSample[];
 export declare const heartRate: {
+    supportsRecordingOwnership: () => boolean;
+    supportsRecordingIntentIdentity: () => boolean;
     /** Whether this app can read a heart-rate strap. */
     isAvailable(): boolean;
     /** Whether this app build answers `method`; an older build may lack one. */
@@ -955,18 +986,20 @@ export declare const heartRate: {
         forget?: boolean;
     }) => Promise<HeartRateState>;
     /** Keep every reading natively from now on: screen locked, page suspended or app closed. */
-    startRecording: () => Promise<HeartRateRecordingState>;
-    pauseRecording: () => Promise<HeartRateRecordingState>;
-    resumeRecording: () => Promise<HeartRateRecordingState>;
+    startRecording(options?: RecordingStartOptions): Promise<HeartRateRecordingState>;
+    pauseRecording(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState>;
+    resumeRecording(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState>;
     /** Ends the recording and hands back every reading it kept. */
-    stopRecording: () => Promise<HeartRateRecordingState & {
+    stopRecording(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState & {
         samples: HeartRateSample[];
     }>;
-    getRecordingState: () => Promise<HeartRateRecordingState>;
+    getRecordingState(options?: RecordingOwnershipOptions): Promise<HeartRateRecordingState>;
+    acknowledgeRecording(options: RecordingOwnershipOptions): Promise<boolean>;
     /** The recording so far; only what came after `since` (ms) when given. */
-    readRecording: (options?: {
+    readRecording(options?: {
         since?: number;
-    }) => Promise<HeartRateSample[]>;
+        expectedId?: string;
+    }): Promise<HeartRateSample[]>;
     /** Every reading from the connected strap, about once a second. */
     onReading: (callback: (reading: HeartRateReading) => void) => (() => void);
     /** Each strap a scan finds. */
@@ -1685,6 +1718,8 @@ export declare const watchConnectivity: {
     onReachabilityChange(callback: (reachable: boolean) => void): () => void;
 };
 declare const mobile: {
+    crypto: typeof crypto;
+    storage: typeof storage;
     device: typeof device;
     haptics: typeof haptics;
     permissions: typeof permissions;

package/dist/browser/storage.d.ts

@@ -6,8 +6,11 @@ export interface BrowserStorageOptions {
     accountKeys?: string[];
     hash: (value: string) => Promise<string>;
     changed: (name: string) => void;
+    /** A host lock primitive; browsers use their native Web Locks implementation. */
+    lock?: (<T>(name: string, operation: () => T | Promise<T>) => Promise<T>) | null;
 }
 export interface BrowserStorage {
+    atomicStorage: boolean;
     craft: {
         storage: {
             getSync: (key: string) => unknown;