craft-native 0.0.162 → 0.0.164

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

@@ -88,6 +88,7 @@ import java.util.UUID
 import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.PI
+import kotlin.math.ceil
 import kotlin.math.roundToInt
 import kotlin.math.roundToLong
 import kotlin.math.sin
@@ -202,13 +203,16 @@ private class CraftNativeSvgView(context: Context) : View(context) {
                 props.has(name) && !props.isNull(name) -> props.optString(name)
                 else -> null
             }
+            // Keep the cascade explicit: computed style wins over a raw prop
+            // when both provide the same SVG paint value.
             val weight = value("fontWeight")
+            val ownOpacity = value("opacity")?.toFloatOrNull() ?: 1f
             return copy(
                 fill = value("fill") ?: fill,
                 stroke = value("stroke") ?: stroke,
                 strokeWidth = value("strokeWidth")?.toFloatOrNull() ?: strokeWidth,
                 color = value("color") ?: color,
-                opacity = (value("opacity")?.toFloatOrNull() ?: 1f) * opacity,
+                opacity = ownOpacity * opacity,
                 typeface = if (weight in setOf("bold", "700")) Typeface.DEFAULT_BOLD else typeface,
             )
         }
@@ -393,8 +397,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     private var alignItems = "stretch"
     private var alignContent = "flex-start"
     private var justifyContent = "flex-start"
-    private var rowGap = 0
-    private var columnGap = 0
+    private var rowGap = 0f
+    private var columnGap = 0f
     private var grid = false
     private var gridColumns = 1
     private var gridAutoRows: CraftNativeLength? = null
@@ -407,9 +411,9 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         alignItems = style.optString("alignItems", "stretch")
         alignContent = style.optString("alignContent", "flex-start")
         justifyContent = style.optString("justifyContent", "flex-start")
-        val gap = (style.optDouble("gap", 0.0) * density).toInt()
-        rowGap = (style.optDouble("rowGap", gap.toDouble() / density.toDouble()) * density).toInt()
-        columnGap = (style.optDouble("columnGap", gap.toDouble() / density.toDouble()) * density).toInt()
+        val gap = style.optDouble("gap", 0.0) * density
+        rowGap = style.optDouble("rowGap", gap / density.toDouble()).toFloat() * density
+        columnGap = style.optDouble("columnGap", gap / density.toDouble()).toFloat() * density
         grid = style.optString("display") == "grid"
         gridColumns = craftNativeGridColumnCount(
             if (style.has("gridTemplateColumns")) style.opt("gridTemplateColumns") else style.opt("gridColumns")
@@ -438,8 +442,8 @@ 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 data class Line(val entries: MutableList<Entry> = mutableListOf(), var main: Float = 0f, var cross: Float = 0f)
+    private data class GridLayout(val rows: List<List<Entry>>, val absolute: List<Entry>, val cellWidth: Float, val rowHeights: List<Float>)
 
     private fun entries(width: Int, height: Int): Pair<List<Line>, List<Entry>> {
         val availableMain = if (orientation == HORIZONTAL) max(0, width - paddingLeft - paddingRight)
@@ -487,8 +491,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             }
             var line = Line()
             pending.forEachIndexed { index, entry ->
-                val childMain = if (orientation == HORIZONTAL) entry.width + (margins[index * 2] + margins[index * 2 + 1]).roundToInt()
-                else entry.height + (margins[index * 2] + margins[index * 2 + 1]).roundToInt()
+                val childMain = if (orientation == HORIZONTAL) entry.width.toFloat() + margins[index * 2] + margins[index * 2 + 1]
+                else entry.height.toFloat() + margins[index * 2] + margins[index * 2 + 1]
                 val lp = entry.view.layoutParams as? MarginLayoutParams
                 val crossMargins = if (orientation == HORIZONTAL) (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
                 else (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
@@ -502,17 +506,22 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 }
                 line.entries += entry
                 line.main = if (line.entries.size == 1) childMain else line.main + gap + childMain
-                line.cross = max(line.cross, childCross)
+                line.cross = max(line.cross, childCross.toFloat())
             }
             if (line.entries.isNotEmpty()) lines += line
         }
+        // Reconciliation reverses the child order so the main axis runs in
+        // the requested direction. With wrapping, that also reverses the
+        // line order; flexbox keeps wrap lines in cross-axis order, so restore
+        // the groups while retaining the reversed entries inside each line.
+        if (reverse && wrap && lines.size > 1) lines.reverse()
         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 cellWidth = max(0f, (availableWidth.toFloat() - max(0, gridColumns - 1) * gap) / max(1, gridColumns).toFloat())
         val rows = mutableListOf<MutableList<Entry>>()
         val absolute = mutableListOf<Entry>()
         for (index in 0 until childCount) {
@@ -532,7 +541,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 absolute += Entry(child, style, modalWidth, modalHeight)
                 continue
             }
-            val childWidth = measureChildWidth(child, style, cellWidth, horizontalMargins)
+            val childWidth = measureChildWidth(child, style, cellWidth.roundToInt(), horizontalMargins)
             val childHeight = measureChildHeight(child, style, height - paddingTop - paddingBottom, verticalMargins)
             val entry = Entry(child, style, childWidth, childHeight)
             if (style.position == "absolute") absolute += entry
@@ -542,10 +551,10 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             }
         }
         val rowHeights = rows.map { row ->
-            max(gridAutoRows?.resolve(height - paddingTop - paddingBottom) ?: 0, row.maxOfOrNull { entry ->
+            max((gridAutoRows?.resolve(height - paddingTop - paddingBottom) ?: 0).toFloat(), row.maxOfOrNull { entry ->
                 val lp = entry.view.layoutParams as? MarginLayoutParams
-                entry.height + (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
-            } ?: 0)
+                (entry.height + (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)).toFloat()
+            } ?: 0f)
         }
         return GridLayout(rows, absolute, cellWidth, rowHeights)
     }
@@ -573,9 +582,9 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             flowIndex += 1
         }
         val cellWidth = columnWidths.maxOrNull() ?: 0
-        val width = paddingLeft + paddingRight + cellWidth * columns + max(0, columns - 1) * columnGap
+        val width = paddingLeft + paddingRight + cellWidth * columns + (max(0, columns - 1) * columnGap).roundToInt()
         val rowGapTotal = max(0, rowHeights.size - 1) * rowGap
-        val measuredHeight = paddingTop + paddingBottom + rowHeights.sum() + rowGapTotal
+        val measuredHeight = paddingTop + paddingBottom + rowHeights.sum() + rowGapTotal.roundToInt()
         return width to measuredHeight
     }
 
@@ -658,15 +667,15 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     }
 
     /** 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: Int): IntArray {
+    private fun fallbackFlexWidths(line: Line, available: Int, gap: Float): IntArray {
         val horizontal = orientation == HORIZONTAL
         val hypothetical = line.entries.sumOf { entry ->
             val lp = entry.view.layoutParams as? MarginLayoutParams
             val margins = if (horizontal) (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
             else (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
-            (if (horizontal) entry.width else entry.height) + margins
-        } + max(0, line.entries.size - 1) * gap
-        val free = available - hypothetical
+            ((if (horizontal) entry.width else entry.height) + margins).toDouble()
+        } + max(0, line.entries.size - 1) * gap.toDouble()
+        val free = available.toDouble() - hypothetical
         val growTotal = line.entries.sumOf { it.style.flexGrow }
         val shrinkTotal = line.entries.sumOf {
             (it.style.flexShrink ?: defaultFlexShrink(it.view)) * (if (horizontal) it.width else it.height)
@@ -695,7 +704,7 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 }
             }
             if (factor <= 0) return@repeat
-            val remaining = available - fixed - activeBasis
+            val remaining = available.toDouble() - fixed - activeBasis
             var froze = false
             for ((index, entry) in line.entries.withIndex()) {
                 if (frozen[index]) continue
@@ -733,16 +742,16 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 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
+            val desiredWidth = paddingLeft + paddingRight + (layout.cellWidth * gridColumns + max(0, gridColumns - 1) * columnGap).roundToInt()
+            val desiredHeight = paddingTop + paddingBottom + layout.rowHeights.sum().roundToInt() + (max(0, layout.rowHeights.size - 1) * rowGap).roundToInt()
             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)
-        val desiredWidth = if (orientation == HORIZONTAL) main else cross
-        val desiredHeight = if (orientation == HORIZONTAL) cross else main
+        val main = lines.maxOfOrNull { it.main } ?: 0f
+        val cross = lines.sumOf { it.cross.toDouble() } + max(0, lines.size - 1) * (if (orientation == HORIZONTAL) rowGap else columnGap).toDouble()
+        val desiredWidth = if (orientation == HORIZONTAL) main.roundToInt() else cross.roundToInt()
+        val desiredHeight = if (orientation == HORIZONTAL) cross.roundToInt() else main.roundToInt()
         val absWidth = absolute.maxOfOrNull { it.width } ?: 0
         val absHeight = absolute.maxOfOrNull { it.height } ?: 0
         setMeasuredDimension(
@@ -760,12 +769,12 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             // Older runtimes return null for the optional symbol; the local
             // layout below remains the compatibility path in that case.
             val sharedFrames = CraftNative.grid(
-                contentWidth.toFloat(), contentHeight.toFloat(), gridColumns, columnGap.toFloat(), rowGap.toFloat(),
+                contentWidth.toFloat(), contentHeight.toFloat(), gridColumns, columnGap, rowGap,
                 flow.map { it.width.toFloat() }.toFloatArray(), flow.map { it.height.toFloat() }.toFloatArray(),
-                flow.map { it.style.width?.resolve(layout.cellWidth)?.toFloat() ?: Float.NaN }.toFloatArray(),
+                flow.map { it.style.width?.resolve(layout.cellWidth.roundToInt())?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.map { it.style.height?.resolve(null)?.toFloat() ?: Float.NaN }.toFloatArray(),
-                flow.map { it.style.minWidth?.resolve(layout.cellWidth)?.toFloat() ?: Float.NaN }.toFloatArray(),
-                flow.map { it.style.maxWidth?.resolve(layout.cellWidth)?.toFloat() ?: Float.NaN }.toFloatArray(),
+                flow.map { it.style.minWidth?.resolve(layout.cellWidth.roundToInt())?.toFloat() ?: Float.NaN }.toFloatArray(),
+                flow.map { it.style.maxWidth?.resolve(layout.cellWidth.roundToInt())?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.map { it.style.minHeight?.resolve(null)?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.map { it.style.maxHeight?.resolve(null)?.toFloat() ?: Float.NaN }.toFloatArray(),
                 flow.flatMap {
@@ -790,29 +799,29 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 }
             } else {
                 val totalRows = layout.rowHeights.sum()
-                val rowGaps = max(0, layout.rowHeights.size - 1) * rowGap
-                val freeRows = max(0, contentHeight - totalRows - rowGaps)
+                val rowGaps = max(0, layout.rowHeights.size - 1) * rowGap.toFloat()
+                val freeRows = max(0f, contentHeight.toFloat() - totalRows - rowGaps)
                 val rowCount = max(1, layout.rowHeights.size)
-                var rowLeading = 0
-                var rowBetween = rowGap
-                var rowExtra = 0
+                var rowLeading = 0f
+                var rowBetween = rowGap.toFloat()
+                var rowExtra = 0f
                 when (alignContentCode()) {
-                    1 -> rowLeading = freeRows / 2
+                    1 -> rowLeading = freeRows / 2f
                     2 -> rowLeading = freeRows
-                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1)
+                    3 -> if (rowCount > 1) rowBetween += freeRows / (rowCount - 1).toFloat()
                     4 -> {
-                        rowLeading = freeRows / (rowCount * 2)
-                        rowBetween += freeRows / rowCount
+                        rowLeading = freeRows / (rowCount * 2).toFloat()
+                        rowBetween += freeRows / rowCount.toFloat()
                     }
                     6 -> {
-                        rowLeading = freeRows / (rowCount + 1)
-                        rowBetween += freeRows / (rowCount + 1)
+                        rowLeading = freeRows / (rowCount + 1).toFloat()
+                        rowBetween += freeRows / (rowCount + 1).toFloat()
                     }
-                    5 -> rowExtra = freeRows / rowCount
+                    5 -> rowExtra = freeRows / rowCount.toFloat()
                 }
-                var rowTop = paddingTop + rowLeading
+                var rowTop = paddingTop.toFloat() + rowLeading
                 for ((rowIndex, row) in layout.rows.withIndex()) {
-                    val rowHeight = layout.rowHeights[rowIndex] + rowExtra
+                    val rowHeight = layout.rowHeights[rowIndex].toFloat() + rowExtra
                     for ((column, entry) in row.withIndex()) {
                         val align = entry.style.alignSelf ?: alignItems
                         val lp = entry.view.layoutParams as? MarginLayoutParams
@@ -820,20 +829,20 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                         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 availableWidth = max(0f, layout.cellWidth - marginLeft - marginRight)
+                        val availableHeight = max(0, (rowHeight - marginTop - marginBottom).roundToInt())
+                        val childWidth = if (align == "stretch" && entry.style.width == null) availableWidth.roundToInt() else min(availableWidth.roundToInt(), 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
+                        val x = (paddingLeft + column * (layout.cellWidth + columnGap) + marginLeft + when (align) {
+                            "center" -> (availableWidth - childWidth) / 2f
                             "flex-end" -> availableWidth - childWidth
-                            else -> 0
-                        }
-                        val y = rowTop + marginTop + when (align) {
+                            else -> 0f
+                        }).roundToInt()
+                        val y = (rowTop + marginTop + when (align) {
                             "center" -> (availableHeight - childHeight) / 2
                             "flex-end" -> availableHeight - childHeight
                             else -> 0
-                        }
+                        }).roundToInt()
                         entry.view.layout(x, y, x + childWidth, y + childHeight)
                     }
                     rowTop += rowHeight + rowBetween
@@ -857,42 +866,42 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val crossGap = if (orientation == HORIZONTAL) rowGap else columnGap
         val availableMain = if (orientation == HORIZONTAL) contentWidth else contentHeight
         val availableCross = if (orientation == HORIZONTAL) contentHeight else contentWidth
-        val totalCross = lines.sumOf { it.cross } + max(0, lines.size - 1) * crossGap
-        val crossFree = max(0, availableCross - totalCross)
-        var crossLeading = 0
+        val totalCross = lines.sumOf { it.cross.toDouble() }.toFloat() + max(0, lines.size - 1) * crossGap
+        val crossFree = max(0f, availableCross.toFloat() - totalCross)
+        var crossLeading = 0f
         var crossBetween = crossGap
         val sharedCross = if (wrap && lines.size > 1) {
             CraftNative.flexLineDistribution(
-                availableCross.toFloat(), crossGap.toFloat(), alignContentCode(), lines.map { it.cross.toFloat() }.toFloatArray()
+                availableCross.toFloat(), crossGap, alignContentCode(), lines.map { it.cross }.toFloatArray()
             )
         } else null
-        sharedCross?.second?.forEachIndexed { index, size -> lines[index].cross = size.roundToInt() }
+        sharedCross?.second?.forEachIndexed { index, size -> lines[index].cross = size }
         if (wrap && lines.size > 1) {
             if (sharedCross == null) when (alignContent) {
-                "center" -> crossLeading = crossFree / 2
+                "center" -> crossLeading = crossFree / 2f
                 "flex-end" -> crossLeading = crossFree
-                "space-between" -> crossBetween = crossFree / (lines.size - 1) + crossGap
+                "space-between" -> crossBetween = crossFree / (lines.size - 1).toFloat() + crossGap
                 "space-around" -> {
-                    crossBetween = crossFree / lines.size + crossGap
-                    crossLeading = crossFree / (lines.size * 2)
+                    crossBetween = crossFree / lines.size.toFloat() + crossGap
+                    crossLeading = crossFree / (lines.size * 2).toFloat()
                 }
                 "space-evenly" -> {
-                    crossBetween = crossFree / (lines.size + 1) + crossGap
-                    crossLeading = crossFree / (lines.size + 1)
-                }
-                "stretch" -> {
-                    val extra = crossFree / lines.size
-                    lines.forEach { it.cross += extra }
+                    crossBetween = crossFree / (lines.size + 1).toFloat() + crossGap
+                    crossLeading = crossFree / (lines.size + 1).toFloat()
                 }
             }
         }
-        var crossOffset = (if (orientation == HORIZONTAL) paddingTop else paddingLeft) + crossLeading
+        val stretchExtra = if (sharedCross == null && wrap && lines.size > 1 && alignContent == "stretch")
+            crossFree / lines.size.toFloat()
+        else 0f
+        var crossOffset = (if (orientation == HORIZONTAL) paddingTop else paddingLeft).toFloat() + crossLeading
         for ((lineIndex, line) in lines.withIndex()) {
-            val lineOffset = sharedCross?.first?.get(lineIndex)?.roundToInt()?.let { (if (orientation == HORIZONTAL) paddingTop else paddingLeft) + it } ?: crossOffset
+            val lineCross = line.cross.toFloat() + stretchExtra
+            val lineOffset = sharedCross?.first?.get(lineIndex)?.let { (if (orientation == HORIZONTAL) paddingTop else paddingLeft).toFloat() + it } ?: crossOffset
             val fallbackWidths = fallbackFlexWidths(line, availableMain, gap)
             val sharedPrimary = CraftNative.flexRow(
                 availableMain.toFloat(),
-                gap.toFloat(),
+                gap,
                 justifyCode(),
                 line.entries.map { entry -> if (orientation == HORIZONTAL) entry.width.toFloat() else entry.height.toFloat() }.toFloatArray(),
                 line.entries.map { it.style.flexGrow.toFloat() }.toFloatArray(),
@@ -917,8 +926,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                     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)
-                    sharedPrimary[index].roundToInt() + margins
-                } + max(0, line.entries.size - 1) * gap
+                    sharedPrimary[index].toDouble() + margins
+                } + max(0, line.entries.size - 1) * gap.toDouble()
             } else {
                 line.entries.indices.sumOf { index ->
                     val constrained = fallbackWidths[index]
@@ -926,49 +935,50 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                     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
+                }.toDouble() + max(0, line.entries.size - 1) * gap.toDouble()
             }
-            val free = max(0, availableMain - distributedMain)
+            val free = max(0f, availableMain.toFloat() - distributedMain.toFloat())
             val (leading, between) = distribution(free, line.entries.size)
-            var mainOffset = if (orientation == HORIZONTAL) paddingLeft else paddingTop
-            mainOffset += leading
+            var mainOffset = (if (orientation == HORIZONTAL) paddingLeft else paddingTop).toFloat() + leading
             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
                 val crossSize = if ((entry.style.alignSelf ?: alignItems) == "stretch" && (if (orientation == HORIZONTAL) entry.style.height else entry.style.width) == null)
-                    max(0, line.cross - (if (orientation == HORIZONTAL) (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0) else (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)))
+                    max(0, (lineCross - (if (orientation == HORIZONTAL) (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0) else (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0))).roundToInt())
                 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 crossLeading = (if (orientation == HORIZONTAL) lp?.topMargin ?: 0 else lp?.leftMargin ?: 0).toFloat()
+                val crossTrailing = (if (orientation == HORIZONTAL) lp?.bottomMargin ?: 0 else lp?.rightMargin ?: 0).toFloat()
                 val alignment = when (align) {
                     "center" -> 1
                     "flex-end" -> 2
                     else -> 0
                 }
                 val crossPosition = CraftNative.crossAxisPosition(
-                    line.cross.toFloat(), crossSize.toFloat(), crossLeading.toFloat(), crossTrailing.toFloat(), alignment
-                )?.roundToInt() ?: when (alignment) {
-                    1 -> crossLeading + (line.cross - crossLeading - crossTrailing - crossSize) / 2
-                    2 -> line.cross - crossTrailing - crossSize
+                    lineCross, crossSize.toFloat(), crossLeading, crossTrailing, alignment
+                ) ?: when (alignment) {
+                    1 -> crossLeading + (lineCross - crossLeading - crossTrailing - crossSize) / 2f
+                    2 -> lineCross - crossTrailing - crossSize
                     else -> crossLeading
                 }
                 // Shared positions cover every non-reverse justification; the
                 // local main-axis rule remains the fallback for old runtimes
                 // that return widths only.
-                val sharedPosition = if (!reverse) sharedPositions?.get(index)?.roundToInt() else null
-                val positionedMain = sharedPosition?.let { (if (orientation == HORIZONTAL) paddingLeft else paddingTop) + it }
+                // The shared result stores widths in the first half and
+                // main-axis positions in the second half.
+                val sharedPosition = if (!reverse) sharedPositions?.get(line.entries.size + index) else null
+                val positionedMain = sharedPosition?.let { (if (orientation == HORIZONTAL) paddingLeft else paddingTop).toFloat() + it }
                     ?: mainOffset + marginStart
-                val x = if (orientation == HORIZONTAL) positionedMain else lineOffset + crossPosition
-                val y = if (orientation == HORIZONTAL) lineOffset + crossPosition else positionedMain
+                val x = if (orientation == HORIZONTAL) positionedMain.roundToInt() else (lineOffset + crossPosition).roundToInt()
+                val y = if (orientation == HORIZONTAL) (lineOffset + crossPosition).roundToInt() else positionedMain.roundToInt()
                 val distributedPrimary = sharedPrimary?.get(index)?.roundToInt() ?: fallbackWidths[index]
                 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)
                 if (sharedPosition == null) mainOffset += distributedPrimary + marginStart + marginEnd + gap + between
             }
-            if (sharedCross == null) crossOffset += line.cross + crossBetween
+            if (sharedCross == null) crossOffset += lineCross + crossBetween
         }
         for (entry in absolute) {
             if (entry.view is CraftNativeModalView && entry.view.visibility == View.VISIBLE) entry.view.bringToFront()
@@ -981,13 +991,16 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         onLayoutChanged?.invoke()
     }
 
-    private fun distribution(free: Int, count: Int): Pair<Int, Int> = when (justifyContent) {
-        "center" -> free / 2 to 0
-        "flex-end" -> free to 0
-        "space-between" -> 0 to if (count > 1) free / (count - 1) else 0
-        "space-around" -> free / (count * 2) to free / count
-        "space-evenly" -> free / (count + 1) to free / (count + 1)
-        else -> 0 to 0
+    private fun distribution(free: Float, count: Int): Pair<Float, Float> {
+        val available = free
+        return when (justifyContent) {
+            "center" -> available / 2f to 0f
+            "flex-end" -> available to 0f
+            "space-between" -> 0f to if (count > 1) available / (count - 1).toFloat() else 0f
+            "space-around" -> available / (count * 2).toFloat() to available / count.toFloat()
+            "space-evenly" -> available / (count + 1).toFloat() to available / (count + 1).toFloat()
+            else -> 0f to 0f
+        }
     }
 }
 
@@ -2721,12 +2734,24 @@ class MainActivity : AppCompatActivity() {
                 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 }
+                // A stepped slider needs one native position per authored
+                // step; a fixed 1,000-position SeekBar silently made large
+                // ranges unable to represent most valid values. Continuous
+                // sliders retain the bounded scale to avoid an enormous max.
+                val progressMax = step?.let {
+                    ceil((maximum - minimum) / it).toInt().coerceIn(1, 1_000_000)
+                } ?: 1000
+                max = progressMax
                 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)
+                val value = (if (step != null) minimum + ((requested - minimum) / step).roundToInt() * step else requested)
+                    .coerceIn(minimum, maximum)
+                progress = if (step != null) {
+                    ((value - minimum) / step).roundToInt().coerceIn(0, max)
+                } else {
+                    (((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)) }
@@ -2742,25 +2767,19 @@ class MainActivity : AppCompatActivity() {
                 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
-                            }
-                        }
+                        val value = (if (step != null) minimum + progress * step else
+                            minimum + (maximum - minimum) * progress.toDouble() / max.toDouble())
+                            .coerceIn(minimum, maximum)
                         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
+                        val value = (if (step != null) minimum + seekBar.progress * step else
+                            minimum + (maximum - minimum) * seekBar.progress.toDouble() / max.toDouble())
+                            .coerceIn(minimum, maximum)
                         send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("value", value)))
                     }
                 })