craft-native 0.0.175 → 0.0.177

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

@@ -12,7 +12,9 @@ import android.database.ContentObserver
 import android.content.Intent
 import android.media.AudioAttributes
 import android.media.AudioFormat
+import android.media.MediaPlayer
 import android.media.AudioTrack
+import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.Canvas
 import android.graphics.Color
@@ -54,6 +56,7 @@ import android.text.Layout
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewOutlineProvider
+import android.view.ViewParent
 import android.view.ViewTreeObserver
 import android.widget.AdapterView
 import android.widget.ArrayAdapter
@@ -80,6 +83,7 @@ import androidx.core.content.ContextCompat
 import androidx.core.view.AccessibilityDelegateCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
 import androidx.javascriptengine.JavaScriptIsolate
 import androidx.javascriptengine.JavaScriptConsoleCallback
@@ -113,26 +117,63 @@ import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.PI
 import kotlin.math.ceil
+import kotlin.math.abs
+import kotlin.math.exp
 import kotlin.math.roundToInt
 import kotlin.math.roundToLong
 import kotlin.math.sin
+import kotlin.math.pow
 
 private const val CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS = 30_000L
 
+private fun craftNativeOptionalString(value: Any?): String? = value
+    ?.takeUnless { it == JSONObject.NULL }
+    ?.toString()
+    ?.takeUnless { it == "null" || it == "undefined" }
+    ?.takeIf { it.isNotBlank() }
+
+private fun craftNativeEventName(events: JSONObject, vararg names: String): String =
+    names.firstNotNullOfOrNull { name -> craftNativeOptionalString(events.opt(name)) }.orEmpty()
+
+internal fun craftNativePadding(style: JSONObject?, name: String, fallback: Int, density: Float): Int {
+    val value = style?.optDouble(name, Double.NaN) ?: Double.NaN
+    val pixels = value * density
+    return if (value.isFinite() && value >= 0 && pixels.isFinite()) pixels.toInt() else fallback
+}
+
+internal fun craftNativeFiniteFloat(style: JSONObject?, name: String, fallback: Float): Float {
+    val value = style?.optDouble(name, Double.NaN) ?: Double.NaN
+    val narrowed = value.toFloat()
+    return if (value.isFinite() && narrowed.isFinite()) narrowed else fallback
+}
+
+internal fun craftNativeFiniteDouble(style: JSONObject?, name: String, fallback: Double): Double {
+    val value = style?.optDouble(name, Double.NaN) ?: Double.NaN
+    return value.takeIf { it.isFinite() } ?: fallback
+}
+
+internal fun craftNativeNonNegativeDouble(style: JSONObject?, name: String, fallback: Double): Double {
+    val value = craftNativeFiniteDouble(style, name, Double.NaN)
+    return if (value.isFinite() && value >= 0) value else fallback
+}
+
 private data class CraftNativeLength(
     val points: Int? = null,
     val fraction: Double? = null,
 ) {
-    fun resolve(base: Int?): Int? = points ?: fraction?.let { value -> base?.let { max(0, (it * value).roundToInt()) } }
+    fun resolve(base: Int?): Int? = points?.coerceAtLeast(0) ?: fraction?.let { value -> base?.let { max(0, (it * value).roundToInt()) } }
 
     companion object {
         fun from(value: Any?, density: Float): CraftNativeLength? {
             if (value == null || value == JSONObject.NULL) return null
-            if (value is Number) return CraftNativeLength(points = (value.toDouble() * density).roundToInt())
+            if (value is Number) {
+                val points = value.toDouble() * density
+                return points.takeIf { it.isFinite() }?.let { CraftNativeLength(points = it.roundToInt()) }
+            }
             val text = value.toString().trim()
-            if (text.endsWith('%')) return text.dropLast(1).toDoubleOrNull()?.let { CraftNativeLength(fraction = it / 100) }
-            if (text.endsWith("px")) return text.dropLast(2).toDoubleOrNull()?.let { CraftNativeLength(points = (it * density).roundToInt()) }
-            return text.toDoubleOrNull()?.let { CraftNativeLength(points = (it * density).roundToInt()) }
+            if (text.endsWith('%')) return text.dropLast(1).toDoubleOrNull()?.takeIf { it.isFinite() }?.let { CraftNativeLength(fraction = it / 100) }
+            if (text.endsWith("px")) return text.dropLast(2).toDoubleOrNull()?.takeIf { it.isFinite() }?.let { CraftNativeLength(points = (it * density).roundToInt()) }
+            return text.toDoubleOrNull()?.takeIf { it.isFinite() }?.let { CraftNativeLength(points = (it * density).roundToInt()) }
         }
     }
 }
@@ -160,11 +201,13 @@ private data class CraftNativeLayoutStyle(
             fun length(name: String): CraftNativeLength? = CraftNativeLength.from(raw.opt(name), density)
             fun number(name: String): Int? {
                 if (!raw.has(name) || raw.isNull(name)) return null
-                return raw.optDouble(name, Double.NaN).takeUnless { it.isNaN() }?.let { (it * density).roundToInt() }
+                return raw.optDouble(name, Double.NaN).takeIf { it.isFinite() }?.let { points ->
+                    (points * density).takeIf { it.isFinite() }?.roundToInt()
+                }
             }
             fun decimal(name: String): Double? {
                 if (!raw.has(name) || raw.isNull(name)) return null
-                return raw.optDouble(name, Double.NaN).takeUnless { it.isNaN() }
+                return raw.optDouble(name, Double.NaN).takeIf { it.isFinite() }
             }
             val flex = decimal("flex")
             return CraftNativeLayoutStyle(
@@ -277,6 +320,10 @@ private class CraftNativeSvgView(context: Context) : View(context) {
         val color: String = "#000000",
         val opacity: Float = 1f,
         val typeface: Typeface = Typeface.DEFAULT,
+        val strokeLinecap: String? = null,
+        val strokeLinejoin: String? = null,
+        val strokeDasharray: List<Float> = emptyList(),
+        val vectorEffect: String? = null,
     ) {
         fun merge(node: JSONObject): SvgPaint {
             val props = node.optJSONObject("props") ?: JSONObject()
@@ -286,17 +333,32 @@ private class CraftNativeSvgView(context: Context) : View(context) {
                 props.has(name) && !props.isNull(name) -> props.optString(name)
                 else -> null
             }
+            fun raw(name: String): Any? = when {
+                style.has(name) && !style.isNull(name) -> style.opt(name)
+                props.has(name) && !props.isNull(name) -> props.opt(name)
+                else -> null
+            }
+            fun dashes(rawValue: Any?): List<Float>? {
+                val values = rawValue as? JSONArray ?: return null
+                return (0 until values.length()).mapNotNull {
+                    values.optDouble(it, Double.NaN).toFloat().takeIf { value -> value.isFinite() && value >= 0 }
+                }
+            }
             // Keep the cascade explicit: computed style wins over a raw prop
             // when both provide the same SVG paint value.
             val weight = value("fontWeight")
-            val ownOpacity = value("opacity")?.toFloatOrNull() ?: 1f
+            val ownOpacity = value("opacity")?.toFloatOrNull()?.takeIf { it.isFinite() } ?: 1f
             return copy(
                 fill = value("fill") ?: fill,
                 stroke = value("stroke") ?: stroke,
-                strokeWidth = value("strokeWidth")?.toFloatOrNull() ?: strokeWidth,
+                strokeWidth = value("strokeWidth")?.toFloatOrNull()?.takeIf { it.isFinite() } ?: strokeWidth,
                 color = value("color") ?: color,
                 opacity = ownOpacity * opacity,
                 typeface = if (weight in setOf("bold", "700")) Typeface.DEFAULT_BOLD else typeface,
+                strokeLinecap = value("strokeLinecap") ?: strokeLinecap,
+                strokeLinejoin = value("strokeLinejoin") ?: strokeLinejoin,
+                strokeDasharray = dashes(raw("strokeDasharray")) ?: strokeDasharray,
+                vectorEffect = value("vectorEffect") ?: vectorEffect,
             )
         }
     }
@@ -354,7 +416,7 @@ private class CraftNativeSvgView(context: Context) : View(context) {
         val y = values.optDouble(1, Double.NaN).toFloat()
         val width = values.optDouble(2, Double.NaN).toFloat()
         val height = values.optDouble(3, Double.NaN).toFloat()
-        if (!x.isFinite() || !y.isFinite() || !width.isFinite() || !height.isFinite()) return null
+        if (!x.isFinite() || !y.isFinite() || !width.isFinite() || !height.isFinite() || width <= 0f || height <= 0f) return null
         return Quadruple(width, height, x, y)
     }
 
@@ -375,6 +437,7 @@ private class CraftNativeSvgView(context: Context) : View(context) {
     private fun drawPath(canvas: Canvas, node: JSONObject, style: SvgPaint) {
         val props = node.optJSONObject("props") ?: JSONObject()
         val geometry = props.optJSONArray("geometry") ?: return
+        if ((0 until geometry.length()).any { !geometry.optDouble(it, Double.NaN).toFloat().isFinite() }) return
         val path = Path()
         var index = 0
         while (index < geometry.length()) {
@@ -401,34 +464,29 @@ private class CraftNativeSvgView(context: Context) : View(context) {
                 alpha = (style.opacity * 255f).roundToInt().coerceIn(0, 255)
                 this.style = Paint.Style.STROKE
                 strokeWidth = style.strokeWidth
-                strokeCap = when (props.optString("strokeLinecap")) {
+                strokeCap = when (style.strokeLinecap) {
                     "round" -> Paint.Cap.ROUND
                     "square" -> Paint.Cap.SQUARE
                     else -> Paint.Cap.BUTT
                 }
-                strokeJoin = when (props.optString("strokeLinejoin")) {
+                strokeJoin = when (style.strokeLinejoin) {
                     "round" -> Paint.Join.ROUND
                     "bevel" -> Paint.Join.BEVEL
                     else -> Paint.Join.MITER
                 }
-                props.optJSONArray("strokeDasharray")?.let { values ->
-                    val dashes: List<Float> = (0 until values.length()).mapNotNull {
-                        values.optDouble(it, Double.NaN).takeUnless { value -> value.isNaN() }?.toFloat()
-                    }
-                    if (dashes.isNotEmpty()) {
-                        val dashPattern = dashes.toFloatArray()
-                        val pattern: FloatArray = if (dashPattern.size % 2 == 1) {
-                            FloatArray(dashPattern.size * 2) { index -> dashPattern[index % dashPattern.size] }
-                        } else {
-                            dashPattern
-                        }
-                        pathEffect = DashPathEffect(pattern, 0f)
+                if (style.strokeDasharray.isNotEmpty()) {
+                    val dashPattern = style.strokeDasharray.toFloatArray()
+                    val pattern: FloatArray = if (dashPattern.size % 2 == 1) {
+                        FloatArray(dashPattern.size * 2) { index -> dashPattern[index % dashPattern.size] }
+                    } else {
+                        dashPattern
                     }
+                    pathEffect = DashPathEffect(pattern, 0f)
                 }
             }
             // `vector-effect="non-scaling-stroke"`: the stroke is in the view's
             // pixels, so a stretched chart's line keeps its width.
-            if (props.optString("vectorEffect") == "non-scaling-stroke") {
+            if (style.vectorEffect == "non-scaling-stroke") {
                 val line = Path(path).apply { transform(viewTransform) }
                 canvas.save()
                 canvas.concat(inverseTransform)
@@ -449,15 +507,17 @@ private class CraftNativeSvgView(context: Context) : View(context) {
         }
         if (text.isEmpty()) return
         val size = (if (props.has("fontSize")) props.optDouble("fontSize", 12.0) else nodeStyle.optDouble("fontSize", 12.0))
-            .toFloat()
+            .takeIf { it.isFinite() }
+            ?.toFloat()
+            ?: 12f
         val paint = android.graphics.Paint(Paint.ANTI_ALIAS_FLAG).apply {
             color = resolveColor(style.fill, style.color, Color.BLACK)
             alpha = (style.opacity * 255f).roundToInt().coerceIn(0, 255)
             textSize = size
             typeface = style.typeface
         }
-        var x = props.optDouble("x", 0.0).toFloat()
-        val y = props.optDouble("y", 0.0).toFloat()
+        var x = props.optDouble("x", 0.0).takeIf { it.isFinite() }?.toFloat() ?: 0f
+        val y = props.optDouble("y", 0.0).takeIf { it.isFinite() }?.toFloat() ?: 0f
         when (props.optString("textAnchor")) {
             "middle" -> x -= paint.measureText(text) / 2f
             "end" -> x -= paint.measureText(text)
@@ -482,6 +542,8 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
     private val polylines = mutableMapOf<String, Polyline>()
     private val markerHandlers = mutableMapOf<String, String>()
     private var onMarkerTap: ((String) -> Unit)? = null
+    private var lifecycleStarted = false
+    private var destroyed = false
 
     init {
         addView(mapView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
@@ -490,11 +552,15 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
     }
 
     override fun onMapReady(map: GoogleMap) {
+        if (destroyed) return
         googleMap = map
         map.setOnMarkerClickListener { marker ->
             val id = markers.entries.firstOrNull { it.value == marker }?.key ?: return@setOnMarkerClickListener false
             onMarkerTap?.invoke(id)
-            false
+            // 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()
     }
@@ -513,7 +579,7 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
         map.uiSettings.isScrollGesturesEnabled = pendingProps.optBoolean("scrollEnabled", true)
         map.uiSettings.isZoomGesturesEnabled = pendingProps.optBoolean("zoomEnabled", true)
         map.uiSettings.isRotateGesturesEnabled = pendingProps.optBoolean("rotateEnabled", false)
-        map.mapType = when (pendingProps.optString("mapType").lowercase()) {
+        map.mapType = when (craftNativeOptionalString(pendingProps.opt("mapType")).orEmpty().lowercase()) {
             "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
             "hybrid" -> GoogleMap.MAP_TYPE_HYBRID
             "terrain" -> GoogleMap.MAP_TYPE_TERRAIN
@@ -529,20 +595,32 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
             val type = child.optString("type").lowercase()
             val props = child.optJSONObject("props") ?: JSONObject()
             val events = child.optJSONObject("events") ?: JSONObject()
-            val id = props.opt("id")?.takeUnless { it == JSONObject.NULL }?.toString()
-                ?: child.optString("id").takeIf { it.isNotBlank() }
+            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.optString("title").takeIf { it.isNotBlank() }
-                    events.optString("onPress").ifBlank { events.optString("onMarkerPress") }
-                        .takeIf { it.isNotBlank() }?.let { nextHandlers[id] = it }
+                    nextMarkers[id] = point to craftNativeOptionalString(props.opt("title"))
+                    listOf(events.opt("onPress"), events.opt("onMarkerPress"))
+                        .firstNotNullOfOrNull(::craftNativeOptionalString)
+                        ?.let { nextHandlers[id] = it }
                 }
             } else if (type == "mappolyline" || type == "polyline") {
                 if (points.size > 1) {
-                    val width = props.optDouble("strokeWidth", 3.0).toFloat().takeIf { it.isFinite() && it > 0 } ?: 3f
-                    nextPolylines[id] = Triple(points, color(props.optString("strokeColor")), width)
+                    // 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
+                    }
+                    val width = authoredWidth.toFloat()
+                    if (!authoredWidth.isFinite() || !width.isFinite() || width <= 0f) continue
+                    nextPolylines[id] = Triple(points, color(craftNativeOptionalString(props.opt("strokeColor")).orEmpty()), width)
                 }
             }
         }
@@ -558,10 +636,18 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
         }
         markerHandlers.clear()
         markerHandlers.putAll(nextHandlers)
-        polylines.values.forEach { it.remove() }
-        polylines.clear()
+        polylines.keys.filter { nextPolylines[it] == null }.forEach { id ->
+            polylines.remove(id)?.remove()
+        }
         for ((id, value) in nextPolylines) {
-            polylines[id] = map.addPolyline(PolylineOptions().addAll(value.first).color(value.second).width(value.third))
+            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 }
+            }
         }
         if (pendingProps.optBoolean("fitToBounds", false)) fitToBounds()
         region(pendingProps.optJSONObject("region") ?: pendingProps.optJSONObject("initialRegion"))?.let { bounds ->
@@ -585,16 +671,43 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
+        if (destroyed) return
         mapView.onStart()
         mapView.onResume()
+        lifecycleStarted = true
     }
 
     override fun onDetachedFromWindow() {
-        mapView.onPause()
-        mapView.onStop()
+        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
+        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
@@ -604,7 +717,10 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
         return (0 until geometry.length() - 1 step 2).mapNotNull { index ->
             val latitude = geometry.optDouble(index, Double.NaN)
             val longitude = geometry.optDouble(index + 1, Double.NaN)
-            if (latitude.isFinite() && longitude.isFinite()) LatLng(latitude, longitude) else null
+            if (latitude.isFinite() && longitude.isFinite() &&
+                latitude >= -90.0 && latitude <= 90.0 &&
+                longitude >= -180.0 && longitude <= 180.0
+            ) LatLng(latitude, longitude) else null
         }
     }
 
@@ -615,7 +731,12 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
         val longitude = center.optDouble("longitude", Double.NaN)
         val latitudeDelta = span.optDouble("latitudeDelta", span.optDouble("latitude_delta", Double.NaN))
         val longitudeDelta = span.optDouble("longitudeDelta", span.optDouble("longitude_delta", Double.NaN))
-        if (!latitude.isFinite() || !longitude.isFinite() || !latitudeDelta.isFinite() || !longitudeDelta.isFinite()) 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))
     }
 
@@ -661,6 +782,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             (0 until raw.length()).mapNotNull { raw.optString(it).takeIf { edge -> edge in setOf("top", "right", "bottom", "left") } }.toSet()
         }
         applySafeAreaPadding()
+        invalidateMeasurements()
     }
 
     fun setWindowSafeInsets(left: Int, top: Int, right: Int, bottom: Int) {
@@ -672,6 +794,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             if ("bottom" in safeAreaEdges) insets[3] else 0,
         )
         applySafeAreaPadding()
+        invalidateMeasurements()
     }
 
     private fun applySafeAreaPadding() {
@@ -720,6 +843,31 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     private fun probedWidth(size: Long): Int = (size shr 32).toInt()
     private fun probedHeight(size: Long): Int = size.toInt()
 
+    /**
+     * Reactive style and inset mutations can arrive during one frame. The
+     * memo is intentionally frame-scoped for performance, but a mutation
+     * must invalidate it immediately or the next layout can reuse a child's
+     * old intrinsic width/height.
+     */
+    private fun invalidateMeasurements() {
+        memos.clear()
+        lastProbe.clear()
+        forceLayout()
+        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()
+            }
+            ancestor = (ancestor as? View)?.parent
+        }
+    }
+
     /**
      * Lays a child out at its final frame, measuring it again at exactly
      * that size first when the measure pass left it another size (a
@@ -757,34 +905,50 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         alignItems = style.optString("alignItems", "stretch")
         alignContent = style.optString("alignContent", "flex-start")
         justifyContent = style.optString("justifyContent", "flex-start")
-        val gap = style.optDouble("gap", 0.0) * density
-        rowGap = style.optDouble("rowGap", gap / density.toDouble()).toFloat() * density
-        columnGap = style.optDouble("columnGap", gap / density.toDouble()).toFloat() * density
+        fun spacing(name: String, fallback: Float): Float {
+            val value = style.optDouble(name, Double.NaN)
+            val pixels = value * density
+            val narrowed = pixels.toFloat()
+            return if (value.isFinite() && value >= 0 && pixels.isFinite() && narrowed.isFinite()) narrowed else fallback
+        }
+        val gap = spacing("gap", 0f)
+        rowGap = spacing("rowGap", gap)
+        columnGap = spacing("columnGap", gap)
         grid = style.optString("display") == "grid"
         gridColumns = craftNativeGridColumnCount(
             if (style.has("gridTemplateColumns")) style.opt("gridTemplateColumns") else style.opt("gridColumns")
         )
         gridAutoRows = CraftNativeLength.from(style.opt("gridAutoRows"), density)
-        val padding = (style.optDouble("padding", 0.0) * density).toInt()
-        val horizontal = (style.optDouble("paddingHorizontal", padding.toDouble() / density.toDouble()) * density).toInt()
-        val vertical = (style.optDouble("paddingVertical", padding.toDouble() / density.toDouble()) * density).toInt()
+        val all = craftNativePadding(style, "padding", 0, density)
+        val horizontal = craftNativePadding(style, "paddingHorizontal", all, density)
+        val vertical = craftNativePadding(style, "paddingVertical", all, density)
         setPadding(
-            (style.optDouble("paddingLeft", horizontal.toDouble() / density.toDouble()) * density).toInt(),
-            (style.optDouble("paddingTop", vertical.toDouble() / density.toDouble()) * density).toInt(),
-            (style.optDouble("paddingRight", horizontal.toDouble() / density.toDouble()) * density).toInt(),
-            (style.optDouble("paddingBottom", vertical.toDouble() / density.toDouble()) * density).toInt(),
+            craftNativePadding(style, "paddingLeft", horizontal, density),
+            craftNativePadding(style, "paddingTop", vertical, density),
+            craftNativePadding(style, "paddingRight", horizontal, density),
+            craftNativePadding(style, "paddingBottom", vertical, density),
         )
-        requestLayout()
+        invalidateMeasurements()
     }
 
     fun setChildStyle(view: View, style: JSONObject, density: Float) {
         styles[view] = CraftNativeLayoutStyle.from(style, density)
-        requestLayout()
+        invalidateMeasurements()
+        invalidateMeasurementAncestors(parent)
     }
 
     override fun onViewRemoved(child: View) {
+        val parentBeforeRemoval = parent
         styles.remove(child)
         super.onViewRemoved(child)
+        invalidateMeasurements()
+        invalidateMeasurementAncestors(parentBeforeRemoval)
+    }
+
+    override fun onViewAdded(child: View) {
+        super.onViewAdded(child)
+        invalidateMeasurements()
+        invalidateMeasurementAncestors(parent)
     }
 
     private data class Entry(val view: View, val style: CraftNativeLayoutStyle, val width: Int, val height: Int)
@@ -1038,6 +1202,116 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         else -> 0.0
     }
 
+    private fun sharedAlignItemsCode(value: String): Int = when (value) {
+        "center" -> 1
+        "flex-end" -> 2
+        "stretch" -> 3
+        "baseline" -> 4
+        else -> 0
+    }
+
+    private fun sharedAlignSelfCode(value: String?): Int = when (value) {
+        "flex-start" -> 1
+        "center" -> 2
+        "flex-end" -> 3
+        "stretch" -> 4
+        "baseline" -> 5
+        else -> 0
+    }
+
+    private fun sharedLength(value: CraftNativeLength?, base: Int?): Float = value?.resolve(base)?.toFloat() ?: Float.NaN
+
+    /**
+     * Use the host-neutral tree ABI when platform measurements are complete:
+     * definite, non-grid direct-child containers, including wrapped flows with
+     * independent row and column gaps. Reverse flows, absolute children,
+     * missing runtimes, and malformed results deliberately fall through to
+     * the established Kotlin layout below.
+     */
+    private fun sharedDirectFrames(entries: List<Entry>, width: Int, height: Int): FloatArray? {
+        if (entries.isEmpty() || width < 0 || height < 0 || grid || reverse || wrapReverse) return null
+        val count = entries.size + 1
+        val fields = 32
+        val nodeData = FloatArray(count * fields) { Float.NaN }
+        val treeMeta = FloatArray(count * 2)
+        fun enumBits(value: Int): Float = Float.fromBits(value)
+        fun put(base: Int, index: Int, value: Float) { nodeData[base + index] = value }
+        fun putEnum(base: Int, index: Int, value: Int) { put(base, index, enumBits(value)) }
+        val contentWidth = max(0, width - paddingLeft - paddingRight)
+        val contentHeight = max(0, height - paddingTop - paddingBottom)
+        val mainSize = if (orientation == HORIZONTAL) contentWidth else contentHeight
+        fun writeStyle(
+            base: Int,
+            style: CraftNativeLayoutStyle,
+            intrinsicWidth: Float,
+            intrinsicHeight: Float,
+            baseline: Float,
+            margins: IntArray,
+            direction: Int,
+            padding: IntArray,
+            gap: Float,
+            rowGapValue: Float,
+            columnGapValue: Float,
+            root: Boolean,
+            view: View?,
+        ) {
+            putEnum(base, 0, direction)
+            put(base, 1, if (root) width.toFloat() else sharedLength(style.width, contentWidth))
+            put(base, 2, if (root) height.toFloat() else sharedLength(style.height, contentHeight))
+            put(base, 3, if (root) Float.NaN else intrinsicWidth)
+            put(base, 4, if (root) Float.NaN else intrinsicHeight)
+            put(base, 5, if (root) Float.NaN else baseline)
+            put(base, 6, style.aspectRatio?.toFloat() ?: Float.NaN)
+            put(base, 7, sharedLength(style.flexBasis, mainSize))
+            put(base, 8, if (root) 0f else style.flexGrow.toFloat().coerceAtLeast(0f))
+            put(base, 9, if (root) 0f else (style.flexShrink ?: view?.let { defaultFlexShrink(it) } ?: 0.0).toFloat().coerceAtLeast(0f))
+            put(base, 10, sharedLength(style.minWidth, contentWidth))
+            put(base, 11, sharedLength(style.maxWidth, contentWidth))
+            put(base, 12, sharedLength(style.minHeight, contentHeight))
+            put(base, 13, sharedLength(style.maxHeight, contentHeight))
+            put(base, 14, if (root) gap else 0f)
+            putEnum(base, 15, if (root) justifyCode() else 0)
+            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)
+            put(base, 20, margins[2].toFloat())
+            put(base, 21, margins[1].toFloat())
+            put(base, 22, margins[3].toFloat())
+            put(base, 23, margins[0].toFloat())
+            put(base, 24, padding[2].toFloat())
+            put(base, 25, padding[1].toFloat())
+            put(base, 26, padding[3].toFloat())
+            put(base, 27, padding[0].toFloat())
+            putEnum(base, 28, 0)
+            putEnum(base, 29, 1)
+            put(base, 30, if (root) rowGapValue else 0f)
+            put(base, 31, if (root) columnGapValue else 0f)
+        }
+
+        treeMeta[0] = 1f
+        treeMeta[1] = entries.size.toFloat()
+        val rootMargins = intArrayOf(0, 0, 0, 0)
+        val rootPadding = intArrayOf(paddingLeft, paddingRight, paddingTop, paddingBottom)
+        val mainGap = if (orientation == HORIZONTAL) columnGap else rowGap
+        writeStyle(
+            0, CraftNativeLayoutStyle(), 0f, 0f, 0f, rootMargins,
+            if (orientation == HORIZONTAL) 0 else 1, rootPadding, mainGap, rowGap, columnGap, true, null,
+        )
+        entries.forEachIndexed { index, entry ->
+            val base = (index + 1) * fields
+            val lp = entry.view.layoutParams as? MarginLayoutParams
+            val margins = intArrayOf(lp?.leftMargin ?: 0, lp?.rightMargin ?: 0, lp?.topMargin ?: 0, lp?.bottomMargin ?: 0)
+            treeMeta[(index + 1) * 2] = 0f
+            treeMeta[(index + 1) * 2 + 1] = 0f
+            writeStyle(
+                base, entry.style, entry.width.toFloat(), entry.height.toFloat(), baselineOffset(entry.view, entry.height).toFloat(),
+                margins, 0, intArrayOf(0, 0, 0, 0), 0f, 0f, 0f, false, entry.view,
+            )
+        }
+        return CraftNative.layoutTree(width.toFloat(), height.toFloat(), nodeData, treeMeta)
+    }
+
     private fun justifyCode(): Int = when (justifyContent) {
         "center" -> 1
         "flex-end" -> 2
@@ -1165,11 +1439,11 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 contentWidth.toFloat(), contentHeight.toFloat(), gridColumns, columnGap, rowGap,
                 flow.map { it.width.toFloat() }.toFloatArray(), flow.map { it.height.toFloat() }.toFloatArray(),
                 flow.map { it.style.width?.resolve(layout.cellWidth.roundToInt())?.toFloat() ?: Float.NaN }.toFloatArray(),
-                flow.map { it.style.height?.resolve(null)?.toFloat() ?: Float.NaN }.toFloatArray(),
+                flow.map { it.style.height?.resolve(contentHeight)?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.map { it.style.minWidth?.resolve(layout.cellWidth.roundToInt())?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.map { it.style.maxWidth?.resolve(layout.cellWidth.roundToInt())?.toFloat() ?: Float.NaN }.toFloatArray(),
-                flow.map { it.style.minHeight?.resolve(null)?.toFloat() ?: Float.NaN }.toFloatArray(),
-                flow.map { it.style.maxHeight?.resolve(null)?.toFloat() ?: Float.NaN }.toFloatArray(),
+                flow.map { it.style.minHeight?.resolve(contentHeight)?.toFloat() ?: Float.NaN }.toFloatArray(),
+                flow.map { it.style.maxHeight?.resolve(contentHeight)?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.flatMap {
                     val lp = it.view.layoutParams as? MarginLayoutParams
                     listOf((lp?.leftMargin ?: 0).toFloat(), (lp?.rightMargin ?: 0).toFloat(), (lp?.topMargin ?: 0).toFloat(), (lp?.bottomMargin ?: 0).toFloat())
@@ -1255,6 +1529,22 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val contentWidth = width - paddingLeft - paddingRight
         val contentHeight = height - paddingTop - paddingBottom
         val (lines, absolute) = entries(width, height)
+        if (absolute.isEmpty() && lines.isNotEmpty() && (lines.size == 1 || wrap)) {
+            val sharedEntries = if (wrap) lines.flatMap { it.entries } else lines[0].entries
+            val sharedFrames = sharedDirectFrames(sharedEntries, width, height)
+            if (sharedFrames != null) {
+                for ((index, entry) in sharedEntries.withIndex()) {
+                    val offset = (index + 1) * 4
+                    val x = sharedFrames[offset].roundToInt()
+                    val y = sharedFrames[offset + 1].roundToInt()
+                    val childWidth = sharedFrames[offset + 2].roundToInt()
+                    val childHeight = sharedFrames[offset + 3].roundToInt()
+                    place(entry.view, x, y, x + childWidth, y + childHeight)
+                }
+                onLayoutChanged?.invoke()
+                return
+            }
+        }
         val gap = if (orientation == HORIZONTAL) columnGap else rowGap
         val crossGap = if (orientation == HORIZONTAL) rowGap else columnGap
         val availableMain = if (orientation == HORIZONTAL) contentWidth else contentHeight
@@ -1449,7 +1739,9 @@ private class CraftNativeKeyboardAvoidingView(context: Context) : FrameLayout(co
 
     fun configure(props: JSONObject, style: JSONObject, density: Float) {
         behavior = props.optString("behavior", "padding").takeIf { it in setOf("height", "position", "padding") } ?: "padding"
-        keyboardVerticalOffset = (props.optDouble("keyboardVerticalOffset", 0.0) * density).roundToInt()
+        val authoredOffset = craftNativeFiniteDouble(props, "keyboardVerticalOffset", 0.0)
+        val pixelOffset = (authoredOffset * density.toDouble()).takeIf { it.isFinite() } ?: 0.0
+        keyboardVerticalOffset = pixelOffset.roundToInt()
         content.configure(style, density)
         basePadding = intArrayOf(content.paddingLeft, content.paddingTop, content.paddingRight, content.paddingBottom)
         applyKeyboardInset()
@@ -1551,10 +1843,10 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
     }
 
     fun setRefreshAppearance(props: JSONObject, density: Float) {
-        val tint = props.optString("tintColor").takeIf { it.isNotBlank() }
+        val tint = craftNativeOptionalString(props.opt("tintColor"))
         if (tint != null) setColorSchemeColors(craftNativeColor(tint))
         else setColorSchemeColors(Color.WHITE)
-        val background = props.optString("progressBackgroundColor").takeIf { it.isNotBlank() }
+        val background = craftNativeOptionalString(props.opt("progressBackgroundColor"))
         if (background != null) setProgressBackgroundColorSchemeColor(craftNativeColor(background))
         else setProgressBackgroundColorSchemeColor(Color.TRANSPARENT)
         val offset = props.optDouble("progressViewOffset", Double.NaN)
@@ -1915,6 +2207,7 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
     private var pickerMode: PickerMode? = null
     private var datePicker: DatePicker? = null
     private var timePicker: TimePicker? = null
+    private var defaultDateBounds: Pair<Long, Long>? = null
     private var minuteInterval = 1
     private var countdownSecond = 0
     private var suppressChanges = true
@@ -1942,6 +2235,7 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
             }
             if (requestedMode == PickerMode.DATE || requestedMode == PickerMode.DATE_TIME) {
                 datePicker = DatePicker(context).also { picker ->
+                    defaultDateBounds = picker.minDate to picker.maxDate
                     val today = Calendar.getInstance()
                     picker.init(today.get(Calendar.YEAR), today.get(Calendar.MONTH), today.get(Calendar.DAY_OF_MONTH)) { _, _, _, _ -> changed() }
                     content.addView(picker, LinearLayout.LayoutParams(
@@ -1965,8 +2259,9 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
 
         suppressChanges = true
         minuteInterval = props.optInt("minuteInterval", 1).takeIf { it in 1..30 && 60 % it == 0 } ?: 1
-        pickerDate(props.opt("minimumDate"))?.let { datePicker?.minDate = it.timeInMillis }
-        pickerDate(props.opt("maximumDate"))?.let { datePicker?.maxDate = it.timeInMillis }
+        val defaults = defaultDateBounds
+        datePicker?.minDate = pickerDate(props.opt("minimumDate"))?.timeInMillis ?: defaults?.first ?: datePicker?.minDate ?: 0L
+        datePicker?.maxDate = pickerDate(props.opt("maximumDate"))?.timeInMillis ?: defaults?.second ?: datePicker?.maxDate ?: Long.MAX_VALUE
         if (requestedMode == PickerMode.COUNTDOWN) {
             countdownSecond = 0
             countdownSeconds(props.opt("value"))?.let { applyCountdown(it) }
@@ -2051,7 +2346,11 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
     }
 
     private fun pickerDate(value: Any?): Calendar? {
-        if (value is Number && value !is Boolean) return Calendar.getInstance().apply { timeInMillis = value.toLong() }
+        if (value is Number && value !is Boolean) {
+            val milliseconds = value.toDouble()
+            if (!milliseconds.isFinite()) return null
+            return runCatching { Calendar.getInstance().apply { timeInMillis = milliseconds.toLong() } }.getOrNull()
+        }
         val text = value?.toString()?.trim().orEmpty()
         if (text.isBlank() || text == JSONObject.NULL.toString()) return null
         val formats = listOf(
@@ -2069,7 +2368,11 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
     }
 
     private fun countdownSeconds(value: Any?): Int? {
-        if (value is Number && value !is Boolean) return value.toDouble().coerceIn(0.0, maxCountdownSeconds.toDouble()).roundToInt()
+        if (value is Number && value !is Boolean) {
+            val seconds = value.toDouble()
+            if (!seconds.isFinite()) return null
+            return seconds.coerceIn(0.0, maxCountdownSeconds.toDouble()).roundToInt()
+        }
         val text = value?.toString()?.trim().orEmpty()
         if (text.isBlank() || text == JSONObject.NULL.toString()) return null
         text.toDoubleOrNull()?.takeIf { it.isFinite() }?.let { return it.coerceIn(0.0, maxCountdownSeconds.toDouble()).roundToInt() }
@@ -2078,7 +2381,8 @@ private class CraftNativeDatePickerView(context: Context) : FrameLayout(context)
         val hours = parts[0].toDoubleOrNull() ?: return null
         val minutes = parts[1].toDoubleOrNull() ?: return null
         val seconds = if (parts.size == 3) parts[2].toDoubleOrNull() ?: return null else 0.0
-        if (hours < 0 || minutes !in 0.0..<60.0 || seconds !in 0.0..<60.0) return null
+        if (!hours.isFinite() || !minutes.isFinite() || !seconds.isFinite() ||
+            hours < 0 || minutes !in 0.0..<60.0 || seconds !in 0.0..<60.0) return null
         return (hours * 3600 + minutes * 60 + seconds).coerceIn(0.0, maxCountdownSeconds.toDouble()).roundToInt()
     }
 }
@@ -2088,26 +2392,33 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
     private var shouldLoop = false
     private var shouldPlay = false
     private var muted = false
+    private var resizeMode = "contain"
+    private var preparedPlayer: MediaPlayer? = null
 
-    fun configure(source: Any?, autoplay: Boolean, paused: Boolean, loop: Boolean, muted: Boolean, controls: Boolean) {
+    fun configure(source: Any?, autoplay: Boolean, paused: Boolean, loop: Boolean, muted: Boolean, controls: Boolean, resizeMode: String?) {
         val uri = when (source) {
             is String -> source
-            is JSONObject -> source.optString("uri")
+            is JSONObject -> craftNativeOptionalString(source.opt("uri")).orEmpty()
             else -> ""
         }
         shouldLoop = loop
         shouldPlay = autoplay && !paused
         this.muted = muted
+        this.resizeMode = resizeMode?.lowercase()?.takeIf { it in setOf("cover", "contain", "stretch", "center") } ?: "contain"
+        applyScalingMode()
         setMediaController(if (controls) MediaController(context).also { it.setAnchorView(this) } else null)
         if (uri != sourceUri) {
             sourceUri = uri
             stopPlayback()
+            preparedPlayer = null
             if (uri.isBlank()) return
             // A copy kept on the phone (craft.media.keep) plays in place of
             // the address: offline in a gym with no signal.
             val kept = CraftNativeMedia.local(context, uri)
             setVideoURI(if (kept != null) Uri.fromFile(kept) else Uri.parse(uri))
             setOnPreparedListener { mediaPlayer ->
+                preparedPlayer = mediaPlayer
+                applyScalingMode()
                 mediaPlayer.isLooping = shouldLoop
                 val volume = if (this.muted) 0f else 1f
                 mediaPlayer.setVolume(volume, volume)
@@ -2125,12 +2436,27 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
     fun stop() {
         stopPlayback()
         sourceUri = ""
+        preparedPlayer = null
+    }
+
+    private fun applyScalingMode() {
+        preparedPlayer?.setVideoScalingMode(
+            if (resizeMode == "cover") MediaPlayer.VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING
+            else MediaPlayer.VIDEO_SCALING_MODE_SCALE_TO_FIT,
+        )
     }
 }
 
-/** The oscillator/gain subset of Web Audio used by native STX screens. */
+/**
+ * The native-screen Web Audio graph. Android renders the same useful graph
+ * shape as iOS: oscillators and buffer sources can pass through gain, filter,
+ * delay, compressor, and convolver nodes before reaching the destination.
+ * Effects deliberately remain conservative in this first Android renderer;
+ * the graph and its timing are native, while the existing WebView remains the
+ * fallback for unsupported media decoding.
+ */
 private class CraftNativeAudio {
-    private data class ParameterEvent(val time: Double, val value: Double, val ramp: Boolean)
+    private data class ParameterEvent(val time: Double, val value: Double, val mode: String)
 
     private class Parameter(initial: Double) {
         private var current = initial
@@ -2141,8 +2467,8 @@ private class CraftNativeAudio {
             events.clear()
         }
 
-        @Synchronized fun schedule(value: Double, time: Double, ramp: Boolean) {
-            events += ParameterEvent(time.coerceAtLeast(0.0), value, ramp)
+        @Synchronized fun schedule(value: Double, time: Double, mode: String) {
+            events += ParameterEvent(time.coerceAtLeast(0.0), value, mode)
             events.sortBy { it.time }
         }
 
@@ -2151,9 +2477,20 @@ private class CraftNativeAudio {
             var previousValue = current
             for (event in events) {
                 if (time < event.time) {
-                    if (!event.ramp || event.time <= previousTime) return previousValue
+                    if (event.time <= previousTime) return previousValue
                     val fraction = (time - previousTime) / (event.time - previousTime)
-                    return previousValue + (event.value - previousValue) * fraction
+                    return when (event.mode) {
+                        "exponential" -> {
+                            val start = previousValue.takeIf { it > 0 } ?: 0.000001
+                            val end = event.value.takeIf { it > 0 } ?: 0.000001
+                            start * (end / start).pow(fraction)
+                        }
+                        "target" -> {
+                            previousValue + (event.value - previousValue) * (1 - exp(-fraction * 5))
+                        }
+                        "linear" -> previousValue + (event.value - previousValue) * fraction
+                        else -> previousValue
+                    }
                 }
                 previousTime = event.time
                 previousValue = event.value
@@ -2162,73 +2499,182 @@ private class CraftNativeAudio {
         }
     }
 
-    private class OscillatorState {
+    private class NodeState(
+        val contextId: String,
+        val id: String,
+        val kind: String,
+    ) {
         val frequency = Parameter(440.0)
-        @Volatile var gain = Parameter(1.0)
-        @Volatile var phase = 0.0
-        @Volatile var active = false
-        var contextStart = 0.0
-    }
+        val detune = Parameter(0.0)
+        val gain = Parameter(1.0)
+        val playbackRate = Parameter(1.0)
+        var waveform = 0
+        var bufferId: String? = null
+        var bufferLoop = false
+        var loopStart = 0.0
+        var loopEnd = 0.0
+        var startOffset = 0.0
+        var startAt = Double.POSITIVE_INFINITY
+        var stopAt = Double.POSITIVE_INFINITY
+    }
+
+    private data class BufferSpec(
+        val length: Int,
+        val sampleRate: Double,
+        val channels: List<FloatArray> = emptyList(),
+    )
 
-    private val handler = Handler(Looper.getMainLooper())
-    private val oscillators = mutableMapOf<String, OscillatorState>()
-    private val gains = mutableMapOf<String, Parameter>()
+    private val nodes = mutableMapOf<String, NodeState>()
+    private val inputs = mutableMapOf<String, MutableSet<String>>()
+    private val buffers = mutableMapOf<String, BufferSpec>()
     private val contextStarts = mutableMapOf<String, Double>()
+    private val suspended = mutableSetOf<String>()
     private var track: AudioTrack? = null
     @Volatile private var running = false
     private var renderThread: Thread? = null
 
+    private fun key(contextId: String, nodeId: String): String = "$contextId:$nodeId"
+
+    private fun node(contextId: String, nodeId: String): NodeState? = nodes[key(contextId, nodeId)]
+
     @Synchronized fun handle(payload: JSONObject) {
+        val contextId = payload.optString("contextId")
         when (payload.optString("action")) {
             "createContext" -> {
-                payload.optString("contextId").takeIf { it.isNotBlank() }?.let {
+                contextId.takeIf { it.isNotBlank() }?.let {
                     contextStarts[it] = System.nanoTime() / 1_000_000_000.0
+                    suspended.remove(it)
                 }
             }
-            "createOscillator" -> {
+            "createOscillator", "createGain", "createBufferSource", "createBiquadFilter",
+            "createDelay", "createDynamicsCompressor", "createConvolver" -> {
                 val id = payload.optString("nodeId")
-                if (id.isNotBlank()) oscillators.putIfAbsent(id, OscillatorState()).also {
-                    oscillators[id]?.contextStart = contextStarts[payload.optString("contextId")]
-                        ?: (System.nanoTime() / 1_000_000_000.0)
-                    oscillators[id]?.frequency?.set(payload.optDouble("frequency", 440.0).coerceAtLeast(0.0))
+                if (contextId.isBlank() || id.isBlank()) return
+                val state = NodeState(contextId, id, payload.optString("action").removePrefix("create"))
+                state.frequency.set(payload.optDouble("frequency", 440.0).coerceAtLeast(0.0))
+                state.gain.set(payload.optDouble("gain", 1.0).coerceAtLeast(0.0))
+                nodes[key(contextId, id)] = state
+            }
+            "createBuffer" -> {
+                val id = payload.optString("bufferId")
+                if (id.isNotBlank()) {
+                    val length = payload.optInt("length", 1).coerceAtLeast(1)
+                    val channelCount = payload.optInt("channels", 1).coerceIn(1, 2)
+                    buffers[id] = BufferSpec(
+                        length,
+                        payload.optDouble("sampleRate", 44_100.0).coerceAtLeast(3_000.0),
+                        List(channelCount) { FloatArray(length) },
+                    )
                 }
             }
-            "createGain" -> {
-                val id = payload.optString("nodeId")
-                if (id.isNotBlank()) gains[id] = Parameter(payload.optDouble("gain", 1.0).coerceAtLeast(0.0))
+            "bufferData" -> {
+                val id = payload.optString("bufferId")
+                val existing = buffers[id] ?: return
+                val rawChannels = payload.optJSONArray("channels") ?: return
+                val channels = (0 until min(existing.channels.size, rawChannels.length())).map { channelIndex ->
+                    val raw = rawChannels.optJSONArray(channelIndex)
+                    FloatArray(existing.length) { sampleIndex ->
+                        val value = raw?.optDouble(sampleIndex, 0.0) ?: 0.0
+                        value.takeIf { it.isFinite() }?.toFloat()?.coerceIn(-1f, 1f) ?: 0f
+                    }
+                }
+                buffers[id] = existing.copy(channels = channels)
             }
             "connect" -> {
                 val source = payload.optString("sourceId")
-                oscillators[source]?.gain = gains[payload.optString("destinationId")] ?: Parameter(1.0)
+                val destination = payload.optString("destinationId", "destination")
+                if (contextId.isNotBlank() && source.isNotBlank()) {
+                    inputs.getOrPut(key(contextId, destination)) { mutableSetOf() }.add(key(contextId, source))
+                }
             }
-            "frequency" -> oscillators[payload.optString("nodeId")]?.frequency?.set(payload.optDouble("value", 0.0).coerceAtLeast(0.0))
-            "frequencyAtTime", "frequencyRampToTime" -> oscillators[payload.optString("nodeId")]?.frequency?.schedule(
-                payload.optDouble("value", 0.0).coerceAtLeast(0.0),
-                payload.optDouble("time", 0.0),
-                payload.optString("action") == "frequencyRampToTime",
-            )
-            "gain" -> gains[payload.optString("nodeId")]?.set(payload.optDouble("value", 0.0).coerceAtLeast(0.0))
-            "gainAtTime", "gainRampToTime" -> gains[payload.optString("nodeId")]?.schedule(
-                payload.optDouble("value", 0.0).coerceAtLeast(0.0),
-                payload.optDouble("time", 0.0),
-                payload.optString("action") == "gainRampToTime",
-            )
-            "start", "stop" -> {
-                val state = oscillators[payload.optString("nodeId")] ?: return
+            "connectParam" -> {
+                // Parameter modulation is accepted by the protocol. The
+                // Android renderer keeps the target's scheduled value stable
+                // rather than dropping the graph connection or throwing.
+            }
+            "type" -> node(contextId, payload.optString("nodeId"))?.waveform = payload.optInt("value", 0)
+            "buffer" -> node(contextId, payload.optString("nodeId"))?.bufferId = payload.optString("bufferId").takeIf { it.isNotBlank() }
+            "loop" -> node(contextId, payload.optString("nodeId"))?.let {
+                it.bufferLoop = payload.optBoolean("loop", false)
+                it.loopStart = payload.optDouble("loopStart", 0.0).coerceAtLeast(0.0)
+                it.loopEnd = payload.optDouble("loopEnd", 0.0).coerceAtLeast(0.0)
+            }
+            "frequency", "gain", "detune", "playbackRate" -> {
+                val state = node(contextId, payload.optString("nodeId")) ?: return
+                parameter(state, payload.optString("action"))?.set(payload.optDouble("value", 0.0))
+            }
+            "frequencyAtTime", "frequencyRampToTime", "frequencyExponentialRampToTime",
+            "gainAtTime", "gainRampToTime", "gainExponentialRampToTime",
+            "detuneAtTime", "detuneRampToTime", "detuneExponentialRampToTime",
+            "playbackRateAtTime", "playbackRateRampToTime", "playbackRateExponentialRampToTime",
+            "gainTargetAtTime" -> {
+                val state = node(contextId, payload.optString("nodeId")) ?: return
+                val action = payload.optString("action")
+                val parameterName = when {
+                    action.contains("TargetAtTime") -> action.substringBefore("TargetAtTime")
+                    action.contains("ExponentialRampToTime") -> action.substringBefore("ExponentialRampToTime")
+                    action.contains("RampToTime") -> action.substringBefore("RampToTime")
+                    else -> action.substringBefore("AtTime")
+                }
+                parameter(state, parameterName)?.schedule(
+                    payload.optDouble("value", 0.0), payload.optDouble("time", 0.0),
+                    when {
+                        action.contains("Exponential") -> "exponential"
+                        action.contains("Target") -> "target"
+                        action.contains("Ramp") -> "linear"
+                        else -> "set"
+                    },
+                )
+            }
+            "start" -> {
+                val state = node(contextId, payload.optString("nodeId")) ?: return
                 ensureTrack()
-                val active = payload.optString("action") == "start"
-                val delay = (payload.optDouble("delay", 0.0).coerceAtLeast(0.0) * 1000).roundToLong()
-                handler.postDelayed({ state.active = active }, delay)
+                val now = contextTime(contextId)
+                state.startAt = now + payload.optDouble("delay", 0.0).coerceAtLeast(0.0)
+                state.startOffset = payload.optDouble("offset", 0.0).coerceAtLeast(0.0)
+                val duration = payload.optDouble("duration", -1.0)
+                if (duration > 0) state.stopAt = state.startAt + duration
+            }
+            "stop" -> {
+                val state = node(contextId, payload.optString("nodeId")) ?: return
+                state.stopAt = contextTime(contextId) + payload.optDouble("delay", 0.0).coerceAtLeast(0.0)
+            }
+            "state" -> when (payload.optString("state")) {
+                "suspended" -> suspended.add(contextId)
+                "running" -> suspended.remove(contextId)
+                "closed" -> closeContext(contextId)
             }
             "close" -> close()
         }
     }
 
+    private fun parameter(state: NodeState, name: String): Parameter? = when (name) {
+        "frequency" -> state.frequency
+        "gain" -> state.gain
+        "detune" -> state.detune
+        "playbackRate" -> state.playbackRate
+        else -> null
+    }
+
+    private fun contextTime(contextId: String): Double {
+        return (System.nanoTime() / 1_000_000_000.0) - (contextStarts[contextId] ?: return 0.0)
+    }
+
+    private fun closeContext(contextId: String) {
+        val prefix = "$contextId:"
+        nodes.keys.removeAll { it.startsWith(prefix) }
+        inputs.keys.removeAll { it.startsWith(prefix) }
+        inputs.values.forEach { it.removeAll { source -> source.startsWith(prefix) } }
+        contextStarts.remove(contextId)
+        suspended.remove(contextId)
+    }
+
     @Synchronized fun close() {
-        oscillators.values.forEach { it.active = false }
-        oscillators.clear()
-        gains.clear()
+        nodes.clear()
+        inputs.clear()
+        buffers.clear()
         contextStarts.clear()
+        suspended.clear()
         running = false
         renderThread?.interrupt()
         renderThread = null
@@ -2269,31 +2715,66 @@ private class CraftNativeAudio {
 
     private fun render(output: AudioTrack, sampleRate: Int) {
         val buffer = ShortArray(1024 * 2)
+        val stereo = DoubleArray(2)
         while (running && !Thread.currentThread().isInterrupted) {
-            val snapshot = synchronized(this) {
-                oscillators.mapValues { (id, state) ->
-                    Triple(state, state.gain, state.active)
-                }
-            }
-            val now = System.nanoTime() / 1_000_000_000.0
             for (frame in 0 until 1024) {
-                var sample = 0.0
-                snapshot.forEach { (_, value) ->
-                    val (state, gain, active) = value
-                    if (!active) return@forEach
-                    val time = (now - state.contextStart).coerceAtLeast(0.0) + frame.toDouble() / sampleRate
-                    val frequency = state.frequency.valueAt(time)
-                    sample += sin(state.phase) * gain.valueAt(time)
-                    state.phase += 2 * PI * frequency / sampleRate
-                    if (state.phase >= 2 * PI) state.phase -= 2 * PI
+                synchronized(this) {
+                    stereo[0] = contextStarts.keys.sumOf { contextId ->
+                        if (contextId in suspended) 0.0
+                        else renderNode(key(contextId, "destination"), contextTime(contextId) + frame.toDouble() / sampleRate, 0, mutableSetOf())
+                    }
+                    stereo[1] = contextStarts.keys.sumOf { contextId ->
+                        if (contextId in suspended) 0.0
+                        else renderNode(key(contextId, "destination"), contextTime(contextId) + frame.toDouble() / sampleRate, 1, mutableSetOf())
+                    }
                 }
-                val value = (sample.coerceIn(-1.0, 1.0) * Short.MAX_VALUE).toInt().toShort()
-                buffer[frame * 2] = value
-                buffer[frame * 2 + 1] = value
+                buffer[frame * 2] = (stereo[0].coerceIn(-1.0, 1.0) * Short.MAX_VALUE).toInt().toShort()
+                buffer[frame * 2 + 1] = (stereo[1].coerceIn(-1.0, 1.0) * Short.MAX_VALUE).toInt().toShort()
             }
             if (output.write(buffer, 0, buffer.size, AudioTrack.WRITE_BLOCKING) < 0) break
         }
     }
+
+    private fun renderNode(nodeKey: String, time: Double, channel: Int, visited: MutableSet<String>): Double {
+        if (!visited.add(nodeKey)) return 0.0
+        val state = nodes[nodeKey]
+        var value = 0.0
+        if (state == null || state.kind == "destination" || state.kind == "Gain" || state.kind == "BiquadFilter" || state.kind == "Delay" || state.kind == "DynamicsCompressor" || state.kind == "Convolver") {
+            for (source in inputs[nodeKey].orEmpty()) value += renderNode(source, time, channel, visited)
+        } else if (state.kind == "Oscillator") {
+            if (time >= state.startAt && time < state.stopAt) {
+                val elapsed = (time - state.startAt).coerceAtLeast(0.0)
+                val frequency = (state.frequency.valueAt(time) * 2.0.pow(state.detune.valueAt(time) / 1200.0)).coerceAtLeast(0.0)
+                val phase = (elapsed * frequency) % 1.0
+                value = when (state.waveform) {
+                    1 -> if (phase < 0.5) 1.0 else -1.0
+                    2 -> 2.0 * phase - 1.0
+                    3 -> 1.0 - 4.0 * kotlin.math.abs(phase - 0.5)
+                    else -> sin(phase * 2.0 * PI)
+                }
+            }
+        } else if (state.kind == "BufferSource") {
+            val buffer = state.bufferId?.let(buffers::get)
+            if (buffer != null && time >= state.startAt && time < state.stopAt) {
+                val elapsed = (time - state.startAt) * state.playbackRate.valueAt(time).coerceAtLeast(0.01)
+                val length = buffer.length.toDouble() / buffer.sampleRate
+                val loopEnd = if (state.loopEnd > state.loopStart) state.loopEnd else length
+                val position = if (state.bufferLoop && loopEnd > state.loopStart) {
+                    state.loopStart + ((elapsed + state.startOffset - state.loopStart) % (loopEnd - state.loopStart))
+                } else elapsed + state.startOffset
+                if (state.bufferLoop || position < length) {
+                    val sampleIndex = (position * buffer.sampleRate).toLong().coerceAtLeast(0)
+                    value = (buffer.channels.getOrNull(channel) ?: buffer.channels.firstOrNull())
+                        ?.getOrNull(sampleIndex.toInt())
+                        ?.toDouble()
+                        ?: 0.0
+                }
+            }
+        }
+        if (state?.kind == "Gain") value *= state.gain.valueAt(time).coerceAtLeast(0.0)
+        visited.remove(nodeKey)
+        return value
+    }
 }
 
 private class CraftTextDecorationSpan(
@@ -2576,6 +3057,16 @@ class MainActivity : AppCompatActivity() {
         }.getOrDefault(JSONObject())
         hapticsEnabled = config.optBoolean("enableHaptics", false)
         clipboardEnabled = config.optBoolean("enableClipboard", false)
+        // Normally started already by its content provider; this covers a
+        // process that skipped providers (instrumentation).
+        CraftCrashReporter.start(this)
+        if (BuildConfig.DEBUG && savedInstanceState == null) {
+            CraftCrashReporter.debugCrashTestRequested(intent?.getStringExtra("craftCrashTest")) { message ->
+                appScreen?.takeIf { it.active }?.let { app ->
+                    reportJavaScriptFailure(app, app.isolate.evaluateJavaScriptAsync("(function crashReporterTest() { throw new TypeError(${JSONObject.quote(message)}); })()"))
+                }
+            }
+        }
         capabilities = CraftNativeCapabilities(this, config)
         routes = CraftNativeRoutes(config)
         stores = CraftNativeStores.get(this, config)
@@ -2904,18 +3395,36 @@ class MainActivity : AppCompatActivity() {
                       audioMessage({ action: action, contextId: contextId, nodeId: nodeId, value: current });
                     }
                   });
-                  function schedule(value, when, ramp) {
+                  param._paramOwner = nodeId;
+                  param._paramName = action;
+                  function schedule(value, when, suffix) {
                     current = Number(value) || 0;
                     var time = Number(when);
-                    audioMessage({ action: action + (ramp ? 'RampToTime' : 'AtTime'), contextId: contextId, nodeId: nodeId, value: current, time: isFinite(time) ? Math.max(0, time) : 0 });
+                    audioMessage({ action: action + suffix, contextId: contextId, nodeId: nodeId, value: current, time: isFinite(time) ? Math.max(0, time) : 0 });
                   }
-                  param.setValueAtTime = function(value, when) { schedule(value, when, false); return param; };
-                  param.linearRampToValueAtTime = function(value, when) { schedule(value, when, true); return param; };
+                  param.setValueAtTime = function(value, when) { schedule(value, when, 'AtTime'); return param; };
+                  param.linearRampToValueAtTime = function(value, when) { schedule(value, when, 'RampToTime'); return param; };
+                  param.exponentialRampToValueAtTime = function(value, when) { schedule(value, when, 'ExponentialRampToTime'); return param; };
+                  param.setTargetAtTime = function(value, when) { schedule(value, when, 'TargetAtTime'); return param; };
                   return param;
                 }
+                function makeNode(context, kind) {
+                  var value = { _contextId: context._id, _nodeId: context._id + '-' + kind + '-' + (++nextAudioId) };
+                  value.connect = function(destination) {
+                    if (destination && destination._paramOwner) {
+                      audioMessage({ action: 'connectParam', contextId: context._id, sourceId: value._nodeId, destinationId: destination._paramOwner, parameter: destination._paramName || '' });
+                    } else {
+                      audioMessage({ action: 'connect', contextId: context._id, sourceId: value._nodeId, destinationId: destination && destination._nodeId || 'destination' });
+                    }
+                    return destination;
+                  };
+                  audioMessage({ action: 'create' + kind, contextId: context._id, nodeId: value._nodeId });
+                  return value;
+                }
                 function AudioContext() {
                   this._id = 'audio-' + (++nextAudioId);
                   this._started = Date.now() / 1000;
+                  this.sampleRate = 44100;
                   this.state = 'running';
                   this.destination = { _contextId: this._id, _nodeId: 'destination' };
                   audioMessage({ action: 'createContext', contextId: this._id });
@@ -2925,37 +3434,101 @@ class MainActivity : AppCompatActivity() {
                 });
                 AudioContext.prototype.createOscillator = function() {
                   var context = this;
-                  var node = { _contextId: context._id, _nodeId: context._id + '-osc-' + (++nextAudioId) };
+                  var node = makeNode(context, 'Oscillator');
                   node.frequency = audioParam(context._id, node._nodeId, 'frequency', 440);
-                  node.connect = function(destination) {
-                    audioMessage({ action: 'connect', contextId: context._id, sourceId: node._nodeId, destinationId: destination && destination._nodeId || 'destination' });
-                    return destination;
-                  };
                   node.start = function(when) {
                     audioMessage({ action: 'start', contextId: context._id, nodeId: node._nodeId, delay: Math.max(0, (Number(when) || 0) - context.currentTime) });
                   };
                   node.stop = function(when) {
                     audioMessage({ action: 'stop', contextId: context._id, nodeId: node._nodeId, delay: Math.max(0, (Number(when) || 0) - context.currentTime) });
                   };
-                  audioMessage({ action: 'createOscillator', contextId: context._id, nodeId: node._nodeId, frequency: node.frequency.value });
+                  audioMessage({ action: 'frequency', contextId: context._id, nodeId: node._nodeId, value: node.frequency.value });
                   return node;
                 };
                 AudioContext.prototype.createGain = function() {
                   var context = this;
-                  var node = { _contextId: context._id, _nodeId: context._id + '-gain-' + (++nextAudioId) };
+                  var node = makeNode(context, 'Gain');
                   node.gain = audioParam(context._id, node._nodeId, 'gain', 1);
-                  node.connect = function(destination) {
-                    audioMessage({ action: 'connect', contextId: context._id, sourceId: node._nodeId, destinationId: destination && destination._nodeId || 'destination' });
-                    return destination;
-                  };
-                  audioMessage({ action: 'createGain', contextId: context._id, nodeId: node._nodeId, gain: node.gain.value });
+                  audioMessage({ action: 'gain', contextId: context._id, nodeId: node._nodeId, value: node.gain.value });
                   return node;
                 };
-                AudioContext.prototype.resume = function() { this.state = 'running'; return Promise.resolve(); };
-                AudioContext.prototype.suspend = function() { this.state = 'suspended'; return Promise.resolve(); };
-                AudioContext.prototype.close = function() { this.state = 'closed'; audioMessage({ action: 'close', contextId: this._id }); return Promise.resolve(); };
+                AudioContext.prototype.createBuffer = function(channels, length, sampleRate) {
+                  var buffer = { _id: 'buffer-' + (++nextAudioId), numberOfChannels: channels, length: length, sampleRate: sampleRate, duration: length / sampleRate, _channels: [] };
+                  for (var index = 0; index < channels; index++) buffer._channels.push(new Float32Array(length));
+                  buffer.getChannelData = function(channel) { return buffer._channels[channel]; };
+                  audioMessage({ action: 'createBuffer', contextId: this._id, bufferId: buffer._id, channels: channels, length: length, sampleRate: sampleRate });
+                  return buffer;
+                };
+                function uploadBuffer(contextId, buffer) {
+                  var channels = [];
+                  for (var index = 0; index < buffer._channels.length; index++) {
+                    var source = buffer._channels[index];
+                    var values = [];
+                    for (var sample = 0; sample < source.length; sample++) values.push(Number(source[sample]) || 0);
+                    channels.push(values);
+                  }
+                  audioMessage({ action: 'bufferData', contextId: contextId, bufferId: buffer._id, channels: channels });
+                }
+                AudioContext.prototype.createBufferSource = function() {
+                  var context = this;
+                  var value = makeNode(context, 'BufferSource');
+                  value.playbackRate = audioParam(context._id, value._nodeId, 'playbackRate', 1);
+                  value.detune = audioParam(context._id, value._nodeId, 'detune', 0);
+                  value.buffer = null;
+                  value.loop = false;
+                  value.loopStart = 0;
+                  value.loopEnd = 0;
+                  value.start = function(when, offset, duration) {
+                    if (value.buffer) {
+                      uploadBuffer(context._id, value.buffer);
+                      audioMessage({ action: 'buffer', contextId: context._id, nodeId: value._nodeId, bufferId: value.buffer._id });
+                    }
+                    audioMessage({ action: 'loop', contextId: context._id, nodeId: value._nodeId, loop: value.loop, loopStart: value.loopStart, loopEnd: value.loopEnd });
+                    audioMessage({ action: 'start', contextId: context._id, nodeId: value._nodeId, delay: Math.max(0, (Number(when) || 0) - context.currentTime), offset: Number(offset) || 0, duration: Number(duration) || -1 });
+                  };
+                  value.stop = function(when) { audioMessage({ action: 'stop', contextId: context._id, nodeId: value._nodeId, delay: Math.max(0, (Number(when) || 0) - context.currentTime) }); };
+                  return value;
+                };
+                AudioContext.prototype.createBiquadFilter = function() {
+                  var context = this;
+                  var value = makeNode(context, 'BiquadFilter');
+                  value.frequency = audioParam(context._id, value._nodeId, 'frequency', 350);
+                  value.Q = audioParam(context._id, value._nodeId, 'Q', 1);
+                  value.gain = audioParam(context._id, value._nodeId, 'gain', 0);
+                  value.type = 'lowpass';
+                  return value;
+                };
+                AudioContext.prototype.createDelay = function() {
+                  var context = this;
+                  var value = makeNode(context, 'Delay');
+                  value.delayTime = audioParam(context._id, value._nodeId, 'delayTime', 0);
+                  return value;
+                };
+                AudioContext.prototype.createDynamicsCompressor = function() {
+                  var context = this;
+                  var value = makeNode(context, 'DynamicsCompressor');
+                  value.threshold = audioParam(context._id, value._nodeId, 'threshold', -24);
+                  value.knee = audioParam(context._id, value._nodeId, 'knee', 30);
+                  value.ratio = audioParam(context._id, value._nodeId, 'ratio', 12);
+                  value.attack = audioParam(context._id, value._nodeId, 'attack', 0.003);
+                  value.release = audioParam(context._id, value._nodeId, 'release', 0.25);
+                  value.reduction = 0;
+                  return value;
+                };
+                AudioContext.prototype.createConvolver = function() {
+                  var context = this;
+                  var value = makeNode(context, 'Convolver');
+                  value.normalize = true;
+                  value.buffer = null;
+                  return value;
+                };
+                AudioContext.prototype.resume = function() { this.state = 'running'; audioMessage({ action: 'state', contextId: this._id, state: this.state }); return Promise.resolve(); };
+                AudioContext.prototype.suspend = function() { this.state = 'suspended'; audioMessage({ action: 'state', contextId: this._id, state: this.state }); return Promise.resolve(); };
+                AudioContext.prototype.close = function() { this.state = 'closed'; audioMessage({ action: 'state', contextId: this._id, state: this.state }); audioMessage({ action: 'close', contextId: this._id }); return Promise.resolve(); };
                 globalThis.AudioContext = AudioContext;
                 globalThis.webkitAudioContext = AudioContext;
+                globalThis.BaseAudioContext = AudioContext;
+                globalThis.AudioBuffer = function() {};
               }
             })()
         """.trimIndent()
@@ -3029,6 +3602,7 @@ class MainActivity : AppCompatActivity() {
                         }
                     } catch (error: Exception) {
                         Log.e(TAG, "Native STX bundle failed", error)
+                        reportJavaScriptError(activeScreen, error)
                         if (activeScreen.active) showError("Native STX bundle failed: ${error.message}")
                     }
                 }, executor)
@@ -3046,6 +3620,8 @@ class MainActivity : AppCompatActivity() {
      * screen shown before hears true (its `navigation.onAppear`).
      */
     private fun show(screen: Screen) {
+        // A navigation breadcrumb: the trail a crash report carries.
+        if (visibleScreen !== screen) CraftCrashReporter.screenAppeared(screen.route ?: "home")
         val bars = chrome
         val host: ViewGroup = bars?.content ?: root
         host.removeAllViews()
@@ -3258,8 +3834,13 @@ class MainActivity : AppCompatActivity() {
             }
             "NAVIGATE_OPEN" -> payload.optString("path").takeIf { it.isNotBlank() }?.let(::navigateOpen)
             "NAVIGATION_SET_OPTIONS" -> {
-                payload.keys().forEach { key -> screen.options.put(key, payload.opt(key)) }
-                if (visibleScreen === screen) applyChrome(screen)
+                // The app script has no navigation bar of its own. Screen
+                // options remain valid while that screen is off-stack, so
+                // only reject the headless app isolate here.
+                if (screen !== appScreen) {
+                    payload.keys().forEach { key -> screen.options.put(key, payload.opt(key)) }
+                    if (visibleScreen === screen) applyChrome(screen)
+                }
             }
             "SYNC_WRITE" -> syncWrite(screen, payload)
             "TIMER" -> {
@@ -3275,15 +3856,20 @@ class MainActivity : AppCompatActivity() {
             "TIMER_CLEAR" -> screen.timers.remove(payload.optInt("id"))?.let(capabilityHandler::removeCallbacks)
             "FRAME" -> requestFrame(screen)
             "NAVIGATE", "NAVIGATE_REPLACE" -> {
-                if (screens.lastOrNull() !== screen && screen !== appScreen) return
+                // Navigation belongs to the route that is actually visible.
+                // The stack list can be temporarily detached while a tab or
+                // back transition restores its root; using its last entry
+                // silently drops a valid push from that visible screen. The
+                // app script has no stack of its own; it uses NAVIGATE_OPEN.
+                if (visibleScreen !== screen) return
                 val route = payload.optString("screen").takeIf { it.isNotBlank() } ?: return
                 if (message.optString("type") == "NAVIGATE_REPLACE") {
                     closeScreen(screens.removeAt(screens.lastIndex))
                 }
                 openScreen(route, payload.optJSONObject("params") ?: JSONObject())
             }
-            "NAVIGATE_BACK" -> if (screens.lastOrNull() === screen || screen === appScreen) back()
-            "NAVIGATE_POP_TO_ROOT" -> if (screens.lastOrNull() === screen || screen === appScreen) popToRoot()
+            "NAVIGATE_BACK" -> if (visibleScreen === screen) back()
+            "NAVIGATE_POP_TO_ROOT" -> if (visibleScreen === screen) popToRoot()
             "API_REQUEST" -> answerAPI(screen, message, payload)
             "API_CANCEL" -> {
                 val id = payload.optString("requestId")
@@ -3324,7 +3910,7 @@ class MainActivity : AppCompatActivity() {
     private fun applyTargetedUpdates(screen: Screen, ids: List<String>): Boolean {
         val applied = mutableSetOf<String>()
         for (id in ids) {
-            val target = screen.flatListOwners[id] ?: id
+            val target = drawnTarget(screen, id) ?: return false
             if (!applied.add(target)) continue
             val document = screen.mutations.node(target) ?: return false
             val path = screen.nodePaths[target] ?: return false
@@ -3340,6 +3926,17 @@ class MainActivity : AppCompatActivity() {
         return true
     }
 
+    /** Find the nearest rendered ancestor for protocol nodes with no view. */
+    private fun drawnTarget(screen: Screen, id: String): String? {
+        var current: String? = id
+        while (current != null) {
+            val target = screen.flatListOwners[current] ?: current
+            if (screen.nodeViews[target] != null) return target
+            current = screen.mutations.parentId(current)
+        }
+        return null
+    }
+
     private fun scheduleLayoutEvents(screen: Screen) {
         if (!screen.active) return
         val observer = screen.view.viewTreeObserver
@@ -3478,8 +4075,8 @@ class MainActivity : AppCompatActivity() {
                 configureText(this, childText(children), style)
             }
             "StatusBar" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
-                screen.statusBarStyle = props.optString("barStyle").takeIf { it.isNotBlank() }
-                screen.statusBarHidden = if (props.has("hidden")) props.optBoolean("hidden") else null
+                screen.statusBarStyle = craftNativeOptionalString(props.opt("barStyle"))
+                screen.statusBarHidden = if (props.has("hidden") && !props.isNull("hidden")) props.optBoolean("hidden") else null
                 visibility = View.GONE
             }
             "RefreshControl" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
@@ -3487,19 +4084,19 @@ class MainActivity : AppCompatActivity() {
             }
             "Link" -> ((previous as? TextView)?.takeUnless { it is Button } ?: TextView(this)).apply {
                 includeFontPadding = false
-                configureText(this, props.optString("title").ifBlank { childText(children) }, style)
-                val linkColor = props.optString("color").takeIf { it.isNotBlank() } ?: style.optString("color")
+                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)))
                 paintFlags = paintFlags or Paint.UNDERLINE_TEXT_FLAG
                 isEnabled = !props.optBoolean("disabled", false)
                 isClickable = true
                 isFocusable = true
-                val target = listOf(props.optString("href"), props.optString("to"))
-                    .firstOrNull { it.isNotBlank() }
+                val target = listOf(props.opt("href"), props.opt("to"))
+                    .firstNotNullOfOrNull(::craftNativeOptionalString)
                     ?.trim()
                     ?.takeIf { !props.optBoolean("disabled", false) }
                 if (target != null) screen.linkTargets[this] = target else screen.linkTargets.remove(this)
-                val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
+                val handler = craftNativeEventName(events, "onPress", "onClick")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 setOnClickListener {
                     screen.linkTargets[it]?.let { target -> navigateOpen(target); return@setOnClickListener }
@@ -3518,12 +4115,12 @@ class MainActivity : AppCompatActivity() {
                 minimumHeight = 0
                 setPadding(0, 0, 0, 0)
             }).apply {
-                val title = props.optString("title").ifBlank { childText(children) }
+                val title = craftNativeOptionalString(props.opt("title")) ?: childText(children)
                 isAllCaps = false
                 configureText(this, title, style)
-                props.optString("color").takeIf { it.isNotBlank() }?.let { setTextColor(color(it, defaultTextColor)) }
+                craftNativeOptionalString(props.opt("color"))?.let { setTextColor(color(it, defaultTextColor)) }
                 isEnabled = !props.optBoolean("disabled", false)
-                val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
+                val handler = craftNativeEventName(events, "onPress", "onClick")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 setOnClickListener {
                     val current = screen.handlers[this] ?: return@setOnClickListener
@@ -3531,7 +4128,7 @@ class MainActivity : AppCompatActivity() {
                 }
             }
             "Checkbox" -> (previous as? CheckBox ?: CheckBox(this)).apply {
-                text = props.optString("label").ifBlank { childText(children) }
+                text = craftNativeOptionalString(props.opt("label")) ?: childText(children)
                 configureText(this, text.toString(), style)
                 val requested = props.opt("checked") ?: props.opt("value")
                 val checked = when (requested) {
@@ -3547,8 +4144,10 @@ class MainActivity : AppCompatActivity() {
                 isChecked = checked
                 isActivated = props.optBoolean("indeterminate", false)
                 isEnabled = !props.optBoolean("disabled", false)
-                props.optString("color").takeIf { it.isNotBlank() }?.let { buttonTintList = ColorStateList.valueOf(color(it, defaultTextColor)) }
-                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                val checkboxColor = craftNativeOptionalString(props.opt("color"))
+                    ?: craftNativeOptionalString(style.opt("color"))
+                buttonTintList = checkboxColor?.let { ColorStateList.valueOf(color(it, defaultTextColor)) }
+                val handler = craftNativeEventName(events, "onValueChange", "onChange")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 setOnCheckedChangeListener { _, value ->
                     screen.handlers[this]?.let { current ->
@@ -3569,13 +4168,13 @@ class MainActivity : AppCompatActivity() {
                     hintTextColors ?: ColorStateList.valueOf(Color.GRAY)
                 }
                 val defaultHighlightColor = inputHighlightDefaults.getOrPut(this) { highlightColor }
-                hint = props.optString("placeholder")
+                hint = craftNativeOptionalString(props.opt("placeholder")).orEmpty()
                 setHintTextColor(
-                    props.optString("placeholderTextColor").takeIf { it.isNotBlank() }
+                    craftNativeOptionalString(props.opt("placeholderTextColor"))
                         ?.let { ColorStateList.valueOf(color(it, Color.GRAY)) }
                         ?: defaultHintColors,
                 )
-                highlightColor = props.optString("selectionColor").takeIf { it.isNotBlank() }
+                highlightColor = craftNativeOptionalString(props.opt("selectionColor"))
                     ?.let { color(it, defaultHighlightColor) }
                     ?: defaultHighlightColor
                 val maxLength = props.optInt("maxLength", 0)
@@ -3597,14 +4196,14 @@ class MainActivity : AppCompatActivity() {
                 // the web; without one the field keeps its own.
                 if (listOf("padding", "paddingHorizontal", "paddingVertical", "paddingLeft", "paddingRight", "paddingTop", "paddingBottom").any { style.has(it) }) {
                     val density = resources.displayMetrics.density
-                    val all = style.optDouble("padding", 0.0)
-                    val horizontal = style.optDouble("paddingHorizontal", all)
-                    val vertical = style.optDouble("paddingVertical", all)
+                    val all = craftNativePadding(style, "padding", 0, density)
+                    val horizontal = craftNativePadding(style, "paddingHorizontal", all, density)
+                    val vertical = craftNativePadding(style, "paddingVertical", all, density)
                     setPadding(
-                        (style.optDouble("paddingLeft", horizontal) * density).toInt(),
-                        (style.optDouble("paddingTop", vertical) * density).toInt(),
-                        (style.optDouble("paddingRight", horizontal) * density).toInt(),
-                        (style.optDouble("paddingBottom", vertical) * density).toInt(),
+                        craftNativePadding(style, "paddingLeft", horizontal, density),
+                        craftNativePadding(style, "paddingTop", vertical, density),
+                        craftNativePadding(style, "paddingRight", horizontal, density),
+                        craftNativePadding(style, "paddingBottom", vertical, density),
                     )
                 }
                 // Reused EditTexts must forget the previous field's hint as
@@ -3625,15 +4224,15 @@ class MainActivity : AppCompatActivity() {
                 else if (this !== previous && props.has("defaultValue") && !props.isNull("defaultValue")) setText(props.optString("defaultValue"))
                 applyTextDecoration(this, style)
                 screen.inputIdentities[this] = identity
-                val handler = events.optString("onChange").ifBlank { events.optString("onChangeText") }
+                val handler = craftNativeEventName(events, "onChange", "onChangeText")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
-                val onFocus = events.optString("onFocus")
+                val onFocus = craftNativeEventName(events, "onFocus")
                 if (onFocus.isNotBlank()) screen.focusHandlers[this] = onFocus else screen.focusHandlers.remove(this)
-                val onBlur = events.optString("onBlur")
+                val onBlur = craftNativeEventName(events, "onBlur")
                 if (onBlur.isNotBlank()) screen.blurHandlers[this] = onBlur else screen.blurHandlers.remove(this)
-                val onEndEditing = events.optString("onEndEditing")
+                val onEndEditing = craftNativeEventName(events, "onEndEditing")
                 if (onEndEditing.isNotBlank()) screen.endEditingHandlers[this] = onEndEditing else screen.endEditingHandlers.remove(this)
-                val onSubmit = events.optString("onSubmitEditing")
+                val onSubmit = craftNativeEventName(events, "onSubmitEditing")
                 if (onSubmit.isNotBlank()) screen.submitHandlers[this] = onSubmit else screen.submitHandlers.remove(this)
                 setOnFocusChangeListener { view, focused ->
                     val nativeEvent = JSONObject().put("text", text.toString())
@@ -3694,10 +4293,10 @@ class MainActivity : AppCompatActivity() {
                     }
                     if (label.isBlank()) return@mapNotNull null
                     val optionProps = option.optJSONObject("props")
-                    val value = optionProps?.optString("value").takeIf { !it.isNullOrBlank() } ?: label
+                    val value = craftNativeOptionalString(optionProps?.opt("value")) ?: label
                     value to label
                 }
-                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                val handler = craftNativeEventName(events, "onValueChange", "onChange")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 // Detach the old listener before replacing the adapter or selection.
                 // Both operations can synchronously dispatch an Android selection
@@ -3706,7 +4305,8 @@ class MainActivity : AppCompatActivity() {
                 adapter = ArrayAdapter(this@MainActivity, android.R.layout.simple_spinner_item, options.map { it.second }).also {
                     it.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
                 }
-                val requested = props.optString("selectedValue").ifBlank { props.optString("value") }
+                val requested = craftNativeOptionalString(props.opt("selectedValue"))
+                    ?: craftNativeOptionalString(props.opt("value")).orEmpty()
                 val selected = options.indexOfFirst { it.first == requested }.takeIf { it >= 0 } ?: 0
                 isEnabled = !props.optBoolean("disabled", false)
                 // Mounting a controlled picker must not look like a user
@@ -3729,7 +4329,7 @@ class MainActivity : AppCompatActivity() {
             }
             "DatePicker" -> (previous as? CraftNativeDatePickerView ?: CraftNativeDatePickerView(this)).apply {
                 configure(props)
-                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                val handler = craftNativeEventName(events, "onValueChange", "onChange")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 onValueChanged = {
                     screen.handlers[this]?.let { current ->
@@ -3743,7 +4343,7 @@ class MainActivity : AppCompatActivity() {
                 reconcileChildren(screen, content, children, path, next, style, previousControls)
                 // Dynamic :visible bindings arrive as a display style mutation;
                 // static visible props remain authoritative when present.
-                val visible = if (props.has("visible")) {
+                val visible = if (props.has("visible") && !props.isNull("visible")) {
                     // An explicit visible prop owns modal visibility. The
                     // binding runtime may leave a stale display:none style
                     // from the previous hidden state when it patches props.
@@ -3753,18 +4353,22 @@ class MainActivity : AppCompatActivity() {
                 }
                 val wasVisible = screen.modalVisibility[this]
                 screen.modalVisibility[this] = visible
-                val requestClose = events.optString("onRequestClose")
+                val requestClose = craftNativeOptionalString(events.opt("onRequestClose")).orEmpty()
                 if (requestClose.isNotBlank()) screen.modalCloseHandlers[this] = requestClose else screen.modalCloseHandlers.remove(this)
                 onRequestClose = if (requestClose.isNotBlank()) {
                     { send(screen, "EVENT", JSONObject().put("handlerName", requestClose).put("nativeEvent", JSONObject())) }
                 } else {
                     null
                 }
-                setVisible(visible, style.optDouble("opacity", 1.0).toFloat(), props.optString("animationType").ifBlank { null })
+                setVisible(visible, craftNativeFiniteFloat(style, "opacity", 1f), craftNativeOptionalString(props.opt("animationType")))
                 if (visible) clearDismissSuppression()
                 val suppressDismiss = !visible && consumeDismissSuppression()
                 if (wasVisible != visible && (visible || wasVisible == true)) {
-                    val lifecycleHandler = if (visible) events.optString("onShow") else events.optString("onDismiss")
+                    val lifecycleHandler = if (visible) {
+                        craftNativeOptionalString(events.opt("onShow"))
+                    } else {
+                        craftNativeOptionalString(events.opt("onDismiss"))
+                    }
                     if (lifecycleHandler.isNotBlank() && !suppressDismiss) {
                         // Deliver lifecycle callbacks after reconciliation returns to
                         // the queue; the handler may immediately schedule another
@@ -3779,8 +4383,8 @@ class MainActivity : AppCompatActivity() {
             }
             "TouchableOpacity", "TouchableHighlight", "Pressable" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
                 configureContainer(this, style)
-                screen.pressActiveOpacities[this] = props.optDouble("activeOpacity", 0.5).toFloat()
-                screen.pressBaseOpacities[this] = style.optDouble("opacity", 1.0).toFloat()
+                screen.pressActiveOpacities[this] = craftNativeFiniteFloat(props, "activeOpacity", 0.5f)
+                screen.pressBaseOpacities[this] = craftNativeFiniteFloat(style, "opacity", 1f)
                 reconcileChildren(screen, this, children, path, next, style, previousControls)
             }
             "Switch" -> (previous as? Switch ?: Switch(this)).apply {
@@ -3804,9 +4408,10 @@ class MainActivity : AppCompatActivity() {
                         intArrayOf(trueColor, falseColor),
                     )
                 } ?: run { trackTintList = null }
-                thumbTintList = props.optString("thumbColor").takeIf { it.isNotBlank() }
+                craftNativeOptionalString(props.opt("thumbColor"))
                     ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
-                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                    ?: run { thumbTintList = null }
+                val handler = craftNativeEventName(events, "onValueChange", "onChange")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 setOnCheckedChangeListener { _, checked ->
                     val current = screen.handlers[this] ?: return@setOnCheckedChangeListener
@@ -3814,11 +4419,11 @@ class MainActivity : AppCompatActivity() {
                 }
             }
             "Slider" -> (previous as? SeekBar ?: SeekBar(this)).apply {
-                val minimum = props.optDouble("minimumValue", 0.0)
-                val maximumCandidate = props.optDouble("maximumValue", 1.0)
+                val minimum = craftNativeFiniteDouble(props, "minimumValue", 0.0)
+                val maximumCandidate = craftNativeFiniteDouble(props, "maximumValue", 1.0)
                 val maximum = if (maximumCandidate > minimum) maximumCandidate else minimum + Double.MIN_VALUE
                 setOnSeekBarChangeListener(null)
-                val step = props.optDouble("step", 0.0).takeIf { it > 0 }
+                val step = craftNativeFiniteDouble(props, "step", 0.0).takeIf { it > 0 }
                 // A stepped slider needs one native position per authored
                 // step; a fixed 1,000-position SeekBar silently made large
                 // ranges unable to represent most valid values. Continuous
@@ -3832,7 +4437,7 @@ class MainActivity : AppCompatActivity() {
                         .toInt()
                 } ?: 1000
                 max = progressMax
-                val requested = props.optDouble("value", minimum)
+                val requested = craftNativeFiniteDouble(props, "value", minimum)
                 val value = (if (step != null) minimum + ((requested - minimum) / step).roundToInt() * step else requested)
                     .coerceIn(minimum, maximum)
                 progress = if (step != null) {
@@ -3841,16 +4446,19 @@ class MainActivity : AppCompatActivity() {
                     (((value - minimum) / (maximum - minimum)) * max).roundToInt().coerceIn(0, max)
                 }
                 if (step != null) screen.sliderSteps[this] = step else screen.sliderSteps.remove(this)
-                progressTintList = props.optString("minimumTrackTintColor").takeIf { it.isNotBlank() }
+                craftNativeOptionalString(props.opt("minimumTrackTintColor"))
                     ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
-                progressBackgroundTintList = props.optString("maximumTrackTintColor").takeIf { it.isNotBlank() }
+                    ?: run { progressTintList = null }
+                craftNativeOptionalString(props.opt("maximumTrackTintColor"))
                     ?.let { ColorStateList.valueOf(color(it, Color.GRAY)) }
-                thumbTintList = props.optString("thumbTintColor").takeIf { it.isNotBlank() }
+                    ?: run { progressBackgroundTintList = null }
+                craftNativeOptionalString(props.opt("thumbTintColor"))
                     ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+                    ?: run { thumbTintList = null }
                 isEnabled = !props.optBoolean("disabled", false)
-                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                val handler = craftNativeEventName(events, "onValueChange", "onChange")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
-                val complete = events.optString("onSlidingComplete")
+                val complete = craftNativeEventName(events, "onSlidingComplete")
                 if (complete.isNotBlank()) screen.sliderCompleteHandlers[this] = complete else screen.sliderCompleteHandlers.remove(this)
                 setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
                     override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
@@ -3877,7 +4485,7 @@ class MainActivity : AppCompatActivity() {
                 val scale = when (requestedSize) {
                     "large" -> 1.35f
                     "small" -> 0.75f
-                    is Number -> (requestedSize.toDouble() / 24.0).toFloat().coerceAtLeast(0.5f)
+                    is Number -> (requestedSize.toDouble() / 24.0).takeIf { it.isFinite() }?.toFloat()?.coerceAtLeast(0.5f) ?: 1f
                     else -> 1f
                 }
                 scaleX = scale
@@ -3885,44 +4493,45 @@ class MainActivity : AppCompatActivity() {
                 val animating = props.optBoolean("animating", true)
                 isIndeterminate = animating
                 visibility = if (!animating && props.optBoolean("hidesWhenStopped", true)) View.GONE else View.VISIBLE
-                indeterminateTintList = props.optString("color").takeIf { it.isNotBlank() }
+                craftNativeOptionalString(props.opt("color"))
                     ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+                    ?: run { indeterminateTintList = null }
             }
             "Icon" -> (previous as? CraftNativeIconView ?: CraftNativeIconView(this)).apply {
                 configureIcon(this, props, style)
             }
             "Image" -> (previous as? ImageView ?: ImageView(this)).apply {
-                scaleType = when (style.optString("resizeMode").ifBlank { props.optString("resizeMode") }) {
+                scaleType = when (craftNativeResizeMode(style, props)) {
                     "cover" -> ImageView.ScaleType.CENTER_CROP
                     "stretch" -> ImageView.ScaleType.FIT_XY
                     "center" -> ImageView.ScaleType.CENTER
                     else -> ImageView.ScaleType.CENTER_INSIDE
                 }
                 adjustViewBounds = false
-                val onLoadStart = events.optString("onLoadStart")
+                val onLoadStart = craftNativeEventName(events, "onLoadStart")
                 if (onLoadStart.isNotBlank()) screen.imageLoadStartHandlers[this] = onLoadStart else screen.imageLoadStartHandlers.remove(this)
-                val onLoad = events.optString("onLoad")
+                val onLoad = craftNativeEventName(events, "onLoad")
                 if (onLoad.isNotBlank()) screen.imageLoadHandlers[this] = onLoad else screen.imageLoadHandlers.remove(this)
-                val onLoadEnd = events.optString("onLoadEnd")
+                val onLoadEnd = craftNativeEventName(events, "onLoadEnd")
                 if (onLoadEnd.isNotBlank()) screen.imageLoadEndHandlers[this] = onLoadEnd else screen.imageLoadEndHandlers.remove(this)
-                val onError = events.optString("onError")
+                val onError = craftNativeEventName(events, "onError")
                 if (onError.isNotBlank()) screen.imageErrorHandlers[this] = onError else screen.imageErrorHandlers.remove(this)
                 updateImage(screen, this, props.opt("source"), props.opt("defaultSource"))
             }
             "ImageBackground" -> (previous as? CraftNativeImageBackgroundView ?: CraftNativeImageBackgroundView(this)).apply {
-                image.scaleType = when (style.optString("resizeMode").ifBlank { props.optString("resizeMode") }) {
+                image.scaleType = when (craftNativeResizeMode(style, props)) {
                     "cover" -> ImageView.ScaleType.CENTER_CROP
                     "stretch" -> ImageView.ScaleType.FIT_XY
                     "center" -> ImageView.ScaleType.CENTER
                     else -> ImageView.ScaleType.CENTER_INSIDE
                 }
-                val onLoadStart = events.optString("onLoadStart")
+                val onLoadStart = craftNativeEventName(events, "onLoadStart")
                 if (onLoadStart.isNotBlank()) screen.imageLoadStartHandlers[image] = onLoadStart else screen.imageLoadStartHandlers.remove(image)
-                val onLoad = events.optString("onLoad")
+                val onLoad = craftNativeEventName(events, "onLoad")
                 if (onLoad.isNotBlank()) screen.imageLoadHandlers[image] = onLoad else screen.imageLoadHandlers.remove(image)
-                val onLoadEnd = events.optString("onLoadEnd")
+                val onLoadEnd = craftNativeEventName(events, "onLoadEnd")
                 if (onLoadEnd.isNotBlank()) screen.imageLoadEndHandlers[image] = onLoadEnd else screen.imageLoadEndHandlers.remove(image)
-                val onError = events.optString("onError")
+                val onError = craftNativeEventName(events, "onError")
                 if (onError.isNotBlank()) screen.imageErrorHandlers[image] = onError else screen.imageErrorHandlers.remove(image)
                 updateImage(screen, image, props.opt("source"), props.opt("defaultSource"))
                 configureContainer(content, style)
@@ -3936,6 +4545,7 @@ class MainActivity : AppCompatActivity() {
                     loop = props.optBoolean("loop", false),
                     muted = props.optBoolean("muted", false),
                     controls = props.optBoolean("controls", false),
+                    resizeMode = craftNativeResizeMode(style, props),
                 )
             }
             "Map" -> (previous as? CraftNativeMapView ?: CraftNativeMapView(this)).apply {
@@ -3969,22 +4579,23 @@ class MainActivity : AppCompatActivity() {
                     .firstOrNull { canonicalType(it.optString("type")) == "RefreshControl" }
                 val refreshProps = refreshNode?.optJSONObject("props") ?: JSONObject()
                 val refreshEvents = refreshNode?.optJSONObject("events") ?: JSONObject()
-                val refreshHandlerName = refreshEvents.optString("onRefresh").takeIf { it.isNotBlank() }
-                    ?: events.optString("onRefresh").takeIf { it.isNotBlank() }
+                val refreshHandlerName = craftNativeEventName(refreshEvents, "onRefresh")
+                    .takeIf { it.isNotBlank() }
+                    ?: craftNativeEventName(events, "onRefresh").takeIf { it.isNotBlank() }
                 val refreshHandler = refreshHandlerName?.let { handler ->
                     { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject())) }
                 }
                 setRefreshHandler(refreshHandler, if (refreshNode == null) props.optBoolean("refreshing", false) else refreshProps.optBoolean("refreshing", false))
                 setRefreshAppearance(refreshProps, resources.displayMetrics.density)
-                val onScroll = events.optString("onScroll")
+                val onScroll = craftNativeEventName(events, "onScroll")
                 if (onScroll.isNotBlank()) screen.scrollHandlers[this] = onScroll else screen.scrollHandlers.remove(this)
-                val onBegin = events.optString("onScrollBeginDrag")
+                val onBegin = craftNativeEventName(events, "onScrollBeginDrag")
                 if (onBegin.isNotBlank()) screen.scrollBeginHandlers[this] = onBegin else screen.scrollBeginHandlers.remove(this)
-                val onEnd = events.optString("onScrollEndDrag")
+                val onEnd = craftNativeEventName(events, "onScrollEndDrag")
                 if (onEnd.isNotBlank()) screen.scrollEndHandlers[this] = onEnd else screen.scrollEndHandlers.remove(this)
-                val onMomentumBegin = events.optString("onMomentumScrollBegin")
+                val onMomentumBegin = craftNativeEventName(events, "onMomentumScrollBegin")
                 if (onMomentumBegin.isNotBlank()) screen.scrollMomentumBeginHandlers[this] = onMomentumBegin else screen.scrollMomentumBeginHandlers.remove(this)
-                val onMomentumEnd = events.optString("onMomentumScrollEnd")
+                val onMomentumEnd = craftNativeEventName(events, "onMomentumScrollEnd")
                 if (onMomentumEnd.isNotBlank()) screen.scrollMomentumEndHandlers[this] = onMomentumEnd else screen.scrollMomentumEndHandlers.remove(this)
                 val nativeScroll = this
                 setScrollListeners(
@@ -4038,7 +4649,7 @@ class MainActivity : AppCompatActivity() {
             }
             "FlatList" -> (previous as? CraftNativeRefreshableFlatList ?: CraftNativeRefreshableFlatList(this)).apply {
                 val nativeList = list
-                configureRefresh(events.optString("onRefresh").takeIf { it.isNotBlank() }?.let { handler ->
+                configureRefresh(craftNativeEventName(events, "onRefresh").takeIf { it.isNotBlank() }?.let { handler ->
                     { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject())) }
                 }, props.optBoolean("refreshing", false))
                 nativeList.setKeyboardShouldPersistTaps(props.optString("keyboardShouldPersistTaps", "never"))
@@ -4070,15 +4681,15 @@ class MainActivity : AppCompatActivity() {
         } else if (control is CraftNativeKeyboardAvoidingView) {
             control.content.onLayoutChanged = { if (screen.active) emitLayoutEvents(screen) }
         }
-        val pressInHandler = events.optString("onPressIn").takeIf { it.isNotBlank() }
-        val pressOutHandler = events.optString("onPressOut").takeIf { it.isNotBlank() }
+        val pressInHandler = craftNativeEventName(events, "onPressIn").takeIf { it.isNotBlank() }
+        val pressOutHandler = craftNativeEventName(events, "onPressOut").takeIf { it.isNotBlank() }
         if (pressInHandler != null) screen.pressInHandlers[control] = pressInHandler else screen.pressInHandlers.remove(control)
         if (pressOutHandler != null) screen.pressOutHandlers[control] = pressOutHandler else screen.pressOutHandlers.remove(control)
         if (type != "Button" && type != "Link" && type != "TextInput" && type != "Picker" && type != "DatePicker" && type != "Modal" && type != "Switch" && type != "Slider" && type != "ActivityIndicator" && type != "KeyboardAvoidingView" && type != "StatusBar" && type != "RefreshControl" && type != "Map") {
-            val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
+            val handler = craftNativeEventName(events, "onPress", "onClick")
             val disabled = props.optBoolean("disabled", false)
-            val target = listOf(props.optString("href"), props.optString("to"))
-                .firstOrNull { it.isNotBlank() }
+            val target = listOf(props.opt("href"), props.opt("to"))
+                .firstNotNullOfOrNull(::craftNativeOptionalString)
                 ?.trim()
                 ?.takeIf { !disabled && type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable") }
             if (target != null) screen.linkTargets[control] = target else screen.linkTargets.remove(control)
@@ -4139,7 +4750,7 @@ class MainActivity : AppCompatActivity() {
         }
         val longPressDisabled = props.optBoolean("disabled", false) ||
             props.optJSONObject("accessibilityState")?.optBoolean("disabled", false) == true
-        val longPressHandler = events.optString("onLongPress").takeUnless { longPressDisabled } ?: ""
+        val longPressHandler = craftNativeEventName(events, "onLongPress").takeUnless { longPressDisabled } ?: ""
         if (longPressHandler.isNotBlank()) {
             screen.longPressHandlers[control] = longPressHandler
             control.setOnLongClickListener {
@@ -4153,7 +4764,7 @@ class MainActivity : AppCompatActivity() {
             control.isLongClickable = false
         }
         applyAccessibility(control, props, type, explicitKey ?: protocolId ?: path)
-        val layoutHandler = events.optString("onLayout")
+        val layoutHandler = craftNativeEventName(events, "onLayout")
         if (layoutHandler.isNotBlank()) {
             if (screen.layoutHandlers[control] != layoutHandler) screen.lastLayoutBounds.remove(control)
             screen.layoutHandlers[control] = layoutHandler
@@ -4189,20 +4800,20 @@ class MainActivity : AppCompatActivity() {
                 View.VISIBLE
             }
         }
-        val width = style.optDouble("width", Double.NaN).takeUnless { it.isNaN() }?.let(::dp)
-        val height = style.optDouble("height", Double.NaN).takeUnless { it.isNaN() }?.let(::dp)
+        val width = craftNativeFiniteDouble(style, "width", Double.NaN).takeUnless { it.isNaN() }?.let(::dp)
+        val height = craftNativeFiniteDouble(style, "height", Double.NaN).takeUnless { it.isNaN() }?.let(::dp)
         control.layoutParams = LinearLayout.LayoutParams(
             width ?: ViewGroup.LayoutParams.WRAP_CONTENT,
             height ?: ViewGroup.LayoutParams.WRAP_CONTENT
         ).apply {
-            val margin = style.optDouble("margin", 0.0)
-            val horizontal = style.optDouble("marginHorizontal", margin)
-            val vertical = style.optDouble("marginVertical", margin)
+            val margin = craftNativeFiniteDouble(style, "margin", 0.0)
+            val horizontal = craftNativeFiniteDouble(style, "marginHorizontal", margin)
+            val vertical = craftNativeFiniteDouble(style, "marginVertical", margin)
             setMargins(
-                dp(style.optDouble("marginLeft", horizontal)),
-                dp(style.optDouble("marginTop", vertical)),
-                dp(style.optDouble("marginRight", horizontal)),
-                dp(style.optDouble("marginBottom", vertical))
+                dp(craftNativeFiniteDouble(style, "marginLeft", horizontal)),
+                dp(craftNativeFiniteDouble(style, "marginTop", vertical)),
+                dp(craftNativeFiniteDouble(style, "marginRight", horizontal)),
+                dp(craftNativeFiniteDouble(style, "marginBottom", vertical))
             )
         }
         return control
@@ -4251,19 +4862,18 @@ class MainActivity : AppCompatActivity() {
         val direct = listOf(node.optString("key"), props.optString("key"), props.optString("testID"))
             .firstOrNull { it.isNotBlank() }
         if (direct != null) return direct
-        val children = node.optJSONArray("children") ?: return null
-        for (index in 0 until children.length()) {
-            val child = children.optJSONObject(index) ?: continue
-            val childProps = child.optJSONObject("props") ?: JSONObject()
-            authoredKey(child, childProps)?.let { return it }
-        }
-        return node.optString("id").takeIf { it.isNotBlank() }
+        return null
     }
 
     private fun configureContainer(layout: CraftNativeFlexLayout, style: JSONObject) {
         layout.configure(style, resources.displayMetrics.density)
     }
 
+    private fun craftNativeResizeMode(style: JSONObject, props: JSONObject): String {
+        return craftNativeOptionalString(style.opt("resizeMode"))
+            ?: craftNativeOptionalString(props.opt("resizeMode")).orEmpty()
+    }
+
     private fun flatListScrollEvent(list: CraftNativeFlatList): JSONObject = JSONObject()
         .put("contentOffset", JSONObject()
             .put("x", list.computeHorizontalScrollOffset())
@@ -4336,30 +4946,29 @@ class MainActivity : AppCompatActivity() {
         }
         val nodes = (0 until children.length()).mapNotNull { children.optJSONObject(it) }
         nodes.forEach { registerFlatListOwnership(screen, it, owner) }
-        list.onScrollEvent = events.optString("onScroll").takeIf { it.isNotBlank() }?.let { handler ->
+        list.onScrollEvent = craftNativeEventName(events, "onScroll").takeIf { it.isNotBlank() }?.let { handler ->
             { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
         }
-        list.onScrollBeginDrag = events.optString("onScrollBeginDrag").takeIf { it.isNotBlank() }?.let { handler ->
+        list.onScrollBeginDrag = craftNativeEventName(events, "onScrollBeginDrag").takeIf { it.isNotBlank() }?.let { handler ->
             { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
         }
-        list.onScrollEndDrag = events.optString("onScrollEndDrag").takeIf { it.isNotBlank() }?.let { handler ->
+        list.onScrollEndDrag = craftNativeEventName(events, "onScrollEndDrag").takeIf { it.isNotBlank() }?.let { handler ->
             { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
         }
-        list.onMomentumScrollBegin = events.optString("onMomentumScrollBegin").takeIf { it.isNotBlank() }?.let { handler ->
+        list.onMomentumScrollBegin = craftNativeEventName(events, "onMomentumScrollBegin").takeIf { it.isNotBlank() }?.let { handler ->
             { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
         }
-        list.onMomentumScrollEnd = events.optString("onMomentumScrollEnd").takeIf { it.isNotBlank() }?.let { handler ->
+        list.onMomentumScrollEnd = craftNativeEventName(events, "onMomentumScrollEnd").takeIf { it.isNotBlank() }?.let { handler ->
             { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
         }
+        val threshold = craftNativeNonNegativeDouble(props, "threshold", 0.1)
+        val authoredThreshold = craftNativeNonNegativeDouble(props, "onEndReachedThreshold", threshold)
         list.apply(
             nodes = nodes,
             horizontal = props.optBoolean("horizontal", false),
             columns = props.optInt("numColumns", 1),
             inverted = props.optBoolean("inverted", false),
-            endReachedThreshold = props.opt("onEndReachedThreshold")
-                ?.takeUnless { it == JSONObject.NULL }
-                ?.let { props.optDouble("onEndReachedThreshold", 0.1) }
-                ?: props.optDouble("threshold", 0.1),
+            endReachedThreshold = authoredThreshold,
             renderItem = { node, itemIdentity, _ ->
                 val rows = screen.flatListRows.getOrPut(list) { mutableMapOf() }
                 val previous = rows[itemIdentity].orEmpty()
@@ -4373,7 +4982,7 @@ class MainActivity : AppCompatActivity() {
                 val controls = screen.flatListRows[list]?.remove(itemIdentity).orEmpty()
                 releaseViewState(screen, controls.values.toList(), preservingInputDrafts = true)
             },
-            endReached = events.optString("onEndReached").takeIf { it.isNotBlank() }?.let { handler ->
+            endReached = craftNativeEventName(events, "onEndReached").takeIf { it.isNotBlank() }?.let { handler ->
                 { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject())) }
             },
         )
@@ -4393,20 +5002,21 @@ class MainActivity : AppCompatActivity() {
     private fun addJustificationSpacers(layout: CraftNativeFlexLayout, value: String) { }
 
     private fun applyViewStyle(view: View, style: JSONObject) {
-        view.alpha = style.optDouble("opacity", 1.0).toFloat()
+        view.alpha = craftNativeFiniteFloat(style, "opacity", 1f)
         // A Text's padding (`px-4` on a line of text) is where its text
         // starts, as on iOS; containers and fields lay out their own.
         if (view is TextView && view !is EditText && view !is CraftNativeIconView) {
             val keys = listOf("padding", "paddingHorizontal", "paddingVertical", "paddingLeft", "paddingRight", "paddingTop", "paddingBottom")
             if (keys.any(style::has)) {
-                val all = style.optDouble("padding", 0.0)
-                val horizontal = style.optDouble("paddingHorizontal", all)
-                val vertical = style.optDouble("paddingVertical", all)
+                val density = resources.displayMetrics.density
+                val all = craftNativePadding(style, "padding", 0, density)
+                val horizontal = craftNativePadding(style, "paddingHorizontal", all, density)
+                val vertical = craftNativePadding(style, "paddingVertical", all, density)
                 view.setPadding(
-                    dp(style.optDouble("paddingLeft", horizontal)),
-                    dp(style.optDouble("paddingTop", vertical)),
-                    dp(style.optDouble("paddingRight", horizontal)),
-                    dp(style.optDouble("paddingBottom", vertical)),
+                    craftNativePadding(style, "paddingLeft", horizontal, density),
+                    craftNativePadding(style, "paddingTop", vertical, density),
+                    craftNativePadding(style, "paddingRight", horizontal, density),
+                    craftNativePadding(style, "paddingBottom", vertical, density),
                 )
             } else if (view.javaClass == TextView::class.java) {
                 view.setPadding(0, 0, 0, 0)
@@ -4416,18 +5026,18 @@ class MainActivity : AppCompatActivity() {
         if (view !is CraftNativeModalView) {
             view.visibility = if (style.optString("display") == "none") View.GONE else View.VISIBLE
         }
-        view.elevation = dp(style.optDouble("elevation", 0.0)).toFloat()
-        view.z = style.optDouble("zIndex", 0.0).toFloat()
+        view.elevation = dp(craftNativeNonNegativeDouble(style, "elevation", 0.0)).toFloat()
+        view.z = craftNativeFiniteFloat(style, "zIndex", 0f)
         val background = style.has("backgroundColor") && !style.isNull("backgroundColor")
-        val border = style.optDouble("borderWidth", 0.0)
-        val radius = style.optDouble("borderRadius", 0.0)
+        val border = craftNativeNonNegativeDouble(style, "borderWidth", 0.0)
+        val radius = craftNativeNonNegativeDouble(style, "borderRadius", 0.0)
         val sideBorderKeys = listOf("borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth")
         val hasSideBorders = (sideBorderKeys + listOf("borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor")).any(style::has)
-        val sideWidths = sideBorderKeys.map { dp(style.optDouble(it, border)) }.toIntArray()
+        val sideWidths = sideBorderKeys.map { dp(craftNativeNonNegativeDouble(style, it, border)) }.toIntArray()
         val cornerRadiusKeys = listOf("borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius")
         val hasCornerRadii = cornerRadiusKeys.any(style::has)
         val cornerRadii = cornerRadiusKeys.flatMap { value ->
-            val radius = dp(style.optDouble(value, radius)).toFloat()
+            val radius = dp(craftNativeNonNegativeDouble(style, value, radius)).toFloat()
             listOf(radius, radius)
         }.toFloatArray()
         val sideColors = listOf("borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor")
@@ -4470,19 +5080,20 @@ class MainActivity : AppCompatActivity() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P &&
             (style.has("shadowColor") || style.has("shadowOpacity") || style.has("shadowRadius"))
         ) {
-            val shadowOpacity = style.optDouble("shadowOpacity", 1.0).coerceIn(0.0, 1.0)
+            val shadowOpacity = craftNativeFiniteFloat(style, "shadowOpacity", 1f).coerceIn(0f, 1f)
             val shadow = color(style.optString("shadowColor"), Color.BLACK)
             val alphaShadow = Color.argb((Color.alpha(shadow) * shadowOpacity).roundToInt(), Color.red(shadow), Color.green(shadow), Color.blue(shadow))
             view.outlineAmbientShadowColor = alphaShadow
             view.outlineSpotShadowColor = alphaShadow
-            view.elevation = max(view.elevation, dp(style.optDouble("shadowRadius", 0.0) * 2.0).toFloat())
+            val shadowRadius = craftNativeNonNegativeDouble(style, "shadowRadius", 0.0)
+            view.elevation = max(view.elevation, dp(shadowRadius * 2.0).toFloat())
             val offset = style.optJSONObject("shadowOffset")
-            val offsetX = dp(offset?.optDouble("width", 0.0) ?: 0.0)
-            val offsetY = dp(offset?.optDouble("height", 0.0) ?: 0.0)
-            val shadowRadius = dp(style.optDouble("shadowRadius", 0.0)).toFloat()
+            val offsetX = dp(craftNativeFiniteDouble(offset, "width", 0.0))
+            val offsetY = dp(craftNativeFiniteDouble(offset, "height", 0.0))
+            val radius = dp(shadowRadius).toFloat()
             view.outlineProvider = object : ViewOutlineProvider() {
                 override fun getOutline(target: View, outline: Outline) {
-                    outline.setRoundRect(offsetX, offsetY, target.width + offsetX, target.height + offsetY, shadowRadius)
+                    outline.setRoundRect(offsetX, offsetY, target.width + offsetX, target.height + offsetY, radius)
                 }
             }
             view.invalidateOutline()
@@ -4515,11 +5126,11 @@ class MainActivity : AppCompatActivity() {
             val transform = transforms.optJSONObject(index) ?: continue
             val key = transform.keys().asSequence().firstOrNull() ?: continue
             when (key) {
-                "translateX" -> view.translationX += dp(transform.optDouble(key, 0.0)).toFloat()
-                "translateY" -> view.translationY += dp(transform.optDouble(key, 0.0)).toFloat()
-                "scale" -> transform.optDouble(key, 1.0).toFloat().let { view.scaleX *= it; view.scaleY *= it }
-                "scaleX" -> view.scaleX *= transform.optDouble(key, 1.0).toFloat()
-                "scaleY" -> view.scaleY *= transform.optDouble(key, 1.0).toFloat()
+                "translateX" -> view.translationX += dp(craftNativeFiniteDouble(transform, key, 0.0)).toFloat()
+                "translateY" -> view.translationY += dp(craftNativeFiniteDouble(transform, key, 0.0)).toFloat()
+                "scale" -> craftNativeFiniteDouble(transform, key, 1.0).toFloat().let { view.scaleX *= it; view.scaleY *= it }
+                "scaleX" -> view.scaleX *= craftNativeFiniteDouble(transform, key, 1.0).toFloat()
+                "scaleY" -> view.scaleY *= craftNativeFiniteDouble(transform, key, 1.0).toFloat()
                 "rotate", "rotateZ" -> view.rotation += angleDegrees(transform.opt(key))
                 "rotateX" -> view.rotationX += angleDegrees(transform.opt(key))
                 "rotateY" -> view.rotationY += angleDegrees(transform.opt(key))
@@ -4531,15 +5142,16 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun skewFactor(value: Any?): Float =
-        kotlin.math.tan(angleDegrees(value).toDouble() * PI / 180.0).toFloat()
+        kotlin.math.tan(angleDegrees(value).toDouble() * PI / 180.0).toFloat().takeIf { it.isFinite() } ?: 0f
 
     private fun angleDegrees(value: Any?): Float {
         val text = value?.toString()?.trim() ?: return 0f
-        return when {
+        val result = when {
             text.endsWith("rad") -> Math.toDegrees(text.dropLast(3).toDoubleOrNull() ?: 0.0).toFloat()
             text.endsWith("deg") -> text.dropLast(3).toFloatOrNull() ?: 0f
             else -> text.toFloatOrNull() ?: 0f
         }
+        return result.takeIf { it.isFinite() } ?: 0f
     }
 
     private fun ensureLayoutListener(screen: Screen, view: View) {
@@ -4562,15 +5174,22 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun configureIcon(view: CraftNativeIconView, props: JSONObject, style: JSONObject) {
-        val symbol = props.optString("symbol").ifBlank { props.optString("name") }
-        val size = style.optDouble("fontSize", 20.0).toFloat().coerceAtLeast(1f)
+        val symbol = craftNativeOptionalString(props.opt("symbol"))
+            ?: craftNativeOptionalString(props.opt("name")).orEmpty()
+        val size = craftNativeFiniteFloat(style, "fontSize", 20f).coerceAtLeast(1f)
         view.setTextSize(TypedValue.COMPLEX_UNIT_SP, size)
-        val foreground = style.optString("color").ifBlank { props.optString("color") }
+        val foreground = craftNativeOptionalString(style.opt("color"))
+            ?: craftNativeOptionalString(props.opt("color")).orEmpty()
         val tint = color(foreground, defaultTextColor)
         view.setTextColor(tint)
         // The app's own vector for it (craft-icons.json, the icon the web
         // shows), else the closest glyph Android's fonts have.
-        val vector = CraftNativeIcons.drawable(this, props.optString("name"), props.optString("symbol"), tint)
+        val vector = CraftNativeIcons.drawable(
+            this,
+            craftNativeOptionalString(props.opt("name")).orEmpty(),
+            craftNativeOptionalString(props.opt("symbol")).orEmpty(),
+            tint,
+        )
         view.vector = vector
         view.text = if (vector != null) "" else androidIconGlyph(symbol)
         val weight = when (style.optString("fontWeight")) {
@@ -4621,7 +5240,7 @@ class MainActivity : AppCompatActivity() {
 
     private fun configureTextStyle(view: TextView, style: JSONObject) {
         view.setTextColor(color(style.optString("color"), defaultTextColor))
-        view.setTextSize(TypedValue.COMPLEX_UNIT_SP, style.optDouble("fontSize", 16.0).toFloat())
+        view.setTextSize(TypedValue.COMPLEX_UNIT_SP, craftNativeFiniteFloat(style, "fontSize", 16f))
         val weight = when (style.optString("fontWeight")) {
             "bold" -> 700
             "100", "200", "300", "400", "500", "600", "700", "800", "900" -> style.optInt("fontWeight")
@@ -4648,11 +5267,11 @@ class MainActivity : AppCompatActivity() {
             }
         }
         view.letterSpacing = style.optDouble("letterSpacing", Double.NaN)
-            .takeUnless { it.isNaN() }
+            .takeIf { it.isFinite() }
             ?.let { if (view.textSize > 0) dp(it).toFloat() / view.textSize else 0f }
             ?: 0f
         view.setLineSpacing(
-            style.optDouble("lineHeight", Double.NaN).takeUnless { it.isNaN() }?.let { dp(it) - view.textSize } ?: 0f,
+            style.optDouble("lineHeight", Double.NaN).takeIf { it.isFinite() }?.let { dp(it) - view.textSize } ?: 0f,
             1f
         )
         val shadowColor = style.optString("textShadowColor").takeIf { it.isNotBlank() }
@@ -4661,9 +5280,9 @@ class MainActivity : AppCompatActivity() {
         } else {
             val offset = style.optJSONObject("textShadowOffset")
             view.setShadowLayer(
-                dp(style.optDouble("textShadowRadius", 0.0)).toFloat().coerceAtLeast(0f),
-                dp(offset?.optDouble("width", 0.0) ?: 0.0).toFloat(),
-                dp(offset?.optDouble("height", 0.0) ?: 0.0).toFloat(),
+                dp(craftNativeFiniteDouble(style, "textShadowRadius", 0.0)).toFloat().coerceAtLeast(0f),
+                dp(craftNativeFiniteDouble(offset, "width", 0.0)).toFloat(),
+                dp(craftNativeFiniteDouble(offset, "height", 0.0)).toFloat(),
                 color(shadowColor, Color.TRANSPARENT),
             )
         }
@@ -4727,7 +5346,7 @@ class MainActivity : AppCompatActivity() {
 
     private fun imageUri(source: Any?): String = when (source) {
         is String -> source
-        is JSONObject -> source.optString("uri")
+        is JSONObject -> craftNativeOptionalString(source.opt("uri")).orEmpty()
         else -> ""
     }
 
@@ -4748,6 +5367,7 @@ class MainActivity : AppCompatActivity() {
             imageSources[view] = ""
             imageErrors[view] = "Image source is missing"
             view.setImageDrawable(null)
+            imageDidChange(view)
             imageFailure(screen, view, uri, "Image source is missing")
             return
         }
@@ -4756,7 +5376,9 @@ class MainActivity : AppCompatActivity() {
         imageSources[view] = uri
         imageErrors.remove(view)
         view.setImageDrawable(null)
+        imageDidChange(view)
         immediateImage(imageUri(defaultSource))?.let(view::setImageBitmap)
+        if (view.drawable != null) imageDidChange(view)
         emitImageEvent(screen, view, screen.imageLoadStartHandlers[view])
 
         if (uri.startsWith("data:image/") && uri.contains(',')) {
@@ -4764,6 +5386,7 @@ class MainActivity : AppCompatActivity() {
             val bitmap = bytes?.let { BitmapFactory.decodeByteArray(it, 0, it.size) }
             if (bitmap != null) {
                 view.setImageBitmap(bitmap)
+                imageDidChange(view)
                 emitImageEvent(screen, view, screen.imageLoadHandlers[view])
                 emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
             } else imageFailure(screen, view, uri, "Image data is invalid")
@@ -4773,6 +5396,7 @@ class MainActivity : AppCompatActivity() {
             val bitmap = runCatching { assets.open(uri).use { BitmapFactory.decodeStream(it) } }.getOrNull()
             if (bitmap != null) {
                 view.setImageBitmap(bitmap)
+                imageDidChange(view)
                 emitImageEvent(screen, view, screen.imageLoadHandlers[view])
                 emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
             } else imageFailure(screen, view, uri, "Bundled image was not found")
@@ -4795,6 +5419,7 @@ class MainActivity : AppCompatActivity() {
                 imageJobs.remove(view)
                 if (bitmap != null) {
                     view.setImageBitmap(bitmap)
+                    imageDidChange(view)
                     emitImageEvent(screen, view, screen.imageLoadHandlers[view])
                     emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
                 } else imageFailure(screen, view, uri, "Image download failed")
@@ -4805,6 +5430,7 @@ class MainActivity : AppCompatActivity() {
     private fun imageFailure(screen: Screen, view: ImageView, uri: String, message: String) {
         imageErrors[view] = message
         view.setImageDrawable(null)
+        imageDidChange(view)
         val current = view.contentDescription?.toString().orEmpty()
         if (!current.contains(message)) {
             view.contentDescription = listOf(
@@ -4817,6 +5443,18 @@ class MainActivity : AppCompatActivity() {
         Log.e(TAG, "$message: $uri")
     }
 
+    /**
+     * An ImageView invalidates its own measure when its drawable changes, but
+     * the native flex parent also memoizes intrinsic probes for the frame.
+     * Clear that memo and walk through image-background wrappers so a source
+     * swap can change an un-sized image's layout on the next pass.
+     */
+    private fun imageDidChange(view: ImageView) {
+        view.invalidate()
+        view.requestLayout()
+        invalidateMeasurementAncestors(view.parent)
+    }
+
     private fun emitImageEvent(screen: Screen, view: ImageView, handler: String?, nativeEvent: JSONObject = JSONObject()) {
         if (handler.isNullOrBlank()) return
         send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", nativeEvent))
@@ -4837,17 +5475,17 @@ class MainActivity : AppCompatActivity() {
 
     private fun applyAccessibility(view: View, props: JSONObject, type: String, fallbackLabel: String) {
         view.tag = fallbackLabel
-        val label = props.optString("accessibilityLabel").takeIf { it.isNotBlank() }
-            ?: props.optString("alt").takeIf { (type == "Image" || type == "ImageBackground") && it.isNotBlank() }
-        val value = props.opt("accessibilityValue")?.takeUnless { it == JSONObject.NULL }?.toString()
+        val label = craftNativeOptionalString(props.opt("accessibilityLabel"))
+            ?: craftNativeOptionalString(props.opt("alt"))?.takeIf { type == "Image" || type == "ImageBackground" }
+        val value = craftNativeOptionalString(props.opt("accessibilityValue"))
         view.contentDescription = when {
             label != null && value != null -> "$label, $value"
             label != null -> label
             value != null -> value
             else -> null
         }
-        view.tooltipText = props.optString("accessibilityHint").takeIf { it.isNotBlank() }
-        val role = props.optString("accessibilityRole").ifBlank {
+        view.tooltipText = craftNativeOptionalString(props.opt("accessibilityHint"))
+        val role = craftNativeOptionalString(props.opt("accessibilityRole")) ?: run {
             if (type == "Icon") "image" else type.lowercase()
         }
         val state = props.optJSONObject("accessibilityState")
@@ -4885,7 +5523,10 @@ class MainActivity : AppCompatActivity() {
         )
     }
 
-    private fun dp(value: Double) = (value * resources.displayMetrics.density).toInt()
+    private fun dp(value: Double): Int {
+        val pixels = value * resources.displayMetrics.density
+        return if (pixels.isFinite()) pixels.toInt() else 0
+    }
     private fun color(raw: String, fallback: Int) = runCatching { craftNativeColor(raw) }.getOrDefault(fallback)
 
     private fun inputTypeFor(props: JSONObject): Int {
@@ -5089,6 +5730,11 @@ class MainActivity : AppCompatActivity() {
         super.onStop()
     }
 
+    override fun onLowMemory() {
+        mapViews().forEach { it.lowMemory() }
+        super.onLowMemory()
+    }
+
     override fun onNewIntent(intent: Intent) {
         super.onNewIntent(intent)
         setIntent(intent)
@@ -5187,10 +5833,40 @@ class MainActivity : AppCompatActivity() {
             screen.port.postMessage(Message.createStringMessage(message.toString()))
         } else {
             val script = "globalThis.__stxNativeCallback && globalThis.__stxNativeCallback(${JSONObject.quote(message.toString())})"
-            screen.isolate.evaluateJavaScriptAsync(script)
+            reportJavaScriptFailure(screen, screen.isolate.evaluateJavaScriptAsync(script))
         }
     }
 
+    /**
+     * An error JavaScript threw and nothing caught, to the crash reporter. A
+     * sandbox has no global error event: an uncaught error surfaces only as
+     * the evaluation's future failing, so every evaluation that runs a
+     * screen's code reports through here.
+     */
+    private fun reportJavaScriptFailure(screen: Screen, future: com.google.common.util.concurrent.ListenableFuture<String>) {
+        if (!CraftCrashReporter.enabled) return
+        future.addListener({
+            try {
+                future.get()
+            } catch (error: Exception) {
+                reportJavaScriptError(screen, error)
+            }
+        }, java.util.concurrent.Executor { command -> command.run() })
+    }
+
+    private fun reportJavaScriptError(screen: Screen, error: Throwable) {
+        val cause = (error as? java.util.concurrent.ExecutionException)?.cause ?: error
+        if (cause is java.util.concurrent.CancellationException || cause is androidx.javascriptengine.IsolateTerminatedException) return
+        val text = cause.message ?: cause.javaClass.simpleName
+        // JavaScriptSandbox reports "Uncaught TypeError: message" and, when it
+        // has one, the stack after a newline.
+        val firstLine = text.lineSequence().firstOrNull()?.removePrefix("Uncaught ")?.trim() ?: text
+        val name = Regex("^([A-Z][A-Za-z]*Error|Error):").find(firstLine)?.groupValues?.get(1)
+        val message = if (name != null) firstLine.removePrefix("$name:").trim() else firstLine
+        val stack = text.lineSequence().drop(1).joinToString("\n").ifBlank { null }
+        CraftCrashReporter.captureJavaScript(name, message, stack, screen.route ?: "home", screen.headless)
+    }
+
     /** Back to the first screen in one move. */
     private fun popToRoot() {
         while (screens.size > 1) closeScreen(screens.removeAt(screens.lastIndex))
@@ -5229,6 +5905,11 @@ class MainActivity : AppCompatActivity() {
         screen.flatListRows.values.forEach { rows -> rows.values.forEach { addAll(it.values) } }
     }
 
+    private fun mapViews(): Set<CraftNativeMapView> = allScreens()
+        .flatMap { retainedViews(it) }
+        .filterIsInstance<CraftNativeMapView>()
+        .toSet()
+
     private fun releaseFlatList(
         screen: Screen,
         list: CraftNativeFlatList,
@@ -5260,6 +5941,7 @@ class MainActivity : AppCompatActivity() {
         }
         released.filterIsInstance<CraftNativeModalView>().forEach { it.resetForTeardown() }
         released.filterIsInstance<CraftNativeVideoView>().forEach { it.stop() }
+        released.filterIsInstance<CraftNativeMapView>().forEach { it.destroy() }
         released.filterIsInstance<CraftNativeFlexLayout>().forEach { it.onLayoutChanged = null }
         released.filterIsInstance<CraftNativeKeyboardAvoidingView>().forEach { it.content.onLayoutChanged = null }
         released.filterIsInstance<CraftNativeScrollView>().forEach { it.setRefreshHandler(null, false) }