craft-native 0.0.123 → 0.0.125

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

@@ -3,11 +3,14 @@ package {{PACKAGE_NAME}}
 import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
+import android.content.res.ColorStateList
+import android.content.res.Configuration
 import android.content.Intent
 import android.graphics.BitmapFactory
 import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Typeface
+import android.graphics.drawable.Drawable
 import android.graphics.drawable.GradientDrawable
 import android.net.Uri
 import android.os.Build
@@ -17,6 +20,8 @@ import android.os.Looper
 import android.os.VibrationEffect
 import android.os.Vibrator
 import android.text.Editable
+import android.text.InputFilter
+import android.text.TextUtils
 import android.text.TextWatcher
 import android.util.Log
 import android.util.Base64
@@ -25,8 +30,11 @@ import android.view.Gravity
 import android.view.KeyEvent
 import android.view.inputmethod.EditorInfo
 import android.text.InputType
+import android.text.Layout
 import android.view.View
 import android.view.ViewGroup
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
 import android.widget.Button
 import android.widget.EditText
 import android.widget.FrameLayout
@@ -34,10 +42,15 @@ import android.widget.HorizontalScrollView
 import android.widget.ImageView
 import android.widget.LinearLayout
 import android.widget.ScrollView
+import android.widget.SeekBar
+import android.widget.Spinner
+import android.widget.Switch
 import android.widget.TextView
 import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.content.ContextCompat
 import androidx.core.view.AccessibilityDelegateCompat
+import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.ViewCompat
 import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
 import androidx.javascriptengine.JavaScriptIsolate
@@ -55,6 +68,7 @@ import java.util.concurrent.Future
 import java.util.UUID
 import kotlin.math.max
 import kotlin.math.min
+import kotlin.math.roundToInt
 
 private const val CRAFT_NATIVE_CAPABILITY_TIMEOUT_MS = 30_000L
 
@@ -71,30 +85,61 @@ private data class CraftNativeLayoutStyle(
     val bottom: Int? = null,
     val left: Int? = null,
     val alignSelf: String? = null,
+    val flexGrow: Double = 0.0,
+    val flexShrink: Double = 0.0,
+    val flexBasis: Int? = null,
 ) {
     companion object {
         fun from(raw: JSONObject, density: Float): CraftNativeLayoutStyle {
-            fun number(name: String): Int? = if (raw.has(name)) (raw.optDouble(name) * density).toInt() else null
+            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).toInt() }
+            }
             return CraftNativeLayoutStyle(
                 width = number("width"), height = number("height"),
                 minWidth = number("minWidth"), maxWidth = number("maxWidth"),
                 minHeight = number("minHeight"), maxHeight = number("maxHeight"),
-                position = raw.optString("position", "relative"),
+                position = raw.opt("position")
+                    ?.takeUnless { it == JSONObject.NULL }
+                    ?.toString()
+                    ?.takeIf { it.isNotBlank() }
+                    ?: "relative",
                 top = number("top"), right = number("right"), bottom = number("bottom"), left = number("left"),
-                alignSelf = raw.optString("alignSelf").takeIf { it.isNotBlank() },
+                alignSelf = raw.opt("alignSelf")
+                    ?.takeUnless { it == JSONObject.NULL }
+                    ?.toString()
+                    ?.takeIf { it.isNotBlank() },
+                flexGrow = raw.optDouble("flexGrow", raw.optDouble("flex", 0.0)),
+                flexShrink = raw.optDouble("flexShrink", 0.0),
+                flexBasis = number("flexBasis"),
             )
         }
     }
 }
 
+private fun craftNativeGridColumnCount(value: Any?): Int {
+    if (value is Number) return max(1, value.toInt())
+    val text = value as? String ?: return 1
+    val trimmed = text.trim()
+    if (trimmed.startsWith("repeat(")) {
+        val count = trimmed.removePrefix("repeat(").takeWhile { it.isDigit() }.toIntOrNull()
+        if (count != null) return max(1, count)
+    }
+    return max(1, trimmed.split(Regex("\\s+")).count { it.isNotBlank() })
+}
+
 /** A deterministic flex-shaped container shared by normal views and scroll content. */
 private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
+    var onLayoutChanged: (() -> Unit)? = null
     private val styles = mutableMapOf<View, CraftNativeLayoutStyle>()
     private var wrap = false
     private var alignItems = "stretch"
     private var justifyContent = "flex-start"
     private var rowGap = 0
     private var columnGap = 0
+    private var grid = false
+    private var gridColumns = 1
+    private var gridAutoRows: Int? = null
 
     fun configure(style: JSONObject, density: Float) {
         orientation = if (style.optString("flexDirection") in setOf("row", "row-reverse")) HORIZONTAL else VERTICAL
@@ -104,6 +149,11 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val gap = (style.optDouble("gap", 0.0) * density).toInt()
         rowGap = (style.optDouble("rowGap", gap.toDouble() / density.toDouble()) * density).toInt()
         columnGap = (style.optDouble("columnGap", gap.toDouble() / density.toDouble()) * density).toInt()
+        grid = style.optString("display") == "grid"
+        gridColumns = craftNativeGridColumnCount(
+            if (style.has("gridTemplateColumns")) style.opt("gridTemplateColumns") else style.opt("gridColumns")
+        )
+        gridAutoRows = style.optDouble("gridAutoRows", Double.NaN).takeUnless { it.isNaN() }?.let { (it * density).toInt() }
         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()
@@ -128,6 +178,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
 
     private data class Entry(val view: View, val style: CraftNativeLayoutStyle, val width: Int, val height: Int)
     private data class Line(val entries: MutableList<Entry> = mutableListOf(), var main: Int = 0, var cross: Int = 0)
+    private data class GridLayout(val rows: List<List<Entry>>, val absolute: List<Entry>, val cellWidth: Int, val rowHeights: List<Int>)
 
     private fun entries(width: Int, height: Int): Pair<List<Line>, List<Entry>> {
         val availableMain = if (orientation == HORIZONTAL) max(0, width - paddingLeft - paddingRight)
@@ -143,6 +194,16 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             val lp = child.layoutParams as? MarginLayoutParams
             val horizontalMargins = (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
             val verticalMargins = (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
+            if (child is CraftNativeModalView) {
+                val modalWidth = max(0, width - paddingLeft - paddingRight)
+                val modalHeight = max(0, height - paddingTop - paddingBottom)
+                child.measure(
+                    View.MeasureSpec.makeMeasureSpec(modalWidth, View.MeasureSpec.EXACTLY),
+                    View.MeasureSpec.makeMeasureSpec(modalHeight, View.MeasureSpec.EXACTLY),
+                )
+                absolute += Entry(child, style, modalWidth, modalHeight)
+                continue
+            }
             val childWidth = measureChildWidth(child, style, width - paddingLeft - paddingRight, horizontalMargins)
             val childHeight = measureChildHeight(child, style, height - paddingTop - paddingBottom, verticalMargins)
             val entry = Entry(child, style, childWidth, childHeight)
@@ -162,8 +223,80 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         return lines to absolute
     }
 
+    private fun gridLayout(width: Int, height: Int): GridLayout {
+        val availableWidth = max(0, width - paddingLeft - paddingRight)
+        val gap = columnGap
+        val cellWidth = max(0, (availableWidth - max(0, gridColumns - 1) * gap) / max(1, gridColumns))
+        val rows = mutableListOf<MutableList<Entry>>()
+        val absolute = mutableListOf<Entry>()
+        for (index in 0 until childCount) {
+            val child = getChildAt(index)
+            if (child.visibility == GONE) continue
+            val style = styles[child] ?: CraftNativeLayoutStyle()
+            val lp = child.layoutParams as? MarginLayoutParams
+            val horizontalMargins = (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
+            val verticalMargins = (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
+            if (child is CraftNativeModalView) {
+                val modalWidth = max(0, width - paddingLeft - paddingRight)
+                val modalHeight = max(0, height - paddingTop - paddingBottom)
+                child.measure(
+                    View.MeasureSpec.makeMeasureSpec(modalWidth, View.MeasureSpec.EXACTLY),
+                    View.MeasureSpec.makeMeasureSpec(modalHeight, View.MeasureSpec.EXACTLY),
+                )
+                absolute += Entry(child, style, modalWidth, modalHeight)
+                continue
+            }
+            val childWidth = measureChildWidth(child, style, cellWidth, horizontalMargins)
+            val childHeight = measureChildHeight(child, style, height - paddingTop - paddingBottom, verticalMargins)
+            val entry = Entry(child, style, childWidth, childHeight)
+            if (style.position == "absolute") absolute += entry
+            else {
+                if (rows.isEmpty() || rows.last().size == gridColumns) rows.add(mutableListOf())
+                rows.last() += entry
+            }
+        }
+        val rowHeights = rows.map { row ->
+            max(gridAutoRows ?: 0, row.maxOfOrNull { entry ->
+                val lp = entry.view.layoutParams as? MarginLayoutParams
+                entry.height + (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
+            } ?: 0)
+        }
+        return GridLayout(rows, absolute, cellWidth, rowHeights)
+    }
+
+    private fun gridIntrinsicSize(height: Int): Pair<Int, Int> {
+        val columns = max(1, gridColumns)
+        val columnWidths = IntArray(columns)
+        val rowHeights = mutableListOf<Int>()
+        var flowIndex = 0
+        for (index in 0 until childCount) {
+            val child = getChildAt(index)
+            if (child.visibility == GONE) continue
+            val style = styles[child] ?: CraftNativeLayoutStyle()
+            if (style.position == "absolute" || child is CraftNativeModalView) continue
+            val lp = child.layoutParams as? MarginLayoutParams
+            val horizontalMargins = (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
+            val verticalMargins = (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
+            val childWidth = measureChildWidth(child, style, 1_000_000, horizontalMargins)
+            val childHeight = measureChildHeight(child, style, height, verticalMargins)
+            val column = flowIndex % columns
+            val row = flowIndex / columns
+            while (rowHeights.size <= row) rowHeights += gridAutoRows ?: 0
+            columnWidths[column] = max(columnWidths[column], childWidth + horizontalMargins)
+            rowHeights[row] = max(rowHeights[row], childHeight + verticalMargins)
+            flowIndex += 1
+        }
+        val cellWidth = columnWidths.maxOrNull() ?: 0
+        val width = paddingLeft + paddingRight + cellWidth * columns + max(0, columns - 1) * columnGap
+        val rowGapTotal = max(0, rowHeights.size - 1) * rowGap
+        val measuredHeight = paddingTop + paddingBottom + rowHeights.sum() + rowGapTotal
+        return width to measuredHeight
+    }
+
     private fun measureChildWidth(child: View, style: CraftNativeLayoutStyle, available: Int, margins: Int): Int {
-        val explicit = style.width ?: (child.layoutParams?.width ?: ViewGroup.LayoutParams.WRAP_CONTENT).takeIf { it >= 0 }
+        val flexBasis = if (orientation == HORIZONTAL) style.flexBasis else null
+        val explicit = style.width ?: flexBasis
+            ?: (child.layoutParams?.width ?: ViewGroup.LayoutParams.WRAP_CONTENT).takeIf { it >= 0 }
         val target = explicit ?: max(0, available - margins)
         val spec = if (explicit != null) View.MeasureSpec.makeMeasureSpec(target, View.MeasureSpec.EXACTLY)
         else View.MeasureSpec.makeMeasureSpec(max(0, available - margins), View.MeasureSpec.AT_MOST)
@@ -172,7 +305,9 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     }
 
     private fun measureChildHeight(child: View, style: CraftNativeLayoutStyle, available: Int, margins: Int): Int {
-        val explicit = style.height ?: (child.layoutParams?.height ?: ViewGroup.LayoutParams.WRAP_CONTENT).takeIf { it >= 0 }
+        val flexBasis = if (orientation == VERTICAL) style.flexBasis else null
+        val explicit = style.height ?: flexBasis
+            ?: (child.layoutParams?.height ?: ViewGroup.LayoutParams.WRAP_CONTENT).takeIf { it >= 0 }
         val target = explicit ?: max(0, available - margins)
         val spec = if (explicit != null) View.MeasureSpec.makeMeasureSpec(target, View.MeasureSpec.EXACTLY)
         else View.MeasureSpec.makeMeasureSpec(max(0, available - margins), View.MeasureSpec.AT_MOST)
@@ -188,8 +323,24 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     }
 
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        val width = View.MeasureSpec.getSize(widthMeasureSpec).takeUnless { View.MeasureSpec.getMode(widthMeasureSpec) == View.MeasureSpec.UNSPECIFIED } ?: 1_000_000
+        val widthMode = View.MeasureSpec.getMode(widthMeasureSpec)
+        val width = View.MeasureSpec.getSize(widthMeasureSpec).takeUnless { widthMode == View.MeasureSpec.UNSPECIFIED } ?: 1_000_000
         val height = View.MeasureSpec.getSize(heightMeasureSpec).takeUnless { View.MeasureSpec.getMode(heightMeasureSpec) == View.MeasureSpec.UNSPECIFIED } ?: 1_000_000
+        if (grid) {
+            if (widthMode == View.MeasureSpec.UNSPECIFIED) {
+                val (intrinsicWidth, intrinsicHeight) = gridIntrinsicSize(height)
+                setMeasuredDimension(
+                    resolveSize(intrinsicWidth, widthMeasureSpec),
+                    resolveSize(intrinsicHeight, heightMeasureSpec),
+                )
+                return
+            }
+            val layout = gridLayout(width, height)
+            val desiredWidth = paddingLeft + paddingRight + layout.cellWidth * gridColumns + max(0, gridColumns - 1) * columnGap
+            val desiredHeight = paddingTop + paddingBottom + layout.rowHeights.sum() + max(0, layout.rowHeights.size - 1) * rowGap
+            setMeasuredDimension(resolveSize(desiredWidth, widthMeasureSpec), resolveSize(desiredHeight, heightMeasureSpec))
+            return
+        }
         val (lines, absolute) = entries(width, height)
         val main = lines.maxOfOrNull { it.main } ?: 0
         val cross = lines.sumOf { it.cross } + max(0, lines.size - 1) * (if (orientation == HORIZONTAL) rowGap else columnGap)
@@ -204,17 +355,78 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     }
 
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        if (grid) {
+            val layout = gridLayout(width, height)
+            var rowTop = paddingTop
+            for ((rowIndex, row) in layout.rows.withIndex()) {
+                val rowHeight = layout.rowHeights[rowIndex]
+                for ((column, entry) in row.withIndex()) {
+                    val align = entry.style.alignSelf ?: alignItems
+                    val lp = entry.view.layoutParams as? MarginLayoutParams
+                    val marginLeft = lp?.leftMargin ?: 0
+                    val marginRight = lp?.rightMargin ?: 0
+                    val marginTop = lp?.topMargin ?: 0
+                    val marginBottom = lp?.bottomMargin ?: 0
+                    val availableWidth = max(0, layout.cellWidth - marginLeft - marginRight)
+                    val availableHeight = max(0, rowHeight - marginTop - marginBottom)
+                    val childWidth = if (align == "stretch" && entry.style.width == null) availableWidth else min(availableWidth, entry.width)
+                    val childHeight = if (align == "stretch" && entry.style.height == null) availableHeight else min(availableHeight, entry.height)
+                    val x = paddingLeft + column * (layout.cellWidth + columnGap) + marginLeft + when (align) {
+                        "center" -> (availableWidth - childWidth) / 2
+                        "flex-end" -> availableWidth - childWidth
+                        else -> 0
+                    }
+                    val y = rowTop + marginTop + when (align) {
+                        "center" -> (availableHeight - childHeight) / 2
+                        "flex-end" -> availableHeight - childHeight
+                        else -> 0
+                    }
+                    entry.view.layout(x, y, x + childWidth, y + childHeight)
+                }
+                rowTop += rowHeight + rowGap
+            }
+            val contentWidth = width - paddingLeft - paddingRight
+            val contentHeight = height - paddingTop - paddingBottom
+            for (entry in layout.absolute) {
+                if (entry.view is CraftNativeModalView && entry.view.visibility == View.VISIBLE) entry.view.bringToFront()
+                val childWidth = if (entry.style.left != null && entry.style.right != null) contentWidth - entry.style.left!! - entry.style.right!! else entry.width
+                val childHeight = if (entry.style.top != null && entry.style.bottom != null) contentHeight - entry.style.top!! - entry.style.bottom!! else entry.height
+                val x = paddingLeft + (entry.style.left ?: (entry.style.right?.let { contentWidth - it - childWidth } ?: 0))
+                val y = paddingTop + (entry.style.top ?: (entry.style.bottom?.let { contentHeight - it - childHeight } ?: 0))
+                entry.view.layout(x, y, x + max(0, childWidth), y + max(0, childHeight))
+            }
+            onLayoutChanged?.invoke()
+            return
+        }
         val contentWidth = width - paddingLeft - paddingRight
         val contentHeight = height - paddingTop - paddingBottom
         val (lines, absolute) = entries(width, height)
         val gap = if (orientation == HORIZONTAL) columnGap else rowGap
+        val crossGap = if (orientation == HORIZONTAL) rowGap else columnGap
+        val availableMain = if (orientation == HORIZONTAL) contentWidth else contentHeight
         var crossOffset = if (orientation == HORIZONTAL) paddingTop else paddingLeft
         for (line in lines) {
-            val free = max(0, (if (orientation == HORIZONTAL) contentWidth else contentHeight) - line.main)
+            val rawFree = availableMain - line.main
+            val factors = line.entries.map { if (rawFree >= 0) it.style.flexGrow else it.style.flexShrink }
+            val totalFactor = factors.sum()
+            val distributedMain = line.entries.indices.sumOf { index ->
+                val base = if (orientation == HORIZONTAL) line.entries[index].width else line.entries[index].height
+                val primary = if (totalFactor > 0) max(0, (base + rawFree * factors[index] / totalFactor).toInt()) else base
+                val constrained = if (orientation == HORIZONTAL) {
+                    clamp(primary, line.entries[index].style.minWidth, line.entries[index].style.maxWidth)
+                } else {
+                    clamp(primary, line.entries[index].style.minHeight, line.entries[index].style.maxHeight)
+                }
+                val lp = line.entries[index].view.layoutParams as? MarginLayoutParams
+                val margins = if (orientation == HORIZONTAL) (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
+                    else (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
+                constrained + margins
+            } + max(0, line.entries.size - 1) * gap
+            val free = max(0, availableMain - distributedMain)
             val (leading, between) = distribution(free, line.entries.size)
             var mainOffset = if (orientation == HORIZONTAL) paddingLeft else paddingTop
             mainOffset += leading
-            for (entry in line.entries) {
+            for ((index, entry) in line.entries.withIndex()) {
                 val lp = entry.view.layoutParams as? MarginLayoutParams
                 val marginStart = if (orientation == HORIZONTAL) lp?.leftMargin ?: 0 else lp?.topMargin ?: 0
                 val marginEnd = if (orientation == HORIZONTAL) lp?.rightMargin ?: 0 else lp?.bottomMargin ?: 0
@@ -222,27 +434,39 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                     max(0, line.cross - (if (orientation == HORIZONTAL) (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0) else (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)))
                 else if (orientation == HORIZONTAL) entry.height else entry.width
                 val align = entry.style.alignSelf ?: alignItems
+                val crossLeading = if (orientation == HORIZONTAL) lp?.topMargin ?: 0 else lp?.leftMargin ?: 0
+                val crossTrailing = if (orientation == HORIZONTAL) lp?.bottomMargin ?: 0 else lp?.rightMargin ?: 0
+                val crossAvailable = max(0, line.cross - crossLeading - crossTrailing)
                 val crossPosition = when (align) {
-                    "center" -> (line.cross - crossSize) / 2
-                    "flex-end" -> line.cross - crossSize
-                    else -> 0
+                    "center" -> crossLeading + (crossAvailable - crossSize) / 2
+                    "flex-end" -> line.cross - crossTrailing - crossSize
+                    else -> crossLeading
                 }
-                val x = if (orientation == HORIZONTAL) mainOffset + marginStart else crossOffset + crossPosition + (lp?.leftMargin ?: 0)
-                val y = if (orientation == HORIZONTAL) crossOffset + crossPosition + (lp?.topMargin ?: 0) else mainOffset + marginStart
-                val w = if (orientation == HORIZONTAL) entry.width else crossSize
-                val h = if (orientation == HORIZONTAL) crossSize else entry.height
+                val x = if (orientation == HORIZONTAL) mainOffset + marginStart else crossOffset + crossPosition
+                val y = if (orientation == HORIZONTAL) crossOffset + crossPosition else mainOffset + marginStart
+                val primary = if (orientation == HORIZONTAL) entry.width else entry.height
+                val distributed = if (totalFactor > 0) max(0, (primary + rawFree * factors[index] / totalFactor).toInt()) else primary
+                val distributedPrimary = if (orientation == HORIZONTAL) {
+                    clamp(distributed, entry.style.minWidth, entry.style.maxWidth)
+                } else {
+                    clamp(distributed, entry.style.minHeight, entry.style.maxHeight)
+                }
+                val w = if (orientation == HORIZONTAL) distributedPrimary else crossSize
+                val h = if (orientation == HORIZONTAL) crossSize else distributedPrimary
                 entry.view.layout(x, y, x + w, y + h)
-                mainOffset += (if (orientation == HORIZONTAL) entry.width else entry.height) + marginStart + marginEnd + gap + between
+                mainOffset += distributedPrimary + marginStart + marginEnd + gap + between
             }
-            crossOffset += line.cross + gap
+            crossOffset += line.cross + crossGap
         }
         for (entry in absolute) {
+            if (entry.view is CraftNativeModalView && entry.view.visibility == View.VISIBLE) entry.view.bringToFront()
             val widthValue = if (entry.style.left != null && entry.style.right != null) contentWidth - entry.style.left!! - entry.style.right!! else entry.width
             val heightValue = if (entry.style.top != null && entry.style.bottom != null) contentHeight - entry.style.top!! - entry.style.bottom!! else entry.height
             val x = paddingLeft + (entry.style.left ?: (entry.style.right?.let { contentWidth - it - widthValue } ?: 0))
             val y = paddingTop + (entry.style.top ?: (entry.style.bottom?.let { contentHeight - it - heightValue } ?: 0))
             entry.view.layout(x, y, x + max(0, widthValue), y + max(0, heightValue))
         }
+        onLayoutChanged?.invoke()
     }
 
     private fun distribution(free: Int, count: Int): Pair<Int, Int> = when (justifyContent) {
@@ -260,6 +484,11 @@ private class CraftNativeScrollView(context: Context) : FrameLayout(context) {
     private val vertical = ScrollView(context)
     private val horizontal = HorizontalScrollView(context)
     private var horizontalMode: Boolean? = null
+    private var pagingEnabled = false
+    private var bounces = true
+    private var alwaysBounceVertical = true
+    private var alwaysBounceHorizontal = true
+    private var keyboardShouldPersistTaps = "never"
 
     init {
         vertical.isNestedScrollingEnabled = true
@@ -293,6 +522,62 @@ private class CraftNativeScrollView(context: Context) : FrameLayout(context) {
         horizontal.isEnabled = value
     }
 
+    fun setKeyboardShouldPersistTaps(value: String?) {
+        keyboardShouldPersistTaps = value?.takeIf { it in setOf("always", "handled", "never") } ?: "never"
+    }
+
+    fun setBounces(value: Boolean) {
+        bounces = value
+        applyBounceModes()
+    }
+
+    fun setAlwaysBounce(vertical: Boolean, horizontal: Boolean) {
+        alwaysBounceVertical = vertical
+        alwaysBounceHorizontal = horizontal
+        applyBounceModes()
+    }
+
+    private fun applyBounceModes() {
+        vertical.overScrollMode = if (bounces && alwaysBounceVertical) View.OVER_SCROLL_ALWAYS else View.OVER_SCROLL_NEVER
+        horizontal.overScrollMode = if (bounces && alwaysBounceHorizontal) View.OVER_SCROLL_ALWAYS else View.OVER_SCROLL_NEVER
+    }
+
+    private fun tapTarget(view: View, x: Float, y: Float): View? {
+        if (x < 0 || y < 0 || x >= view.width || y >= view.height || view.visibility != View.VISIBLE) return null
+        if (view is ViewGroup) {
+            for (index in view.childCount - 1 downTo 0) {
+                val child = view.getChildAt(index)
+                tapTarget(child, x - child.left, y - child.top)?.let { return it }
+            }
+        }
+        return view
+    }
+
+    private fun shouldDismissKeyboard(scroller: View, event: android.view.MotionEvent): Boolean {
+        if (keyboardShouldPersistTaps == "always") return false
+        return when (keyboardShouldPersistTaps) {
+            "handled" -> (scroller as? ViewGroup)?.let { tapTarget(it, event.x, event.y)?.isClickable != true } ?: true
+            else -> true
+        }
+    }
+
+    fun setPagingEnabled(value: Boolean) {
+        pagingEnabled = value
+    }
+
+    private fun snapToPage(scroller: View) {
+        val horizontal = horizontalMode == true
+        val pageSize = if (horizontal) scroller.width else scroller.height
+        if (pageSize <= 0) return
+        val offset = if (horizontal) scroller.scrollX else scroller.scrollY
+        val target = (offset.toFloat() / pageSize).roundToInt() * pageSize
+        if (horizontal) {
+            (scroller as HorizontalScrollView).smoothScrollTo(target, 0)
+        } else {
+            (scroller as ScrollView).smoothScrollTo(0, target)
+        }
+    }
+
     fun setScrollIndicators(verticalVisible: Boolean, horizontalVisible: Boolean) {
         vertical.isVerticalScrollBarEnabled = verticalVisible
         horizontal.isHorizontalScrollBarEnabled = horizontalVisible
@@ -302,13 +587,65 @@ private class CraftNativeScrollView(context: Context) : FrameLayout(context) {
         onScroll: ((Int, Int) -> Unit)?,
         onBeginDrag: (() -> Unit)?,
         onEndDrag: (() -> Unit)?,
+        onMomentumBegin: (() -> Unit)?,
+        onMomentumEnd: (() -> Unit)?,
+        keyboardDismissMode: String,
+        dismissKeyboard: (() -> Unit)?,
     ) {
         fun attach(scroller: View) {
+            var dismissed = false
+            var moved = false
+            var momentumActive = false
+            var lastX = 0
+            var lastY = 0
+
+            fun pollMomentum() {
+                if (!momentumActive) return
+                val x = scroller.scrollX
+                val y = scroller.scrollY
+                if (x == lastX && y == lastY) {
+                    momentumActive = false
+                    onMomentumEnd?.invoke()
+                } else {
+                    lastX = x
+                    lastY = y
+                    scroller.postDelayed({ pollMomentum() }, 16L)
+                }
+            }
+
             scroller.setOnScrollChangeListener { _, x, y, _, _ -> onScroll?.invoke(x, y) }
             scroller.setOnTouchListener { _, event ->
                 when (event.actionMasked) {
-                    android.view.MotionEvent.ACTION_DOWN -> onBeginDrag?.invoke()
-                    android.view.MotionEvent.ACTION_UP, android.view.MotionEvent.ACTION_CANCEL -> onEndDrag?.invoke()
+                    android.view.MotionEvent.ACTION_DOWN -> {
+                        if (momentumActive) {
+                            momentumActive = false
+                            onMomentumEnd?.invoke()
+                        }
+                        dismissed = false
+                        moved = false
+                        onBeginDrag?.invoke()
+                    }
+                    android.view.MotionEvent.ACTION_MOVE -> {
+                        moved = true
+                        if (!dismissed && keyboardDismissMode in setOf("on-drag", "interactive")) {
+                            dismissed = true
+                            dismissKeyboard?.invoke()
+                        }
+                    }
+                    android.view.MotionEvent.ACTION_UP, android.view.MotionEvent.ACTION_CANCEL -> {
+                        if (event.actionMasked == android.view.MotionEvent.ACTION_UP && shouldDismissKeyboard(scroller, event)) {
+                            dismissKeyboard?.invoke()
+                        }
+                        onEndDrag?.invoke()
+                        if (pagingEnabled) snapToPage(scroller)
+                        if (moved && !momentumActive) {
+                            momentumActive = true
+                            lastX = scroller.scrollX
+                            lastY = scroller.scrollY
+                            onMomentumBegin?.invoke()
+                            scroller.postDelayed({ pollMomentum() }, 16L)
+                        }
+                    }
                 }
                 false
             }
@@ -320,7 +657,54 @@ private class CraftNativeScrollView(context: Context) : FrameLayout(context) {
 
 private class CraftNativeFlexSpacer(context: Context) : View(context)
 
-/** WebView-free host for a compiled stx-native route bundle. */
+private class CraftNativeModalView(context: Context) : FrameLayout(context) {
+    val content = CraftNativeFlexLayout(context)
+    private val blocker = View(context)
+    private var renderedVisible = false
+    var onRequestClose: (() -> Unit)? = null
+
+    var transparent: Boolean = false
+        set(value) {
+            field = value
+            blocker.setBackgroundColor(if (value) Color.TRANSPARENT else Color.argb(82, 0, 0, 0))
+        }
+
+    init {
+        isClickable = true
+        blocker.isClickable = true
+        blocker.setOnTouchListener { _, _ -> true }
+        blocker.setBackgroundColor(Color.argb(82, 0, 0, 0))
+        addView(blocker, LayoutParams(-1, -1))
+        addView(content, LayoutParams(-1, -1))
+    }
+
+    fun setVisible(visible: Boolean, opacity: Float, animationType: String?) {
+        if (renderedVisible == visible && visibility == if (visible) View.VISIBLE else View.GONE) return
+        renderedVisible = visible
+        if (!visible) {
+            animate().cancel()
+            alpha = 0f
+            visibility = View.GONE
+            return
+        }
+        visibility = View.VISIBLE
+        if (animationType == "none") {
+            alpha = opacity
+        } else {
+            alpha = 0f
+            animate().alpha(opacity).setDuration(if (animationType == "slide") 240L else 180L).start()
+        }
+    }
+}
+
+private data class LayoutBounds(
+    val x: Double,
+    val y: Double,
+    val width: Double,
+    val height: Double,
+)
+
+/** WebView-free host for a route bundle compiled by `stx native compile`. */
 class MainActivity : AppCompatActivity() {
     private class Screen(
         val route: String?,
@@ -330,14 +714,34 @@ class MainActivity : AppCompatActivity() {
         val port: MessagePort?
     ) {
         val drafts = mutableMapOf<String, String>()
+        val inputIdentities = mutableMapOf<EditText, String>()
+        val suppressedTextChanges = mutableSetOf<EditText>()
         val controls = mutableMapOf<String, View>()
         val handlers = mutableMapOf<View, String>()
+        val pressInHandlers = mutableMapOf<View, String>()
+        val pressOutHandlers = mutableMapOf<View, String>()
+        val longPressHandlers = mutableMapOf<View, String>()
         val scrollHandlers = mutableMapOf<View, String>()
         val scrollBeginHandlers = mutableMapOf<View, String>()
         val scrollEndHandlers = mutableMapOf<View, String>()
+        val scrollMomentumBeginHandlers = mutableMapOf<View, String>()
+        val scrollMomentumEndHandlers = mutableMapOf<View, String>()
+        val sliderCompleteHandlers = mutableMapOf<View, String>()
+        val sliderSteps = mutableMapOf<View, Double>()
         val focusHandlers = mutableMapOf<View, String>()
         val blurHandlers = mutableMapOf<View, String>()
+        val endEditingHandlers = mutableMapOf<View, String>()
         val submitHandlers = mutableMapOf<View, String>()
+        val imageLoadStartHandlers = mutableMapOf<ImageView, String>()
+        val imageLoadHandlers = mutableMapOf<ImageView, String>()
+        val imageLoadEndHandlers = mutableMapOf<ImageView, String>()
+        val imageErrorHandlers = mutableMapOf<ImageView, String>()
+        val pressActiveOpacities = mutableMapOf<View, Float>()
+        val pressBaseOpacities = mutableMapOf<View, Float>()
+        val modalVisibility = mutableMapOf<View, Boolean>()
+        val modalCloseHandlers = mutableMapOf<View, String>()
+        val layoutHandlers = mutableMapOf<View, String>()
+        val lastLayoutBounds = mutableMapOf<View, LayoutBounds>()
         val flatListRows = mutableMapOf<CraftNativeFlatList, MutableMap<String, MutableMap<String, View>>>()
         val flatListOwners = mutableMapOf<String, String>()
         val flatListOwnerByView = mutableMapOf<CraftNativeFlatList, String>()
@@ -374,14 +778,26 @@ class MainActivity : AppCompatActivity() {
     private val imageSources = mutableMapOf<ImageView, String>()
     private val imageJobs = mutableMapOf<ImageView, Future<*>>()
     private val imageErrors = mutableMapOf<ImageView, String>()
+    private val inputHintDefaults = mutableMapOf<EditText, ColorStateList>()
+    private val inputHighlightDefaults = mutableMapOf<EditText, Int>()
+    private val defaultBackgrounds = mutableMapOf<View, Drawable?>()
 
     override fun onCreate(savedInstanceState: Bundle?) {
+        applyConfiguredAppearance()
         super.onCreate(savedInstanceState)
         initialDeepLink = savedInstanceState?.getString("craft.initialDeepLink")?.let(Uri::parse) ?: intent?.data
         initialDeepLinkClaimed = savedInstanceState?.getBoolean("craft.initialDeepLinkClaimed", false) ?: false
         deliveredInitialDeepLink = savedInstanceState?.getBoolean("craft.deliveredInitialDeepLink", false) ?: false
         setContentView(R.layout.activity_main)
         root = findViewById(R.id.native_root)
+        ViewCompat.setOnApplyWindowInsetsListener(root) { view, insets ->
+            val safe = insets.getInsets(WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout())
+            view.setPadding(safe.left, safe.top, safe.right, safe.bottom)
+            view.requestLayout()
+            view.post { screens.lastOrNull()?.takeIf { it.active }?.let(::emitLayoutEvents) }
+            insets
+        }
+        ViewCompat.requestApplyInsets(root)
         config = runCatching {
             assets.open("craft.config.json").bufferedReader().use {
                 JSONObject(it.readText())
@@ -390,9 +806,7 @@ class MainActivity : AppCompatActivity() {
         hapticsEnabled = config.optBoolean("enableHaptics", false)
         clipboardEnabled = config.optBoolean("enableClipboard", false)
         capabilities = CraftNativeCapabilities(this, config)
-        val background = color(config.optString("backgroundColor", "#1a1a2e"), Color.BLACK)
-        root.setBackgroundColor(background)
-        defaultTextColor = if (Color.luminance(background) < 0.5) Color.WHITE else Color.BLACK
+        refreshThemeDefaults()
         bundle = runCatching {
             assets.open("native-screen.js").bufferedReader().use { it.readText() }
         }.getOrElse {
@@ -433,6 +847,23 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    private fun applyConfiguredAppearance() {
+        val configured = runCatching {
+            assets.open("craft.config.json").bufferedReader().use { JSONObject(it.readText()) }
+        }.getOrNull()
+        val mode = when (configured?.optString("appearance")) {
+            "light" -> AppCompatDelegate.MODE_NIGHT_NO
+            "dark" -> AppCompatDelegate.MODE_NIGHT_YES
+            "system" -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+            else -> if (configured?.optBoolean("darkMode", true) == false) {
+                AppCompatDelegate.MODE_NIGHT_NO
+            } else {
+                AppCompatDelegate.MODE_NIGHT_YES
+            }
+        }
+        AppCompatDelegate.setDefaultNightMode(mode)
+    }
+
     private fun attachSandbox(engine: JavaScriptSandbox) {
         useMessagePorts = engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_MESSAGE_PORTS)
             && engine.isFeatureSupported(JavaScriptSandbox.JS_FEATURE_PROMISE_RETURN)
@@ -470,6 +901,9 @@ class MainActivity : AppCompatActivity() {
             null
         }
         val activeScreen = Screen(route, params, view, isolate, port)
+        activeScreen.view.onLayoutChanged = {
+            if (activeScreen.active) emitLayoutEvents(activeScreen)
+        }
         screen = activeScreen
         screens.add(activeScreen)
         show(activeScreen)
@@ -539,6 +973,7 @@ class MainActivity : AppCompatActivity() {
         root.removeAllViews()
         (screen.view.parent as? ViewGroup)?.removeView(screen.view)
         root.addView(screen.view)
+        refreshScreenTheme(screen)
     }
 
     override fun onSaveInstanceState(outState: Bundle) {
@@ -548,6 +983,43 @@ class MainActivity : AppCompatActivity() {
         super.onSaveInstanceState(outState)
     }
 
+    override fun onConfigurationChanged(newConfig: Configuration) {
+        super.onConfigurationChanged(newConfig)
+        if (!::root.isInitialized) return
+        refreshThemeDefaults()
+        ViewCompat.requestApplyInsets(root)
+        refreshInputDefaultsForTraitChange()
+        screens.lastOrNull()?.let { screen ->
+            refreshScreenTheme(screen)
+        }
+    }
+
+    private fun refreshScreenTheme(screen: Screen) {
+        screen.mutations.node("root")?.let { renderCommitted(screen, it) }
+        screen.controls.values.mapNotNull {
+            when (it) {
+                is CraftNativeRefreshableFlatList -> it.list
+                is CraftNativeFlatList -> it
+                else -> null
+            }
+        }.forEach { it.refreshThemeDefaults() }
+    }
+
+    private fun refreshThemeDefaults() {
+        val background = ContextCompat.getColor(this, R.color.background)
+        root.setBackgroundColor(background)
+        defaultTextColor = if (Color.luminance(background) < 0.5) Color.WHITE else Color.BLACK
+    }
+
+    private fun refreshInputDefaultsForTraitChange() {
+        if (inputHintDefaults.isEmpty() && inputHighlightDefaults.isEmpty()) return
+        val probe = EditText(this)
+        val hintColors = probe.hintTextColors
+        val highlightColor = probe.highlightColor
+        inputHintDefaults.keys.toList().forEach { inputHintDefaults[it] = hintColors }
+        inputHighlightDefaults.keys.toList().forEach { inputHighlightDefaults[it] = highlightColor }
+    }
+
     private fun receive(screen: Screen, raw: String) {
         val message = runCatching { JSONObject(raw) }.getOrNull() ?: return
         val payload = message.optJSONObject("payload") ?: JSONObject()
@@ -679,12 +1151,38 @@ class MainActivity : AppCompatActivity() {
             ?: explicitKey?.let { "${path.substringBeforeLast('.', "")}/$it" }
             ?: path
         val previous = previousControls[identity]
+        val reusableInput = previous as? EditText
         val control = when (type) {
             "Text" -> ((previous as? TextView)?.takeUnless { it is Button || it is EditText } ?: TextView(this)).apply {
+                maxLines = props.optInt("numberOfLines", 0).takeIf { it > 0 } ?: Int.MAX_VALUE
+                ellipsize = when (props.optString("ellipsizeMode")) {
+                    "head" -> TextUtils.TruncateAt.START
+                    "middle" -> TextUtils.TruncateAt.MIDDLE
+                    "tail" -> TextUtils.TruncateAt.END
+                    else -> null
+                }
                 configureText(this, childText(children), style)
             }
+            "Link" -> ((previous as? TextView)?.takeUnless { it is Button } ?: TextView(this)).apply {
+                configureText(this, props.optString("title").ifBlank { childText(children) }, style)
+                val linkColor = props.optString("color").takeIf { it.isNotBlank() } ?: style.optString("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 handler = events.optString("onPress").ifBlank { events.optString("onClick") }
+                if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
+                setOnClickListener {
+                    val current = screen.handlers[this] ?: return@setOnClickListener
+                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                }
+            }
             "Button" -> (previous as? Button ?: Button(this)).apply {
-                text = props.optString("title").ifBlank { childText(children) }
+                val title = props.optString("title").ifBlank { childText(children) }
+                configureText(this, title, style)
+                props.optString("color").takeIf { it.isNotBlank() }?.let { setTextColor(color(it, defaultTextColor)) }
+                isEnabled = !props.optBoolean("disabled", false)
                 val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 setOnClickListener {
@@ -692,26 +1190,62 @@ class MainActivity : AppCompatActivity() {
                     send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                 }
             }
-            "TextInput" -> (previous as? EditText ?: EditText(this)).apply {
+            "TextInput" -> (reusableInput?.takeIf { it.isSingleLine == !props.optBoolean("multiline", false) }
+                ?: EditText(this)).apply {
+                val defaultHintColors = inputHintDefaults.getOrPut(this) {
+                    hintTextColors ?: ColorStateList.valueOf(Color.GRAY)
+                }
+                val defaultHighlightColor = inputHighlightDefaults.getOrPut(this) { highlightColor }
                 hint = props.optString("placeholder")
+                setHintTextColor(
+                    props.optString("placeholderTextColor").takeIf { it.isNotBlank() }
+                        ?.let { ColorStateList.valueOf(color(it, Color.GRAY)) }
+                        ?: defaultHintColors,
+                )
+                highlightColor = props.optString("selectionColor").takeIf { it.isNotBlank() }
+                    ?.let { color(it, defaultHighlightColor) }
+                    ?: defaultHighlightColor
+                val maxLength = props.optInt("maxLength", 0)
+                filters = if (maxLength > 0) arrayOf(InputFilter.LengthFilter(maxLength)) else emptyArray()
                 inputType = inputTypeFor(props)
                 imeOptions = imeOptionsFor(props)
-                isSingleLine = !props.optBoolean("multiline", false)
+                val multiline = props.optBoolean("multiline", false)
+                isSingleLine = !multiline
+                maxLines = if (multiline) props.optInt("numberOfLines", Int.MAX_VALUE).coerceAtLeast(1) else 1
                 isEnabled = props.optBoolean("editable", true)
-                if (props.has("value") && text.toString() != props.optString("value")) setText(props.optString("value"))
+                configureTextStyle(this, style)
+                val controlledValue = props.opt("value")?.takeUnless { it == JSONObject.NULL }?.toString()
+                if (controlledValue != null && text.toString() != controlledValue) {
+                    screen.suppressedTextChanges.add(this)
+                    setTextPreservingSelection(this, controlledValue)
+                }
                 else if (this !== previous && screen.drafts.containsKey(identity)) setText(screen.drafts[identity])
+                else if (this !== previous && props.has("defaultValue") && !props.isNull("defaultValue")) setText(props.optString("defaultValue"))
+                screen.inputIdentities[this] = identity
                 val handler = events.optString("onChange").ifBlank { events.optString("onChangeText") }
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
                 val onFocus = events.optString("onFocus")
                 if (onFocus.isNotBlank()) screen.focusHandlers[this] = onFocus else screen.focusHandlers.remove(this)
-                val onBlur = events.optString("onBlur").ifBlank { events.optString("onEndEditing") }
+                val onBlur = events.optString("onBlur")
                 if (onBlur.isNotBlank()) screen.blurHandlers[this] = onBlur else screen.blurHandlers.remove(this)
+                val onEndEditing = events.optString("onEndEditing")
+                if (onEndEditing.isNotBlank()) screen.endEditingHandlers[this] = onEndEditing else screen.endEditingHandlers.remove(this)
                 val onSubmit = events.optString("onSubmitEditing")
                 if (onSubmit.isNotBlank()) screen.submitHandlers[this] = onSubmit else screen.submitHandlers.remove(this)
                 setOnFocusChangeListener { view, focused ->
-                    val current = if (focused) screen.focusHandlers[view] else screen.blurHandlers[view]
-                    if (current == null) return@setOnFocusChangeListener
-                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("text", text.toString())))
+                    val nativeEvent = JSONObject().put("text", text.toString())
+                    if (focused) {
+                        screen.focusHandlers[view]?.let { current ->
+                            send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", nativeEvent))
+                        }
+                    } else {
+                        screen.blurHandlers[view]?.let { current ->
+                            send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", nativeEvent))
+                        }
+                        screen.endEditingHandlers[view]?.let { current ->
+                            send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", nativeEvent))
+                        }
+                    }
                 }
                 setOnEditorActionListener { view, actionId, event ->
                     val submitted = actionId != EditorInfo.IME_ACTION_NONE || event?.keyCode == KeyEvent.KEYCODE_ENTER
@@ -720,16 +1254,19 @@ class MainActivity : AppCompatActivity() {
                     send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("text", text.toString())))
                     true
                 }
-                if (props.optBoolean("autoFocus", false)) post {
-                    requestFocus()
-                    (getSystemService(INPUT_METHOD_SERVICE) as? android.view.inputmethod.InputMethodManager)
-                        ?.showSoftInput(this, android.view.inputmethod.InputMethodManager.SHOW_IMPLICIT)
+                if (props.optBoolean("autoFocus", false) && !isFocused) post {
+                    if (!isFocused) {
+                        requestFocus()
+                        (getSystemService(INPUT_METHOD_SERVICE) as? android.view.inputmethod.InputMethodManager)
+                            ?.showSoftInput(this, android.view.inputmethod.InputMethodManager.SHOW_IMPLICIT)
+                    }
                 }
                 if (this !== previous) addTextChangedListener(object : TextWatcher {
                     override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
                     override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
                         val updated = s?.toString().orEmpty()
                         screen.drafts[identity] = updated
+                        if (screen.suppressedTextChanges.remove(this@apply)) return
                         val current = screen.handlers[this@apply] ?: return
                         send(screen, "EVENT", JSONObject()
                             .put("handlerName", current)
@@ -738,6 +1275,150 @@ class MainActivity : AppCompatActivity() {
                     override fun afterTextChanged(s: Editable?) {}
                 })
             }
+            "Picker" -> (previous as? Spinner ?: Spinner(this)).apply {
+                val options = (0 until children.length()).mapNotNull { index ->
+                    val option = children.optJSONObject(index) ?: return@mapNotNull null
+                    if (option.optString("type") != "Text") return@mapNotNull null
+                    val label = (option.optJSONArray("children") ?: JSONArray()).let { text ->
+                        (0 until text.length()).joinToString("") { text.optString(it) }
+                    }
+                    if (label.isBlank()) return@mapNotNull null
+                    val optionProps = option.optJSONObject("props")
+                    val value = optionProps?.optString("value").takeIf { !it.isNullOrBlank() } ?: label
+                    value to label
+                }
+                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 selected = options.indexOfFirst { it.first == requested }.takeIf { it >= 0 } ?: 0
+                isEnabled = !props.optBoolean("disabled", false)
+                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
+                onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+                    override fun onNothingSelected(parent: AdapterView<*>?) = Unit
+                    override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
+                        val current = screen.handlers[this@apply] ?: return
+                        val option = options.getOrNull(position) ?: return
+                        send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()
+                            .put("value", option.first).put("index", position)))
+                    }
+                }
+                setSelection(selected, false)
+            }
+            "Modal" -> (previous as? CraftNativeModalView ?: CraftNativeModalView(this)).apply {
+                transparent = props.optBoolean("transparent", false)
+                content.configure(style, resources.displayMetrics.density)
+                reconcileChildren(screen, content, children, path, next, style, previousControls)
+                val visible = props.optBoolean("visible", false)
+                val wasVisible = screen.modalVisibility[this]
+                screen.modalVisibility[this] = visible
+                val requestClose = events.optString("onRequestClose")
+                if (requestClose.isNotBlank()) screen.modalCloseHandlers[this] = requestClose else screen.modalCloseHandlers.remove(this)
+                setVisible(visible, style.optDouble("opacity", 1.0).toFloat(), props.optString("animationType").ifBlank { null })
+                if (wasVisible != visible && (visible || wasVisible == true)) {
+                    val lifecycleHandler = if (visible) events.optString("onShow") else events.optString("onDismiss")
+                    if (lifecycleHandler.isNotBlank()) {
+                        send(screen, "EVENT", JSONObject().put("handlerName", lifecycleHandler).put("nativeEvent", JSONObject()))
+                    }
+                }
+            }
+            "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()
+                reconcileChildren(screen, this, children, path, next, style, previousControls)
+            }
+            "Switch" -> (previous as? Switch ?: Switch(this)).apply {
+                setOnCheckedChangeListener(null)
+                val requestedValue = props.opt("value")
+                isChecked = if (requestedValue != null && requestedValue != JSONObject.NULL) {
+                    props.optBoolean("value")
+                } else {
+                    props.optBoolean("checked", false)
+                }
+                isEnabled = !props.optBoolean("disabled", false)
+                props.optJSONObject("trackColor")?.let { track ->
+                    val falseColor = color(track.optString("false"), Color.GRAY)
+                    val trueColor = color(track.optString("true"), falseColor)
+                    trackTintList = ColorStateList(
+                        arrayOf(intArrayOf(android.R.attr.state_checked), intArrayOf()),
+                        intArrayOf(trueColor, falseColor),
+                    )
+                } ?: run { trackTintList = null }
+                thumbTintList = props.optString("thumbColor").takeIf { it.isNotBlank() }
+                    ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
+                setOnCheckedChangeListener { _, checked ->
+                    val current = screen.handlers[this] ?: return@setOnCheckedChangeListener
+                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("value", checked)))
+                }
+            }
+            "Slider" -> (previous as? SeekBar ?: SeekBar(this)).apply {
+                val minimum = props.optDouble("minimumValue", 0.0)
+                val maximumCandidate = props.optDouble("maximumValue", 1.0)
+                val maximum = if (maximumCandidate > minimum) maximumCandidate else minimum + Double.MIN_VALUE
+                max = 1000
+                setOnSeekBarChangeListener(null)
+                val step = props.optDouble("step", 0.0).takeIf { it > 0 }
+                val requested = props.optDouble("value", minimum)
+                val value = if (step != null) minimum + ((requested - minimum) / step).roundToInt() * step else requested
+                progress = (((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() }
+                    ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+                progressBackgroundTintList = props.optString("maximumTrackTintColor").takeIf { it.isNotBlank() }
+                    ?.let { ColorStateList.valueOf(color(it, Color.GRAY)) }
+                thumbTintList = props.optString("thumbTintColor").takeIf { it.isNotBlank() }
+                    ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+                isEnabled = !props.optBoolean("disabled", false)
+                val handler = events.optString("onValueChange").ifBlank { events.optString("onChange") }
+                if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
+                val complete = events.optString("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) {
+                        val current = screen.handlers[seekBar] ?: return
+                        val raw = minimum + (maximum - minimum) * progress.toDouble() / max.toDouble()
+                        val step = screen.sliderSteps[seekBar]
+                        val value = if (step != null) minimum + ((raw - minimum) / step).roundToInt() * step else raw
+                        if (step != null) {
+                            val snappedProgress = (((value - minimum) / (maximum - minimum)) * max)
+                                .roundToInt().coerceIn(0, max)
+                            if (seekBar.progress != snappedProgress) {
+                                seekBar.progress = snappedProgress
+                                return
+                            }
+                        }
+                        send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("value", value)))
+                    }
+                    override fun onStartTrackingTouch(seekBar: SeekBar) {}
+                    override fun onStopTrackingTouch(seekBar: SeekBar) {
+                        val current = screen.sliderCompleteHandlers[seekBar] ?: return
+                        val raw = minimum + (maximum - minimum) * seekBar.progress.toDouble() / max.toDouble()
+                        val step = screen.sliderSteps[seekBar]
+                        val value = if (step != null) minimum + ((raw - minimum) / step).roundToInt() * step else raw
+                        send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("value", value)))
+                    }
+                })
+            }
+            "ActivityIndicator" -> (previous as? android.widget.ProgressBar ?: android.widget.ProgressBar(this)).apply {
+                val requestedSize = props.opt("size")
+                val scale = when (requestedSize) {
+                    "large" -> 1.35f
+                    "small" -> 0.75f
+                    is Number -> (requestedSize.toDouble() / 24.0).toFloat().coerceAtLeast(0.5f)
+                    else -> 1f
+                }
+                scaleX = scale
+                scaleY = scale
+                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() }
+                    ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+            }
             "Image" -> (previous as? ImageView ?: ImageView(this)).apply {
                 scaleType = when (style.optString("resizeMode").ifBlank { props.optString("resizeMode") }) {
                     "cover" -> ImageView.ScaleType.CENTER_CROP
@@ -746,10 +1427,18 @@ class MainActivity : AppCompatActivity() {
                     else -> ImageView.ScaleType.CENTER_INSIDE
                 }
                 adjustViewBounds = false
-                updateImage(this, props.opt("source"))
+                val onLoadStart = events.optString("onLoadStart")
+                if (onLoadStart.isNotBlank()) screen.imageLoadStartHandlers[this] = onLoadStart else screen.imageLoadStartHandlers.remove(this)
+                val onLoad = events.optString("onLoad")
+                if (onLoad.isNotBlank()) screen.imageLoadHandlers[this] = onLoad else screen.imageLoadHandlers.remove(this)
+                val onLoadEnd = events.optString("onLoadEnd")
+                if (onLoadEnd.isNotBlank()) screen.imageLoadEndHandlers[this] = onLoadEnd else screen.imageLoadEndHandlers.remove(this)
+                val onError = events.optString("onError")
+                if (onError.isNotBlank()) screen.imageErrorHandlers[this] = onError else screen.imageErrorHandlers.remove(this)
+                updateImage(screen, this, props.opt("source"))
             }
             "ScrollView" -> (previous as? CraftNativeScrollView ?: CraftNativeScrollView(this)).apply {
-                val horizontal = props.optBoolean("horizontal", false) || style.optString("flexDirection") == "row"
+                val horizontal = props.optBoolean("horizontal", false) || style.optString("flexDirection") in setOf("row", "row-reverse")
                 setHorizontal(horizontal)
                 setNativeNestedScrollingEnabled(true)
                 setScrollIndicators(
@@ -757,12 +1446,23 @@ class MainActivity : AppCompatActivity() {
                     props.optBoolean("showsHorizontalScrollIndicator", true),
                 )
                 setScrollEnabled(props.optBoolean("scrollEnabled", true))
+                setKeyboardShouldPersistTaps(props.optString("keyboardShouldPersistTaps", "never"))
+                setBounces(props.optBoolean("bounces", true))
+                setAlwaysBounce(
+                    props.optBoolean("alwaysBounceVertical", !horizontal),
+                    props.optBoolean("alwaysBounceHorizontal", horizontal),
+                )
+                setPagingEnabled(props.optBoolean("pagingEnabled", false))
                 val onScroll = events.optString("onScroll")
                 if (onScroll.isNotBlank()) screen.scrollHandlers[this] = onScroll else screen.scrollHandlers.remove(this)
                 val onBegin = events.optString("onScrollBeginDrag")
                 if (onBegin.isNotBlank()) screen.scrollBeginHandlers[this] = onBegin else screen.scrollBeginHandlers.remove(this)
                 val onEnd = events.optString("onScrollEndDrag")
                 if (onEnd.isNotBlank()) screen.scrollEndHandlers[this] = onEnd else screen.scrollEndHandlers.remove(this)
+                val onMomentumBegin = events.optString("onMomentumScrollBegin")
+                if (onMomentumBegin.isNotBlank()) screen.scrollMomentumBeginHandlers[this] = onMomentumBegin else screen.scrollMomentumBeginHandlers.remove(this)
+                val onMomentumEnd = events.optString("onMomentumScrollEnd")
+                if (onMomentumEnd.isNotBlank()) screen.scrollMomentumEndHandlers[this] = onMomentumEnd else screen.scrollMomentumEndHandlers.remove(this)
                 val nativeScroll = this
                 setScrollListeners(
                     onScroll = { scrollX, scrollY ->
@@ -784,40 +1484,141 @@ class MainActivity : AppCompatActivity() {
                             send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
                         }
                     },
+                    onMomentumBegin = {
+                        screen.scrollMomentumBeginHandlers[nativeScroll]?.let { current ->
+                            send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                        }
+                    },
+                    onMomentumEnd = {
+                        screen.scrollMomentumEndHandlers[nativeScroll]?.let { current ->
+                            send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                        }
+                    },
+                    keyboardDismissMode = props.optString("keyboardDismissMode"),
+                    dismissKeyboard = {
+                        (getSystemService(INPUT_METHOD_SERVICE) as? android.view.inputmethod.InputMethodManager)
+                            ?.hideSoftInputFromWindow(nativeScroll.windowToken, 0)
+                    },
                 )
-                configureContainer(content, style)
-                reconcileChildren(screen, content, children, path, next, style, previousControls)
+                val contentStyle = JSONObject(style.toString()).apply {
+                    props.optJSONObject("contentContainerStyle")?.let { override ->
+                        override.keys().forEach { key -> put(key, override.get(key)) }
+                    }
+                }
+                configureContainer(content, contentStyle)
+                reconcileChildren(screen, content, children, path, next, contentStyle, previousControls)
             }
-            "FlatList" -> (previous as? CraftNativeFlatList ?: CraftNativeFlatList(this)).apply {
-                reconcileFlatList(screen, this, children, path, protocolId ?: path, props, events)
+            "FlatList" -> (previous as? CraftNativeRefreshableFlatList ?: CraftNativeRefreshableFlatList(this)).apply {
+                val nativeList = list
+                configureRefresh(events.optString("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"))
+                nativeList.setContentContainerStyle(props.optJSONObject("contentContainerStyle"), resources.displayMetrics.density)
+                nativeList.setKeyboardDismissMode(props.optString("keyboardDismissMode")) {
+                    (getSystemService(INPUT_METHOD_SERVICE) as? android.view.inputmethod.InputMethodManager)
+                        ?.hideSoftInputFromWindow(windowToken, 0)
+                }
+                nativeList.overScrollMode = if (props.optBoolean("bounces", true)) View.OVER_SCROLL_ALWAYS else View.OVER_SCROLL_NEVER
+                reconcileFlatList(screen, nativeList, children, path, protocolId ?: path, props, events)
+            }
+            "View", "SafeAreaView" -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
+                configureContainer(this, style)
+                reconcileChildren(screen, this, children, path, next, style, previousControls)
             }
             else -> (previous as? CraftNativeFlexLayout ?: CraftNativeFlexLayout(this)).apply {
                 configureContainer(this, style)
                 reconcileChildren(screen, this, children, path, next, style, previousControls)
             }
         }
-        if (type != "Button" && type != "TextInput") {
+        val pressInHandler = events.optString("onPressIn").takeIf { it.isNotBlank() }
+        val pressOutHandler = events.optString("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 != "Modal" && type != "Switch" && type != "Slider" && type != "ActivityIndicator") {
             val handler = events.optString("onPress").ifBlank { events.optString("onClick") }
-            if (handler.isNotBlank()) {
-                screen.handlers[control] = handler
+            val disabled = props.optBoolean("disabled", false)
+            val hasPressLifecycle = pressInHandler != null || pressOutHandler != null
+            if ((handler.isNotBlank() || (type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable") && hasPressLifecycle)) && !disabled) {
+                if (handler.isNotBlank()) screen.handlers[control] = handler else screen.handlers.remove(control)
                 control.isClickable = true
-                control.setOnClickListener {
-                    val current = screen.handlers[control] ?: return@setOnClickListener
-                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                if (type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable")) {
+                    control.setOnClickListener(null)
+                    control.setOnTouchListener { view, event ->
+                        when (event.actionMasked) {
+                            android.view.MotionEvent.ACTION_DOWN -> {
+                                val active = screen.pressActiveOpacities[view] ?: 0.5f
+                                val base = screen.pressBaseOpacities[view] ?: 1f
+                                view.alpha = base * active
+                                screen.pressInHandlers[view]?.let { current ->
+                                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                                }
+                                true
+                            }
+                            android.view.MotionEvent.ACTION_UP, android.view.MotionEvent.ACTION_CANCEL -> {
+                                view.alpha = screen.pressBaseOpacities[view] ?: 1f
+                                screen.pressOutHandlers[view]?.let { current ->
+                                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                                }
+                                if (event.actionMasked == android.view.MotionEvent.ACTION_UP) {
+                                    val current = screen.handlers[view] ?: return@setOnTouchListener true
+                                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                                }
+                                true
+                            }
+                            else -> true
+                        }
+                    }
+                } else {
+                    control.setOnTouchListener(null)
+                    control.setOnClickListener {
+                        val current = screen.handlers[control] ?: return@setOnClickListener
+                        send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                    }
                 }
             } else {
                 screen.handlers.remove(control)
                 control.isClickable = false
                 control.setOnClickListener(null)
+                control.setOnTouchListener(null)
             }
+            control.isEnabled = !disabled
+        }
+        val longPressHandler = events.optString("onLongPress").takeUnless { props.optBoolean("disabled", false) } ?: ""
+        if (longPressHandler.isNotBlank()) {
+            screen.longPressHandlers[control] = longPressHandler
+            control.setOnLongClickListener {
+                val current = screen.longPressHandlers[control] ?: return@setOnLongClickListener false
+                send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject()))
+                true
+            }
+        } else {
+            screen.longPressHandlers.remove(control)
+            control.setOnLongClickListener(null)
         }
         applyAccessibility(control, props, type, explicitKey ?: protocolId ?: path)
-        if (control is ImageView) imageErrors[control]?.let { control.contentDescription = "${control.contentDescription}, $it" }
+        val layoutHandler = events.optString("onLayout")
+        if (layoutHandler.isNotBlank()) {
+            if (screen.layoutHandlers[control] != layoutHandler) screen.lastLayoutBounds.remove(control)
+            screen.layoutHandlers[control] = layoutHandler
+        } else {
+            screen.layoutHandlers.remove(control)
+            screen.lastLayoutBounds.remove(control)
+        }
+        if (control is ImageView) imageErrors[control]?.let { message ->
+            val current = control.contentDescription?.toString().orEmpty()
+            if (!current.contains(message)) {
+                control.contentDescription = listOf(current, message).filter { it.isNotBlank() }.joinToString(", ")
+            }
+        }
         next[identity] = control
         applyViewStyle(control, style)
+        if (type == "Modal" && !props.optBoolean("visible", false)) control.visibility = View.GONE
+        val width = style.optDouble("width", Double.NaN).takeUnless { it.isNaN() }?.let(::dp)
+        val height = style.optDouble("height", Double.NaN).takeUnless { it.isNaN() }?.let(::dp)
         control.layoutParams = LinearLayout.LayoutParams(
-            if (style.has("width")) dp(style.optDouble("width")) else ViewGroup.LayoutParams.WRAP_CONTENT,
-            if (style.has("height")) dp(style.optDouble("height")) else ViewGroup.LayoutParams.WRAP_CONTENT
+            width ?: ViewGroup.LayoutParams.WRAP_CONTENT,
+            height ?: ViewGroup.LayoutParams.WRAP_CONTENT
         ).apply {
             val margin = style.optDouble("margin", 0.0)
             val horizontal = style.optDouble("marginHorizontal", margin)
@@ -843,6 +1644,17 @@ class MainActivity : AppCompatActivity() {
         layout.configure(style, resources.displayMetrics.density)
     }
 
+    private fun flatListScrollEvent(list: CraftNativeFlatList): JSONObject = JSONObject()
+        .put("contentOffset", JSONObject()
+            .put("x", list.computeHorizontalScrollOffset())
+            .put("y", list.computeVerticalScrollOffset()))
+        .put("contentSize", JSONObject()
+            .put("width", list.computeHorizontalScrollRange())
+            .put("height", list.computeVerticalScrollRange()))
+        .put("layoutMeasurement", JSONObject()
+            .put("width", list.width)
+            .put("height", list.height))
+
     private fun reconcileChildren(
         screen: Screen,
         layout: CraftNativeFlexLayout,
@@ -895,17 +1707,35 @@ class MainActivity : AppCompatActivity() {
     ) {
         screen.flatListOwners.entries.removeAll { it.value == owner }
         screen.flatListOwnerByView[list] = owner
+        list.onLayoutChanged = {
+            if (screen.active) emitLayoutEvents(screen)
+        }
         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 ->
+            { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
+        }
+        list.onScrollBeginDrag = events.optString("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 ->
+            { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
+        }
+        list.onMomentumScrollBegin = events.optString("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 ->
+            { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", flatListScrollEvent(list))) }
+        }
         list.apply(
             nodes = nodes,
             horizontal = props.optBoolean("horizontal", false),
             columns = props.optInt("numColumns", 1),
             inverted = props.optBoolean("inverted", false),
-            endReachedThreshold = when {
-                props.has("onEndReachedThreshold") -> props.optDouble("onEndReachedThreshold", 0.1)
-                else -> props.optDouble("threshold", 0.1)
-            },
+            endReachedThreshold = props.opt("onEndReachedThreshold")
+                ?.takeUnless { it == JSONObject.NULL }
+                ?.let { props.optDouble("onEndReachedThreshold", 0.1) }
+                ?: props.optDouble("threshold", 0.1),
             renderItem = { node, itemIdentity, _ ->
                 val rows = screen.flatListRows.getOrPut(list) { mutableMapOf() }
                 val previous = rows[itemIdentity].orEmpty()
@@ -917,7 +1747,7 @@ class MainActivity : AppCompatActivity() {
             },
             recycleItem = { itemIdentity ->
                 val controls = screen.flatListRows[list]?.remove(itemIdentity).orEmpty()
-                releaseViewState(screen, controls.values.toList())
+                releaseViewState(screen, controls.values.toList(), preservingInputDrafts = true)
             },
             endReached = events.optString("onEndReached").takeIf { it.isNotBlank() }?.let { handler ->
                 { send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject())) }
@@ -942,21 +1772,26 @@ class MainActivity : AppCompatActivity() {
         view.alpha = style.optDouble("opacity", 1.0).toFloat()
         view.visibility = if (style.optString("display") == "none") View.GONE else View.VISIBLE
         view.elevation = dp(style.optDouble("elevation", 0.0)).toFloat()
-        val background = style.has("backgroundColor")
+        val background = style.has("backgroundColor") && !style.isNull("backgroundColor")
         val border = style.optDouble("borderWidth", 0.0)
         val radius = style.optDouble("borderRadius", 0.0)
+        val defaultBackground = if (defaultBackgrounds.containsKey(view)) {
+            defaultBackgrounds[view]
+        } else {
+            view.background.also { defaultBackgrounds[view] = it }
+        }
         if (background || border > 0 || radius > 0) {
             view.background = GradientDrawable().apply {
                 setColor(color(style.optString("backgroundColor"), Color.TRANSPARENT))
                 cornerRadius = dp(radius).toFloat()
                 if (border > 0) setStroke(dp(border), color(style.optString("borderColor"), Color.TRANSPARENT))
             }
-        }
+        } else view.background = defaultBackground
         view.clipToOutline = style.optString("overflow") == "hidden"
         if (view is ViewGroup) view.clipChildren = style.optString("overflow") == "hidden"
         if (view is ImageView) {
-            if (style.has("tintColor")) view.setColorFilter(color(style.optString("tintColor"), Color.TRANSPARENT))
-            else view.clearColorFilter()
+            style.optString("tintColor").takeIf { it.isNotBlank() }?.let { view.setColorFilter(color(it, Color.TRANSPARENT)) }
+                ?: view.clearColorFilter()
         }
     }
 
@@ -967,8 +1802,12 @@ class MainActivity : AppCompatActivity() {
             "capitalize" -> value.split(' ').joinToString(" ") { word -> word.replaceFirstChar(Char::uppercase) }
             else -> value
         }
+        configureTextStyle(view, style)
+    }
+
+    private fun configureTextStyle(view: TextView, style: JSONObject) {
         view.setTextColor(color(style.optString("color"), defaultTextColor))
-        view.setTextSize(TypedValue.COMPLEX_UNIT_SP, style.optDouble("fontSize", 14.0).toFloat())
+        view.setTextSize(TypedValue.COMPLEX_UNIT_SP, style.optDouble("fontSize", 16.0).toFloat())
         val weight = when (style.optString("fontWeight")) {
             "bold" -> 700
             "100", "200", "300", "400", "500", "600", "700", "800", "900" -> style.optInt("fontWeight")
@@ -987,10 +1826,19 @@ class MainActivity : AppCompatActivity() {
             "justify" -> View.TEXT_ALIGNMENT_VIEW_START
             else -> View.TEXT_ALIGNMENT_INHERIT
         }
-        view.letterSpacing = if (style.has("letterSpacing") && view.textSize > 0)
-            dp(style.optDouble("letterSpacing")).toFloat() / view.textSize else 0f
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            view.justificationMode = if (style.optString("textAlign") == "justify") {
+                Layout.JUSTIFICATION_MODE_INTER_WORD
+            } else {
+                Layout.JUSTIFICATION_MODE_NONE
+            }
+        }
+        view.letterSpacing = style.optDouble("letterSpacing", Double.NaN)
+            .takeUnless { it.isNaN() }
+            ?.let { if (view.textSize > 0) dp(it).toFloat() / view.textSize else 0f }
+            ?: 0f
         view.setLineSpacing(
-            if (style.has("lineHeight")) dp(style.optDouble("lineHeight")) - view.textSize else 0f,
+            style.optDouble("lineHeight", Double.NaN).takeUnless { it.isNaN() }?.let { dp(it) - view.textSize } ?: 0f,
             1f
         )
         view.paintFlags = view.paintFlags and Paint.UNDERLINE_TEXT_FLAG.inv() and Paint.STRIKE_THRU_TEXT_FLAG.inv()
@@ -1002,7 +1850,7 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
-    private fun updateImage(view: ImageView, source: Any?) {
+    private fun updateImage(screen: Screen, view: ImageView, source: Any?) {
         val uri = when (source) {
             is String -> source
             is JSONObject -> source.optString("uri")
@@ -1013,6 +1861,7 @@ class MainActivity : AppCompatActivity() {
             imageSources.remove(view)
             imageErrors[view] = "Image source is missing"
             view.setImageDrawable(null)
+            imageFailure(screen, view, uri, "Image source is missing")
             return
         }
         if (imageSources[view] == uri) return
@@ -1020,20 +1869,29 @@ class MainActivity : AppCompatActivity() {
         imageSources[view] = uri
         imageErrors.remove(view)
         view.setImageDrawable(null)
+        emitImageEvent(screen, view, screen.imageLoadStartHandlers[view])
 
         if (uri.startsWith("data:image/") && uri.contains(',')) {
             val bytes = runCatching { Base64.decode(uri.substringAfter(','), Base64.DEFAULT) }.getOrNull()
             val bitmap = bytes?.let { BitmapFactory.decodeByteArray(it, 0, it.size) }
-            if (bitmap != null) view.setImageBitmap(bitmap) else imageFailure(view, uri, "Image data is invalid")
+            if (bitmap != null) {
+                view.setImageBitmap(bitmap)
+                emitImageEvent(screen, view, screen.imageLoadHandlers[view])
+                emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
+            } else imageFailure(screen, view, uri, "Image data is invalid")
             return
         }
         if (!uri.contains(':')) {
             val bitmap = runCatching { assets.open(uri).use { BitmapFactory.decodeStream(it) } }.getOrNull()
-            if (bitmap != null) view.setImageBitmap(bitmap) else imageFailure(view, uri, "Bundled image was not found")
+            if (bitmap != null) {
+                view.setImageBitmap(bitmap)
+                emitImageEvent(screen, view, screen.imageLoadHandlers[view])
+                emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
+            } else imageFailure(screen, view, uri, "Bundled image was not found")
             return
         }
         if (!uri.startsWith("https://")) {
-            imageFailure(view, uri, "Unsupported image source")
+            imageFailure(screen, view, uri, "Unsupported image source")
             return
         }
         imageJobs[view] = imageExecutor.submit {
@@ -1047,27 +1905,68 @@ class MainActivity : AppCompatActivity() {
             runOnUiThread {
                 if (imageSources[view] != uri) return@runOnUiThread
                 imageJobs.remove(view)
-                if (bitmap != null) view.setImageBitmap(bitmap) else imageFailure(view, uri, "Image download failed")
+                if (bitmap != null) {
+                    view.setImageBitmap(bitmap)
+                    emitImageEvent(screen, view, screen.imageLoadHandlers[view])
+                    emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
+                } else imageFailure(screen, view, uri, "Image download failed")
             }
         }
     }
 
-    private fun imageFailure(view: ImageView, uri: String, message: String) {
+    private fun imageFailure(screen: Screen, view: ImageView, uri: String, message: String) {
         imageErrors[view] = message
         view.setImageDrawable(null)
-        view.contentDescription = "${view.tag ?: "Image"}, $message"
+        val current = view.contentDescription?.toString().orEmpty()
+        if (!current.contains(message)) {
+            view.contentDescription = listOf(
+                current.ifBlank { view.tag?.toString() ?: "Image" },
+                message,
+            ).joinToString(", ")
+        }
+        emitImageEvent(screen, view, screen.imageErrorHandlers[view], JSONObject().put("error", JSONObject().put("message", message)))
+        emitImageEvent(screen, view, screen.imageLoadEndHandlers[view])
         Log.e(TAG, "$message: $uri")
     }
 
+    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))
+    }
+
+    private fun setTextPreservingSelection(field: EditText, value: String) {
+        val start = field.selectionStart
+        val end = field.selectionEnd
+        field.setText(value)
+        if (start < 0 || end < 0) {
+            field.setSelection(value.length)
+            return
+        }
+        val boundedStart = start.coerceIn(0, value.length)
+        val boundedEnd = end.coerceIn(0, value.length)
+        field.setSelection(minOf(boundedStart, boundedEnd), maxOf(boundedStart, boundedEnd))
+    }
+
     private fun applyAccessibility(view: View, props: JSONObject, type: String, fallbackLabel: String) {
         view.tag = fallbackLabel
-        view.contentDescription = props.optString("accessibilityLabel").ifBlank { fallbackLabel }
-        props.opt("accessibilityValue")?.takeUnless { it == JSONObject.NULL }?.let { view.contentDescription = "${view.contentDescription}, $it" }
-        props.optString("accessibilityHint").takeIf { it.isNotBlank() }?.let { view.tooltipText = it }
+        val label = props.optString("accessibilityLabel").takeIf { it.isNotBlank() }
+            ?: props.optString("alt").takeIf { type == "Image" && it.isNotBlank() }
+        val value = props.opt("accessibilityValue")?.takeUnless { it == JSONObject.NULL }?.toString()
+        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 { type.lowercase() }
         val state = props.optJSONObject("accessibilityState")
         val disabled = state?.optBoolean("disabled", false) == true
-        if (state != null && state.has("disabled")) view.isEnabled = !disabled
+        if (type !in setOf("Button", "Link", "TextInput", "Picker", "Modal", "Switch", "Slider", "ActivityIndicator")) {
+            view.isEnabled = !disabled
+        } else if (disabled) {
+            view.isEnabled = false
+        }
         ViewCompat.setAccessibilityDelegate(view, object : AccessibilityDelegateCompat() {
             override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
                 super.onInitializeAccessibilityNodeInfo(host, info)
@@ -1080,7 +1979,8 @@ class MainActivity : AppCompatActivity() {
                 }
                 info.isHeading = role == "header"
                 info.roleDescription = role.takeIf { it !in setOf("view", "text", "textinput", "scrollview") }
-                info.isEnabled = !disabled
+                info.hintText = host.tooltipText
+                info.isEnabled = host.isEnabled && !disabled
                 info.isSelected = state?.optBoolean("selected", false) == true
                 info.isChecked = state?.optBoolean("checked", false) == true
             }
@@ -1100,9 +2000,11 @@ class MainActivity : AppCompatActivity() {
         val keyboard = when (props.optString("keyboardType")) {
             "email-address" -> InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
             "url" -> InputType.TYPE_TEXT_VARIATION_URI
-            "numeric" -> InputType.TYPE_CLASS_NUMBER
+            "numeric", "number-pad" -> InputType.TYPE_CLASS_NUMBER
             "decimal-pad" -> InputType.TYPE_CLASS_NUMBER or InputType.TYPE_NUMBER_FLAG_DECIMAL
             "phone-pad" -> InputType.TYPE_CLASS_PHONE
+            "web-search" -> InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT
+            "visible-password" -> InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD
             else -> 0
         }
         val capitalization = when (props.optString("autoCapitalize")) {
@@ -1243,6 +2145,36 @@ class MainActivity : AppCompatActivity() {
         return initialDeepLink
     }
 
+    private fun emitLayoutEvents(screen: Screen) {
+        emitLayoutEvents(screen, screen.view)
+    }
+
+    private fun emitLayoutEvents(screen: Screen, view: View) {
+        val handler = screen.layoutHandlers[view]
+        if (handler != null && view.isShown) {
+            val density = resources.displayMetrics.density
+            val bounds = LayoutBounds(
+                x = view.left.toDouble() / density.toDouble(),
+                y = view.top.toDouble() / density.toDouble(),
+                width = view.width.toDouble() / density.toDouble(),
+                height = view.height.toDouble() / density.toDouble(),
+            )
+            if (screen.lastLayoutBounds[view] != bounds) {
+                screen.lastLayoutBounds[view] = bounds
+                send(screen, "EVENT", JSONObject()
+                    .put("handlerName", handler)
+                    .put("nativeEvent", JSONObject().put("layout", JSONObject()
+                        .put("x", bounds.x)
+                        .put("y", bounds.y)
+                        .put("width", bounds.width)
+                        .put("height", bounds.height))))
+            }
+        }
+        if (view is ViewGroup) {
+            for (index in 0 until view.childCount) emitLayoutEvents(screen, view.getChildAt(index))
+        }
+    }
+
     private fun send(screen: Screen, type: String, payload: JSONObject, correlationId: String? = null) {
         if (!screen.active) return
         val message = JSONObject().put("type", type).put("payload", payload)
@@ -1276,22 +2208,68 @@ class MainActivity : AppCompatActivity() {
         screen.flatListRows.values.forEach { rows -> rows.values.forEach { addAll(it.values) } }
     }
 
-    private fun releaseViewState(screen: Screen, views: Collection<View>) {
-        val released = views.toSet()
-        released.filterIsInstance<CraftNativeFlatList>().forEach { list ->
-            val owner = screen.flatListOwnerByView.remove(list)
-            list.discardAll()
-            screen.flatListRows.remove(list)?.values?.forEach { releaseViewState(screen, it.values) }
-            if (owner != null) screen.flatListOwners.entries.removeAll { it.value == owner }
+    private fun releaseFlatList(
+        screen: Screen,
+        list: CraftNativeFlatList,
+        preservingInputDrafts: Boolean,
+    ) {
+        val owner = screen.flatListOwnerByView.remove(list)
+        list.discardAll()
+        screen.flatListRows.remove(list)?.values?.forEach {
+            releaseViewState(screen, it.values, preservingInputDrafts)
+        }
+        if (owner != null) screen.flatListOwners.entries.removeAll { it.value == owner }
+    }
+
+    private fun releaseViewState(
+        screen: Screen,
+        views: Collection<View>,
+        preservingInputDrafts: Boolean = false,
+    ) {
+        val released = views.toMutableSet()
+        val refreshableLists = released.filterIsInstance<CraftNativeRefreshableFlatList>()
+        val nestedLists = refreshableLists.map { it.list }.toSet()
+        released.addAll(nestedLists)
+        refreshableLists.forEach {
+            releaseFlatList(screen, it.list, preservingInputDrafts)
+        }
+        released.filterIsInstance<CraftNativeFlatList>().filterNot { nestedLists.contains(it) }.forEach {
+            releaseFlatList(screen, it, preservingInputDrafts)
         }
         releaseImages(released)
+        released.filterIsInstance<EditText>().forEach {
+            inputHintDefaults.remove(it)
+            inputHighlightDefaults.remove(it)
+            screen.suppressedTextChanges.remove(it)
+            val identity = screen.inputIdentities.remove(it)
+            if (!preservingInputDrafts) identity?.let(screen.drafts::remove)
+        }
+        released.forEach(defaultBackgrounds::remove)
         screen.handlers.keys.removeAll(released)
+        screen.pressInHandlers.keys.removeAll(released)
+        screen.pressOutHandlers.keys.removeAll(released)
+        screen.longPressHandlers.keys.removeAll(released)
+        screen.layoutHandlers.keys.removeAll(released)
+        screen.lastLayoutBounds.keys.removeAll(released)
         screen.scrollHandlers.keys.removeAll(released)
         screen.scrollBeginHandlers.keys.removeAll(released)
         screen.scrollEndHandlers.keys.removeAll(released)
+        screen.scrollMomentumBeginHandlers.keys.removeAll(released)
+        screen.scrollMomentumEndHandlers.keys.removeAll(released)
+        screen.sliderCompleteHandlers.keys.removeAll(released)
+        screen.sliderSteps.keys.removeAll(released)
         screen.focusHandlers.keys.removeAll(released)
         screen.blurHandlers.keys.removeAll(released)
+        screen.endEditingHandlers.keys.removeAll(released)
         screen.submitHandlers.keys.removeAll(released)
+        screen.imageLoadStartHandlers.keys.removeAll(released)
+        screen.imageLoadHandlers.keys.removeAll(released)
+        screen.imageLoadEndHandlers.keys.removeAll(released)
+        screen.imageErrorHandlers.keys.removeAll(released)
+        screen.pressActiveOpacities.keys.removeAll(released)
+        screen.pressBaseOpacities.keys.removeAll(released)
+        screen.modalVisibility.keys.removeAll(released)
+        screen.modalCloseHandlers.keys.removeAll(released)
     }
 
     private fun closeScreen(screen: Screen) {
@@ -1302,12 +2280,25 @@ class MainActivity : AppCompatActivity() {
         releaseViewState(screen, retainedViews(screen).toList())
         screen.controls.clear()
         screen.handlers.clear()
+        screen.pressInHandlers.clear()
+        screen.pressOutHandlers.clear()
+        screen.layoutHandlers.clear()
+        screen.lastLayoutBounds.clear()
         screen.scrollHandlers.clear()
         screen.scrollBeginHandlers.clear()
         screen.scrollEndHandlers.clear()
+        screen.scrollMomentumBeginHandlers.clear()
+        screen.scrollMomentumEndHandlers.clear()
+        screen.sliderCompleteHandlers.clear()
+        screen.sliderSteps.clear()
         screen.focusHandlers.clear()
         screen.blurHandlers.clear()
+        screen.endEditingHandlers.clear()
         screen.submitHandlers.clear()
+        screen.imageLoadStartHandlers.clear()
+        screen.imageLoadHandlers.clear()
+        screen.imageLoadEndHandlers.clear()
+        screen.imageErrorHandlers.clear()
         screen.flatListRows.clear()
         screen.flatListOwners.clear()
         screen.flatListOwnerByView.clear()
@@ -1315,7 +2306,17 @@ class MainActivity : AppCompatActivity() {
     }
 
     @Deprecated("Uses the activity back callback for native route navigation")
-    override fun onBackPressed() = back()
+    override fun onBackPressed() {
+        val screen = screens.lastOrNull() ?: return back()
+        val modal = screen.modalVisibility.entries.lastOrNull { (view, visible) -> visible && view.visibility == View.VISIBLE }
+        if (modal != null) {
+            screen.modalCloseHandlers[modal.key]?.let { handler ->
+                send(screen, "EVENT", JSONObject().put("handlerName", handler).put("nativeEvent", JSONObject()))
+            }
+            return
+        }
+        back()
+    }
 
     private fun showError(message: String) {
         root.removeAllViews()