craft-native 0.0.186 → 0.0.189

package/dist/android/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)

package/dist/browser/dialogs.d.ts

@@ -0,0 +1,20 @@
+export interface BrowserDialogOptions {
+    title?: string;
+    message?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    buttons?: Array<{
+        id: string;
+        title?: string;
+        label?: string;
+        style?: string;
+    }>;
+    actions?: Array<{
+        id: string;
+        title?: string;
+        label?: string;
+        style?: string;
+    }>;
+}
+/** A user-owned browser dialog, with keyboard focus and cancellation, not a timed prompt. */
+export declare function showBrowserDialog(kind: string, options: BrowserDialogOptions, signal: AbortSignal): Promise<string | boolean | undefined>;

package/dist/browser/storage.d.ts

@@ -0,0 +1,31 @@
+export interface BrowserStorageOptions {
+    storage: Storage;
+    namespace: string;
+    tokenKey: string;
+    /** Existing website identity keys to forget whenever its token changes. */
+    accountKeys?: string[];
+    hash: (value: string) => Promise<string>;
+    changed: (name: string) => void;
+}
+export interface BrowserStorage {
+    craft: {
+        storage: {
+            getSync: (key: string) => unknown;
+            setSync: (key: string, value: unknown) => void;
+        };
+        secureStorage: {
+            getSync: (key: string) => string | null;
+        };
+        snapshots: {
+            get: (name: string) => unknown;
+            set: (name: string, value: unknown) => Promise<boolean>;
+            clear: (keep?: string[]) => Promise<boolean>;
+            keys: () => string[];
+        };
+    };
+    call: (module: string, method: string, args: unknown[]) => Promise<unknown>;
+    accountChanged: () => Promise<void>;
+    scope: () => string;
+}
+/** Browser persistence has browser security semantics; it does not claim to be a Keychain. */
+export declare function createBrowserStorage(options: BrowserStorageOptions): Promise<BrowserStorage>;

package/dist/browser.d.ts

@@ -0,0 +1,22 @@
+export interface BrowserPlatformOptions {
+    namespace?: string;
+    tokenKey?: string;
+    accountKeys?: string[];
+    /** App metadata shared with native hosts; no device capabilities are implied. */
+    appURL?: string;
+    locale?: string;
+    /** Application-owned deep-link schemes; arbitrary executable schemes are rejected. */
+    urlSchemes?: string[];
+}
+export interface BrowserPlatform {
+    craft: Record<string, unknown>;
+    capabilities: string[];
+    call: (module: string, method: string, args: unknown[], signal: AbortSignal) => Promise<unknown>;
+    navigate: (path: string, replace?: boolean) => void;
+    emit: (listener: (type: string, payload: unknown) => void) => () => void;
+    resolveMedia: (url: string) => Promise<string>;
+    resolveFile: (value: unknown) => unknown;
+    dispose: () => void;
+}
+/** Real browser counterparts for the portable Craft services. Device-only APIs remain absent. */
+export declare function createBrowserPlatform(options?: BrowserPlatformOptions): Promise<BrowserPlatform>;