@craft-native/android 0.0.187 → 0.0.189

package/README.md

@@ -147,6 +147,10 @@ content box, keeping responsive sizing aligned with the iOS renderer.
 When `flexShrink` is omitted, horizontal text labels and scroll hosts use the
 same shrink defaults as the iOS renderer; buttons and editable fields retain
 their intrinsic width unless explicitly configured.
+An exact horizontal scroll viewport still measures its content unbounded and
+retains that measured child width for the platform's second pass, so a wider
+carousel keeps its overflow and receives the horizontal gesture before the tab
+shell.
 Wrapped containers also honor `alignContent` (`center`, `flex-end`,
 `space-between`, `space-around`, `space-evenly`, and `stretch`) consistently
 across hosts.

package/package.json

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

package/templates/CraftNative.kt.template

@@ -341,6 +341,18 @@ object CraftNative {
         nodeData: FloatArray,
         treeMeta: FloatArray,
     ): FloatArray?
+    private external fun nativeLayoutTreeV2(
+        width: Float,
+        height: Float,
+        nodeData: FloatArray,
+        treeMeta: FloatArray,
+    ): FloatArray?
+    private external fun nativeLayoutTreeV3(
+        width: Float,
+        height: Float,
+        nodeData: FloatArray,
+        treeMeta: FloatArray,
+    ): FloatArray?
     private external fun nativeClipboardRead(activity: Activity): String?
     private external fun nativeClipboardWrite(activity: Activity, text: String): Boolean
     private external fun nativeOpenUrl(activity: Activity, url: String): Boolean
@@ -601,6 +613,28 @@ object CraftNative {
         }
     }
 
+    /** Resolve a reverse-aware tree in Zig, or null for Kotlin fallback. */
+    fun layoutTreeV2(width: Float, height: Float, nodeData: FloatArray, treeMeta: FloatArray): FloatArray? {
+        if (!isAvailable || nodeData.isEmpty() || treeMeta.isEmpty()) return null
+        return try {
+            nativeLayoutTreeV2(width, height, nodeData, treeMeta)
+                ?.takeIf { it.size >= treeMeta.size / 2 * 4 && it.all { value -> value.isFinite() } }
+        } catch (e: UnsatisfiedLinkError) {
+            null
+        }
+    }
+
+    /** Resolve a wrap-reverse-aware tree in Zig, or null for Kotlin fallback. */
+    fun layoutTreeV3(width: Float, height: Float, nodeData: FloatArray, treeMeta: FloatArray): FloatArray? {
+        if (!isAvailable || nodeData.isEmpty() || treeMeta.isEmpty()) return null
+        return try {
+            nativeLayoutTreeV3(width, height, nodeData, treeMeta)
+                ?.takeIf { it.size >= treeMeta.size / 2 * 4 && it.all { value -> value.isFinite() } }
+        } catch (e: UnsatisfiedLinkError) {
+            null
+        }
+    }
+
     /**
      * The clipboard's text, or null to use the Kotlin implementation.
      *

package/templates/CraftNativeCapabilities.kt.template

@@ -104,6 +104,7 @@ internal class CraftNativeCapabilities(
         val maxPixels: Int,
         val quality: Float,
         val completion: (CraftNativeCapabilityResult) -> Unit,
+        val videoLimit: Long = 0,
     )
 
     init {
@@ -166,6 +167,7 @@ internal class CraftNativeCapabilities(
             }
             "Files" -> when (method) {
                 "pickImage" -> pickImage(requestToken, args, completion)
+                "pickVideo" -> pickVideo(requestToken, args, completion)
                 "download", "write", "remove" -> networkExecutor.execute {
                     complete(requestToken, files(requestToken, method, args), completion)
                 }
@@ -238,21 +240,28 @@ internal class CraftNativeCapabilities(
                     }
                 }
                 if (body != null || multipart is FileResult.Multipart) doOutput = true
-                if (multipart is FileResult.Multipart) setRequestProperty("Content-Type", "multipart/form-data; boundary=${multipart.boundary}")
+                if (multipart is FileResult.Multipart) {
+                    setRequestProperty("Content-Type", "multipart/form-data; boundary=${multipart.boundary}")
+                    setFixedLengthStreamingMode(multipart.body.length())
+                    readTimeout = 600_000
+                }
             }
         } catch (error: IllegalArgumentException) {
+            if (multipart is FileResult.Multipart) multipart.body.parentFile?.deleteRecursively()
             return failure("INVALID_ARGUMENT", error.message ?: "fetch request is invalid")
         } catch (error: Exception) {
+            if (multipart is FileResult.Multipart) multipart.body.parentFile?.deleteRecursively()
             return failure("NETWORK_ERROR", error.message ?: "Network request failed")
         }
         fetchConnections[requestToken] = connection
         if (cancelled.contains(requestToken)) {
             fetchConnections.remove(requestToken)?.disconnect()
+            if (multipart is FileResult.Multipart) multipart.body.parentFile?.deleteRecursively()
             return failure("CANCELLED", "Network request was cancelled")
         }
         return try {
             if (body != null) connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
-            if (multipart is FileResult.Multipart) connection.outputStream.use { it.write(multipart.body) }
+            if (multipart is FileResult.Multipart) connection.outputStream.use { output -> multipart.body.inputStream().use { it.copyTo(output, 64 * 1024) } }
             val status = connection.responseCode
             val input = if (status >= 400) connection.errorStream else connection.inputStream
             val output = ByteArrayOutputStream()
@@ -283,17 +292,21 @@ internal class CraftNativeCapabilities(
             failure("NETWORK_ERROR", error.message ?: "Network request failed")
         } finally {
             fetchConnections.remove(requestToken)?.disconnect()
+            if (multipart is FileResult.Multipart) multipart.body.parentFile?.deleteRecursively()
         }
     }
 
     private sealed interface FileResult {
-        data class Multipart(val body: ByteArray, val boundary: String) : FileResult
+        data class Multipart(val body: File, val boundary: String) : FileResult
         data class Failure(val code: String, val message: String) : FileResult
     }
 
     private fun multipart(parts: JSONArray): FileResult {
         val boundary = "craft-${UUID.randomUUID()}"
-        val body = ByteArrayOutputStream()
+        val file = File(fileRoot, UUID.randomUUID().toString()).apply { mkdirs() }.resolve("upload.multipart")
+        var kept = false
+        try {
+        FileOutputStream(file).use { body ->
         fun append(value: String) { body.write(value.toByteArray(Charsets.UTF_8)) }
         for (index in 0 until parts.length()) {
             val part = parts.optJSONObject(index) ?: return FileResult.Failure("INVALID_ARGUMENT", "A form part must be an object")
@@ -303,14 +316,11 @@ internal class CraftNativeCapabilities(
             val path = part.optString("path")
             if (path.isNotBlank()) {
                 val file = ownedFile(path) ?: return FileResult.Failure("INVALID_ARGUMENT", "A form file must be one craft.files made, and still there")
-                val bytes = runCatching { file.readBytes() }.getOrElse {
-                    return FileResult.Failure("INVALID_ARGUMENT", "A form file could not be read")
-                }
                 val filename = safeFileName(part.optString("filename").ifBlank { file.name })
                 val type = part.optString("type").ifBlank { URLConnection.guessContentTypeFromName(filename) ?: "application/octet-stream" }
                 append("Content-Disposition: form-data; name=\"${quoted(name)}\"; filename=\"${quoted(filename)}\"\r\n")
                 append("Content-Type: ${headerValue(type)}\r\n\r\n")
-                body.write(bytes)
+                file.inputStream().use { it.copyTo(body, 64 * 1024) }
                 append("\r\n")
             } else {
                 append("Content-Disposition: form-data; name=\"${quoted(name)}\"\r\n\r\n")
@@ -319,7 +329,14 @@ internal class CraftNativeCapabilities(
             }
         }
         append("--$boundary--\r\n")
-        return FileResult.Multipart(body.toByteArray(), boundary)
+        }
+        kept = true
+        return FileResult.Multipart(file, boundary)
+        } catch (error: Exception) {
+            return FileResult.Failure("WRITE_ERROR", error.message ?: "A form file could not be read")
+        } finally {
+            if (!kept) file.parentFile?.deleteRecursively()
+        }
     }
 
     private fun files(requestToken: String, method: String, args: JSONArray): CraftNativeCapabilityResult {
@@ -417,6 +434,64 @@ internal class CraftNativeCapabilities(
         return success(JSONObject().put("ok", false).put("status", status).put("body", body.toString(Charsets.UTF_8.name())))
     }
 
+    private fun pickVideo(requestToken: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit) {
+        mainHandler.post {
+            val host = activity ?: return@post complete(requestToken, failure("NEEDS_ACTIVITY", "No screen is showing to pick from"), completion)
+            if (pendingFilePick != null) {
+                complete(requestToken, failure("BUSY", "Another file picker is already open"), completion)
+                return@post
+            }
+            val options = args.optJSONObject(0) ?: JSONObject()
+            val limit = options.optLong("maxBytes", 512L * 1024 * 1024).coerceIn(1, 512L * 1024 * 1024)
+            pendingFilePick = PendingFilePick(requestToken, "video", 0, 1f, completion, limit)
+            val photos = options.optString("source", "library") != "files" && Build.VERSION.SDK_INT >= 33
+            val intent = Intent(if (photos) MediaStore.ACTION_PICK_IMAGES else Intent.ACTION_OPEN_DOCUMENT).apply {
+                type = "video/*"
+                if (!photos) addCategory(Intent.CATEGORY_OPENABLE)
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            }
+            try { host.startActivityForResult(intent, CRAFT_NATIVE_FILE_PICK_REQUEST) }
+            catch (error: Exception) {
+                pendingFilePick = null
+                complete(requestToken, failure("PICKER_UNAVAILABLE", error.message ?: "Video picker could not be opened"), completion)
+            }
+        }
+    }
+
+    /** Copy with a bound even when a cloud provider does not report its size. */
+    private fun copyVideo(uri: Uri, limit: Long): CraftNativeCapabilityResult {
+        var target: File? = null
+        return try {
+            val name = context.contentResolver.query(uri, arrayOf(android.provider.OpenableColumns.DISPLAY_NAME), null, null, null)?.use {
+                if (it.moveToFirst()) it.getString(0) else null
+            } ?: "video.mp4"
+            val types = mapOf("mp4" to "video/mp4", "m4v" to "video/x-m4v", "mov" to "video/quicktime", "webm" to "video/webm")
+            val type = types[name.substringAfterLast('.', "").lowercase()]
+                ?: return failure("INVALID_VIDEO", "Choose an MP4, MOV or WebM video.")
+            val destination = File(fileRoot, UUID.randomUUID().toString()).apply { mkdirs() }.resolve(safeFileName(name))
+            target = destination
+            val input = context.contentResolver.openInputStream(uri) ?: throw IllegalArgumentException("The video could not be read")
+            var size = 0L
+            input.use { source ->
+                destination.outputStream().use { output ->
+                    val buffer = ByteArray(64 * 1024)
+                    while (true) {
+                        val count = source.read(buffer)
+                        if (count < 0) break
+                        size += count
+                        require(size <= limit) { "Choose a video under ${limit / 1024 / 1024}MB." }
+                        output.write(buffer, 0, count)
+                    }
+                }
+            }
+            require(size > 0) { "Choose a nonempty video." }
+            success(descriptor(destination, type))
+        } catch (error: Exception) {
+            target?.parentFile?.deleteRecursively()
+            failure("READ_ERROR", error.message ?: "The video could not be read")
+        }
+    }
+
     private fun pickImage(
         requestToken: String,
         args: JSONArray,
@@ -465,6 +540,14 @@ internal class CraftNativeCapabilities(
             complete(pending.requestToken, success(JSONObject.NULL), pending.completion)
             return true
         }
+        if (pending.source == "video") {
+            networkExecutor.execute {
+                val result = data?.data?.let { copyVideo(it, pending.videoLimit) }
+                    ?: failure("PICKER_FAILED", "The selected video could not be read")
+                complete(pending.requestToken, result, pending.completion)
+            }
+            return true
+        }
         val descriptor = if (pending.source == "camera") {
             val bitmap = data?.extras?.get("data") as? Bitmap
             bitmap?.let { writeImage(it, pending.maxPixels, pending.quality, "photo.jpg") }

package/templates/CraftNativeShell.kt.template

@@ -580,6 +580,7 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
     private var selectedTab = 0
     private var swipeTracking = false
     private var swipeIntercepted = false
+    private var horizontalScrollDeferred = false
     private var swipeDownX = 0f
     private var swipeDownY = 0f
     private val swipeSlop = ViewConfiguration.get(context).scaledTouchSlop
@@ -590,6 +591,8 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
     var onTabSwipeStart: ((Float, Float, Float) -> Boolean)? = null
     var onTabSwipeMove: ((Float) -> Unit)? = null
     var onTabSwipeEnd: ((Float, Boolean) -> Unit)? = null
+    /** Lets a native horizontal scroller own the gesture from its first down. */
+    var onTabSwipeShouldDefer: ((Float, Float) -> Boolean)? = null
     var tabSwipeEnabled = true
 
     init {
@@ -654,7 +657,10 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
     override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
         when (event.actionMasked) {
             MotionEvent.ACTION_DOWN -> {
-                swipeTracking = tabs.size > 1 && tabSwipeEnabled && tabBar.visibility == View.VISIBLE && event.y < tabBar.top
+                val overHorizontalScroll = onTabSwipeShouldDefer?.invoke(event.x, event.y) == true
+                horizontalScrollDeferred = overHorizontalScroll
+                if (overHorizontalScroll) parent?.requestDisallowInterceptTouchEvent(true)
+                swipeTracking = tabs.size > 1 && tabSwipeEnabled && !overHorizontalScroll && tabBar.visibility == View.VISIBLE && event.y < tabBar.top
                 swipeIntercepted = false
                 swipeDownX = event.x
                 swipeDownY = event.y
@@ -668,7 +674,13 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
                     return swipeIntercepted
                 }
             }
-            MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -> swipeTracking = false
+            MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -> {
+                swipeTracking = false
+                if (horizontalScrollDeferred) {
+                    horizontalScrollDeferred = false
+                    parent?.requestDisallowInterceptTouchEvent(false)
+                }
+            }
         }
         return swipeIntercepted
     }

package/templates/MainActivityNative.kt.template

@@ -771,6 +771,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     private var gridAutoRows: CraftNativeLength? = null
     private var reverse = false
     private var wrapReverse = false
+    private var unboundedWidth = false
     private var authoredPadding = intArrayOf(0, 0, 0, 0)
     private var safeAreaPadding = intArrayOf(0, 0, 0, 0)
     private var applyingPadding = false
@@ -947,6 +948,13 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         invalidateMeasurements()
     }
 
+    /** A horizontal scroll host measures its content beyond the viewport. */
+    fun setUnboundedWidth(value: Boolean) {
+        if (unboundedWidth == value) return
+        unboundedWidth = value
+        invalidateMeasurements()
+    }
+
     fun setChildStyle(view: View, style: JSONObject, density: Float) {
         styles[view] = CraftNativeLayoutStyle.from(style, density)
         invalidateMeasurements()
@@ -1237,15 +1245,197 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
 
     private fun sharedLength(value: CraftNativeLength?, base: Int?): Float = value?.resolve(base)?.toFloat() ?: Float.NaN
 
+    /** A measured node in the host-neutral tree ABI, retaining its native view
+     * so the returned absolute frames can be mounted back into the hierarchy. */
+    private data class SharedTreeNode(
+        val view: View?,
+        val style: CraftNativeLayoutStyle,
+        val intrinsicWidth: Float,
+        val intrinsicHeight: Float,
+        val baseline: Float,
+        val direction: Int,
+        val gap: Float,
+        val rowGap: Float,
+        val columnGap: Float,
+        val wrap: Boolean,
+        val justify: String,
+        val alignItems: String,
+        val alignContent: String,
+        val padding: IntArray,
+        val margins: IntArray,
+        val grid: Boolean,
+        val gridColumns: Int,
+        val reverse: Boolean,
+        val wrapReverse: Boolean,
+        val children: List<SharedTreeNode>,
+    )
+
+    private data class SharedTreeResult(
+        val nodes: List<SharedTreeNode>,
+        val parents: IntArray,
+        val frames: FloatArray,
+    )
+
+    /**
+     * Flatten a flex or equal-track grid subtree for the shared ABI. The local
+     * layout stays authoritative for grid-auto-rows,
+     * absolute/modal children, and scroll hosts; those cases cannot be
+     * represented without changing their native measurement contract.
+     */
+    private fun sharedTreeChildren(width: Int, height: Int): List<Entry>? {
+        if (gridAutoRows != null) return null
+        if (grid) {
+            val layout = gridLayout(width, height)
+            if (layout.absolute.isNotEmpty()) return null
+            return layout.rows.flatten()
+        }
+        val (lines, absolute) = entries(width, height)
+        if (absolute.isNotEmpty()) return null
+        return lines.flatMap { it.entries }
+    }
+
+    private fun sharedTreeNode(entry: Entry): SharedTreeNode? {
+        val nested = entry.view as? CraftNativeFlexLayout
+        val children = if (nested == null) {
+            emptyList()
+        } else {
+            nested.sharedTreeChildren(entry.width, entry.height) ?: return null
+        }
+        val lp = entry.view.layoutParams as? MarginLayoutParams
+        return SharedTreeNode(
+            view = entry.view,
+            style = entry.style,
+            intrinsicWidth = entry.width.toFloat(),
+            intrinsicHeight = entry.height.toFloat(),
+            baseline = baselineOffset(entry.view, entry.height).toFloat(),
+            direction = nested?.let { if (it.orientation == HORIZONTAL) 0 else 1 } ?: 0,
+            gap = nested?.let { if (it.orientation == HORIZONTAL) it.columnGap else it.rowGap } ?: 0f,
+            rowGap = nested?.rowGap ?: 0f,
+            columnGap = nested?.columnGap ?: 0f,
+            wrap = nested?.wrap ?: false,
+            justify = nested?.justifyContent ?: "flex-start",
+            alignItems = nested?.alignItems ?: "stretch",
+            alignContent = nested?.alignContent ?: "flex-start",
+            padding = nested?.let { intArrayOf(it.paddingLeft, it.paddingRight, it.paddingTop, it.paddingBottom) }
+                ?: intArrayOf(0, 0, 0, 0),
+            margins = intArrayOf(lp?.leftMargin ?: 0, lp?.rightMargin ?: 0, lp?.topMargin ?: 0, lp?.bottomMargin ?: 0),
+            grid = nested?.grid ?: false,
+            gridColumns = nested?.gridColumns ?: 1,
+            reverse = nested?.reverse ?: false,
+            wrapReverse = nested?.wrapReverse ?: false,
+            children = children.map { child -> sharedTreeNode(child) ?: return null },
+        )
+    }
+
+    private fun sharedTreeFrames(entries: List<Entry>, width: Int, height: Int): SharedTreeResult? {
+        if (entries.isEmpty() || width < 0 || height < 0 || gridAutoRows != null) return null
+        val children = entries.map { sharedTreeNode(it) ?: return null }
+        val root = SharedTreeNode(
+            view = null,
+            style = CraftNativeLayoutStyle(),
+            intrinsicWidth = 0f,
+            intrinsicHeight = 0f,
+            baseline = 0f,
+            direction = if (orientation == HORIZONTAL) 0 else 1,
+            gap = if (orientation == HORIZONTAL) columnGap else rowGap,
+            rowGap = rowGap,
+            columnGap = columnGap,
+            wrap = wrap,
+            justify = justifyContent,
+            alignItems = alignItems,
+            alignContent = alignContent,
+            padding = intArrayOf(paddingLeft, paddingRight, paddingTop, paddingBottom),
+            margins = intArrayOf(0, 0, 0, 0),
+            grid = grid,
+            gridColumns = gridColumns,
+            reverse = reverse,
+            wrapReverse = wrapReverse,
+            children = children,
+        )
+        val nodes = mutableListOf<SharedTreeNode>()
+        val parents = mutableListOf<Int>()
+        fun append(node: SharedTreeNode, parent: Int) {
+            val index = nodes.size
+            nodes += node
+            parents += parent
+            node.children.forEach { child -> append(child, index) }
+        }
+        append(root, -1)
+        val reverseAware = nodes.any { it.reverse || it.wrapReverse }
+        val wrapReverseAware = nodes.any { it.wrapReverse }
+        val fields = if (reverseAware) 33 else 32
+        val nodeData = FloatArray(nodes.size * fields) { Float.NaN }
+        val treeMeta = FloatArray(nodes.size * 2)
+        fun enumBits(value: Int): Float = Float.fromBits(value)
+        fun put(base: Int, index: Int, value: Float) { nodeData[base + index] = value }
+        fun putEnum(base: Int, index: Int, value: Int) { put(base, index, enumBits(value)) }
+        var cursor = 0
+        fun write(node: SharedTreeNode, parentWidth: Int, parentHeight: Int, rootNode: Boolean) {
+            val index = cursor++
+            val base = index * fields
+            val measuredWidth = if (rootNode) width else node.style.width?.resolve(parentWidth) ?: node.intrinsicWidth.roundToInt()
+            val measuredHeight = if (rootNode) height else node.style.height?.resolve(parentHeight) ?: node.intrinsicHeight.roundToInt()
+            val contentWidth = max(0, measuredWidth - node.padding[0] - node.padding[1])
+            val contentHeight = max(0, measuredHeight - node.padding[2] - node.padding[3])
+            val mainSize = if (node.direction == 0) contentWidth else contentHeight
+            putEnum(base, 0, node.direction)
+            put(base, 1, if (rootNode) width.toFloat() else sharedLength(node.style.width, parentWidth))
+            put(base, 2, if (rootNode) height.toFloat() else sharedLength(node.style.height, parentHeight))
+            put(base, 3, if (rootNode) Float.NaN else node.intrinsicWidth)
+            put(base, 4, if (rootNode) Float.NaN else node.intrinsicHeight)
+            put(base, 5, if (rootNode) Float.NaN else node.baseline)
+            put(base, 6, node.style.aspectRatio?.toFloat() ?: Float.NaN)
+            put(base, 7, sharedLength(node.style.flexBasis, mainSize))
+            put(base, 8, if (rootNode) 0f else node.style.flexGrow.toFloat().coerceAtLeast(0f))
+            put(base, 9, if (rootNode) 0f else (node.style.flexShrink ?: 0.0).toFloat().coerceAtLeast(0f))
+            put(base, 10, sharedLength(node.style.minWidth, contentWidth))
+            put(base, 11, sharedLength(node.style.maxWidth, contentWidth))
+            put(base, 12, sharedLength(node.style.minHeight, contentHeight))
+            put(base, 13, sharedLength(node.style.maxHeight, contentHeight))
+            put(base, 14, node.gap)
+            putEnum(base, 15, sharedJustifyCode(node.justify))
+            putEnum(base, 16, sharedAlignItemsCode(node.alignItems))
+            putEnum(base, 17, if (rootNode) 0 else sharedAlignSelfCode(node.style.alignSelf))
+            putEnum(base, 18, if (node.wrap) 1 else 0)
+            putEnum(base, 19, sharedAlignContentCode(node.alignContent))
+            put(base, 20, node.margins[2].toFloat())
+            put(base, 21, node.margins[1].toFloat())
+            put(base, 22, node.margins[3].toFloat())
+            put(base, 23, node.margins[0].toFloat())
+            put(base, 24, node.padding[2].toFloat())
+            put(base, 25, node.padding[1].toFloat())
+            put(base, 26, node.padding[3].toFloat())
+            put(base, 27, node.padding[0].toFloat())
+            putEnum(base, 28, if (node.grid) 1 else 0)
+            put(base, 29, node.gridColumns.toFloat())
+            put(base, 30, node.rowGap)
+            put(base, 31, node.columnGap)
+            if (reverseAware) putEnum(base, 32, (if (node.reverse) 1 else 0) or (if (node.wrapReverse) 2 else 0))
+            val firstChild = cursor
+            node.children.forEach { child -> write(child, contentWidth, contentHeight, false) }
+            treeMeta[index * 2] = firstChild.toFloat()
+            treeMeta[index * 2 + 1] = (cursor - firstChild).toFloat()
+        }
+        write(root, width, height, true)
+        val frames = (if (wrapReverseAware) {
+            CraftNative.layoutTreeV3(width.toFloat(), height.toFloat(), nodeData, treeMeta)
+        } else if (reverseAware) {
+            CraftNative.layoutTreeV2(width.toFloat(), height.toFloat(), nodeData, treeMeta)
+        } else {
+            CraftNative.layoutTree(width.toFloat(), height.toFloat(), nodeData, treeMeta)
+        }) ?: return null
+        return SharedTreeResult(nodes, parents.toIntArray(), frames)
+    }
+
     /**
      * Use the host-neutral tree ABI when platform measurements are complete:
-     * definite, non-grid direct-child containers, including wrapped flows with
-     * independent row and column gaps. Reverse flows, absolute children,
-     * missing runtimes, and malformed results deliberately fall through to
-     * the established Kotlin layout below.
+     * definite direct-child containers, including wrapped flows, equal-track
+     * grids, and independent row and column gaps. Grid
+     * auto-rows, absolute children, missing runtimes, and malformed results
+     * deliberately fall through to the established Kotlin layout below.
      */
     private fun sharedDirectFrames(entries: List<Entry>, width: Int, height: Int): FloatArray? {
-        if (entries.isEmpty() || width < 0 || height < 0 || grid || reverse || wrapReverse) return null
+        if (entries.isEmpty() || width < 0 || height < 0 || grid || reverse || wrapReverse || gridAutoRows != null) return null
         val count = entries.size + 1
         val fields = 32
         val nodeData = FloatArray(count * fields) { Float.NaN }
@@ -1300,7 +1490,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             put(base, 26, padding[3].toFloat())
             put(base, 27, padding[0].toFloat())
             putEnum(base, 28, 0)
-            putEnum(base, 29, 1)
+            put(base, 29, 1f)
             put(base, 30, if (root) rowGapValue else 0f)
             put(base, 31, if (root) columnGapValue else 0f)
         }
@@ -1337,6 +1527,15 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         else -> 0
     }
 
+    private fun sharedJustifyCode(value: String): Int = when (value) {
+        "center" -> 1
+        "flex-end" -> 2
+        "space-between" -> 3
+        "space-around" -> 4
+        "space-evenly" -> 5
+        else -> 0
+    }
+
     private fun alignContentCode(): Int = when (alignContent) {
         "center" -> 1
         "flex-end" -> 2
@@ -1347,6 +1546,16 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         else -> 0
     }
 
+    private fun sharedAlignContentCode(value: String): Int = when (value) {
+        "center" -> 1
+        "flex-end" -> 2
+        "space-between" -> 3
+        "space-around" -> 4
+        "stretch" -> 5
+        "space-evenly" -> 6
+        else -> 0
+    }
+
     /** Keep the old-runtime shim on the same bounded-flex water-fill rule as the Zig bridge. */
     private fun fallbackFlexWidths(line: Line, available: Int, gap: Float): IntArray {
         val horizontal = orientation == HORIZONTAL
@@ -1410,7 +1619,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     }
 
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-        val widthMode = View.MeasureSpec.getMode(widthMeasureSpec)
+        val unboundedHorizontal = unboundedWidth && orientation == HORIZONTAL
+        val widthMode = if (unboundedHorizontal) View.MeasureSpec.UNSPECIFIED else View.MeasureSpec.getMode(widthMeasureSpec)
         widthDefinite = widthMode == View.MeasureSpec.EXACTLY
         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
@@ -1437,7 +1647,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val absWidth = absolute.maxOfOrNull { it.width } ?: 0
         val absHeight = absolute.maxOfOrNull { it.height } ?: 0
         setMeasuredDimension(
-            resolveSize(max(desiredWidth + paddingLeft + paddingRight, absWidth + paddingLeft + paddingRight), widthMeasureSpec),
+            if (unboundedHorizontal) max(desiredWidth + paddingLeft + paddingRight, absWidth + paddingLeft + paddingRight)
+            else resolveSize(max(desiredWidth + paddingLeft + paddingRight, absWidth + paddingLeft + paddingRight), widthMeasureSpec),
             resolveSize(max(desiredHeight + paddingTop + paddingBottom, absHeight + paddingTop + paddingBottom), heightMeasureSpec),
         )
     }
@@ -1547,6 +1758,23 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val (lines, absolute) = entries(width, height)
         if (absolute.isEmpty() && lines.isNotEmpty() && (lines.size == 1 || wrap)) {
             val sharedEntries = if (wrap) lines.flatMap { it.entries } else lines[0].entries
+            val sharedTree = sharedTreeFrames(sharedEntries, width, height)
+            if (sharedTree != null && (sharedTree.nodes.size > sharedEntries.size + 1 || grid)) {
+                for (index in 1 until sharedTree.nodes.size) {
+                    val view = sharedTree.nodes[index].view ?: continue
+                    val offset = index * 4
+                    val parentOffset = sharedTree.parents[index] * 4
+                    val parentX = sharedTree.frames[parentOffset]
+                    val parentY = sharedTree.frames[parentOffset + 1]
+                    val x = (sharedTree.frames[offset] - parentX).roundToInt()
+                    val y = (sharedTree.frames[offset + 1] - parentY).roundToInt()
+                    val childWidth = sharedTree.frames[offset + 2].roundToInt()
+                    val childHeight = sharedTree.frames[offset + 3].roundToInt()
+                    place(view, x, y, x + childWidth, y + childHeight)
+                }
+                onLayoutChanged?.invoke()
+                return
+            }
             val sharedFrames = sharedDirectFrames(sharedEntries, width, height)
             if (sharedFrames != null) {
                 for ((index, entry) in sharedEntries.withIndex()) {
@@ -1808,10 +2036,18 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
         vertical.isFillViewport = true
         horizontal.isFillViewport = true
         setOnRefreshListener { refreshHandler?.invoke() }
-        isEnabled = false
+        // The outer refresh host must stay touch-enabled so its real scroll
+        // child can receive gestures even when no pull-to-refresh handler is
+        // configured. Interception is gated below instead.
+        isEnabled = true
         setHorizontal(false)
     }
 
+    override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+        if (refreshHandler == null) return false
+        return super.onInterceptTouchEvent(event)
+    }
+
     /**
      * Along an axis its parent does not fix, a scroll view is as big as its
      * content (up to what the parent allows): a horizontal strip is as tall
@@ -1824,10 +2060,11 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
         val heightMode = MeasureSpec.getMode(heightMeasureSpec)
         val widthSize = MeasureSpec.getSize(widthMeasureSpec)
         val heightSize = MeasureSpec.getSize(heightMeasureSpec)
-        if (widthMode == MeasureSpec.EXACTLY && heightMode == MeasureSpec.EXACTLY) {
-            super.onMeasure(widthMeasureSpec, heightMeasureSpec)
-            return
-        }
+        // Even when the viewport itself is exact, a horizontal scroll must
+        // measure its content with an unspecified width. Returning straight
+        // to SwipeRefreshLayout here makes HorizontalScrollView remeasure the
+        // content at the viewport width, erasing overflow and disabling the
+        // nested carousel gesture.
         val sideways = horizontalMode == true
         val unspecified = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)
         val horizontalPadding = paddingLeft + paddingRight
@@ -1838,6 +2075,18 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
             if (!sideways || heightMode == MeasureSpec.UNSPECIFIED) unspecified
             else MeasureSpec.makeMeasureSpec(max(0, heightSize - verticalPadding), MeasureSpec.AT_MOST),
         )
+        if (sideways) {
+            // HorizontalScrollView may turn a WRAP_CONTENT child into an
+            // AT_MOST viewport measurement during its own pass. Preserve the
+            // intrinsic width we just measured as the child's layout width so
+            // the second pass cannot collapse a carousel back to the viewport.
+            val params = content.layoutParams ?: ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT,
+                ViewGroup.LayoutParams.MATCH_PARENT,
+            )
+            params.width = max(params.width, content.measuredWidth)
+            content.layoutParams = params
+        }
         fun fit(mode: Int, size: Int, wanted: Int): Int = when (mode) {
             MeasureSpec.EXACTLY -> size
             MeasureSpec.AT_MOST -> min(size, wanted)
@@ -1853,7 +2102,7 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
 
     fun setRefreshHandler(handler: (() -> Unit)?, refreshing: Boolean) {
         refreshHandler = handler
-        isEnabled = handler != null
+        isEnabled = true
         isRefreshing = handler != null && refreshing
         if (handler == null) isRefreshing = false
     }
@@ -1884,6 +2133,7 @@ private class CraftNativeScrollView(context: Context) : SwipeRefreshLayout(conte
         val scroller: ViewGroup = if (value) horizontal else vertical
         scroller.removeAllViews()
         content.orientation = if (value) LinearLayout.HORIZONTAL else LinearLayout.VERTICAL
+        content.setUnboundedWidth(value)
         scroller.addView(content, if (value)
             ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.MATCH_PARENT)
         else ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT))
@@ -3272,6 +3522,16 @@ class MainActivity : AppCompatActivity() {
         bars.onTabSwipeStart = { dx, x, y -> beginTabSwipe(dx, x, y) }
         bars.onTabSwipeMove = { dx -> updateTabSwipe(dx) }
         bars.onTabSwipeEnd = { dx, cancelled -> finishTabSwipe(dx, cancelled) }
+        bars.onTabSwipeShouldDefer = { x, y ->
+            val location = IntArray(2)
+            bars.getLocationOnScreen(location)
+            val screen = visibleScreen
+            screen != null && horizontalScrollAtPoint(
+                screen.view,
+                location[0] + x,
+                location[1] + y,
+            )
+        }
         root.addView(bars)
         chrome = bars
         tabStacks.clear()
@@ -3320,7 +3580,9 @@ class MainActivity : AppCompatActivity() {
         val target = ensureTabRoot(targetIndex) ?: return false
         val host = chrome?.content ?: return false
         if (target === current || host.width <= 0) return false
-        if (horizontalScrollCanConsume(current.view, host, x, y, dx)) return false
+        val chromeLocation = IntArray(2)
+        chrome?.getLocationOnScreen(chromeLocation)
+        if (horizontalScrollCanConsume(current.view, chromeLocation[0] + x, chromeLocation[1] + y, dx)) return false
         (target.view.parent as? ViewGroup)?.removeView(target.view)
         host.addView(target.view, FrameLayout.LayoutParams(-1, -1))
         target.view.translationX = if (direction > 0) host.width.toFloat() else -host.width.toFloat()
@@ -3375,15 +3637,36 @@ class MainActivity : AppCompatActivity() {
         }.start()
     }
 
-    private fun horizontalScrollCanConsume(view: View, host: ViewGroup, x: Float, y: Float, dx: Float): Boolean {
-        val localX = x - view.left
-        val localY = y - host.top - view.top
-        if (view !is ViewGroup || localX < 0 || localY < 0 || localX > view.width || localY > view.height) return false
+    /**
+     * Returns true when the exact screen gesture point is over a horizontal
+     * child that still has room in the gesture's direction. Screen coordinates
+     * keep nested scroll offsets and translated parents out of the calculation.
+     */
+    private fun horizontalScrollCanConsume(view: View, screenX: Float, screenY: Float, dx: Float): Boolean {
+        if (!view.isShown) return false
+        val location = IntArray(2)
+        view.getLocationOnScreen(location)
+        if (screenX < location[0] || screenY < location[1]
+            || screenX > location[0] + view.width || screenY > location[1] + view.height) return false
+        if (view is android.widget.HorizontalScrollView && view.canScrollHorizontally(if (dx < 0) 1 else -1)) return true
+        if (view !is ViewGroup) return false
+        for (index in view.childCount - 1 downTo 0) {
+            if (horizontalScrollCanConsume(view.getChildAt(index), screenX, screenY, dx)) return true
+        }
+        return false
+    }
+
+    /** Returns true when a native horizontal scroll host owns the touch point. */
+    private fun horizontalScrollAtPoint(view: View, screenX: Float, screenY: Float): Boolean {
+        if (!view.isShown) return false
+        val location = IntArray(2)
+        view.getLocationOnScreen(location)
+        if (screenX < location[0] || screenY < location[1]
+            || screenX > location[0] + view.width || screenY > location[1] + view.height) return false
+        if (view is android.widget.HorizontalScrollView) return true
+        if (view !is ViewGroup) return false
         for (index in view.childCount - 1 downTo 0) {
-            val child = view.getChildAt(index)
-            if (!child.isShown || localX < child.left || localX > child.right || localY < child.top || localY > child.bottom) continue
-            if (child is android.widget.HorizontalScrollView && child.canScrollHorizontally(if (dx < 0) 1 else -1)) return true
-            if (horizontalScrollCanConsume(child, host, localX - child.left, localY - child.top, dx)) return true
+            if (horizontalScrollAtPoint(view.getChildAt(index), screenX, screenY)) return true
         }
         return false
     }
@@ -4514,7 +4797,7 @@ class MainActivity : AppCompatActivity() {
                     )
                 } ?: run { trackTintList = null }
                 craftNativeOptionalString(props.opt("thumbColor"))
-                    ?.let { ColorStateList.valueOf(color(it, Color.WHITE)) }
+                    ?.let { thumbTintList = ColorStateList.valueOf(color(it, Color.WHITE)) }
                     ?: run { thumbTintList = null }
                 val handler = craftNativeEventName(events, "onValueChange", "onChange")
                 if (handler.isNotBlank()) screen.handlers[this] = handler else screen.handlers.remove(this)
@@ -4751,6 +5034,11 @@ class MainActivity : AppCompatActivity() {
                     }
                 }
                 configureContainer(content, contentStyle)
+                // Content-style reconciliation configures the flex host again;
+                // restore the scroll axis after it so horizontal children are
+                // measured beyond the viewport rather than clamped to it.
+                content.orientation = if (horizontal) LinearLayout.HORIZONTAL else LinearLayout.VERTICAL
+                content.setUnboundedWidth(horizontal)
                 val contentChildren = JSONArray()
                 for (index in 0 until children.length()) {
                     val child = children.opt(index)