craft-native 0.0.163 → 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,8 +799,8 @@ 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).toFloat()
+                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 = 0f
                 var rowBetween = rowGap.toFloat()
@@ -820,15 +829,15 @@ 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 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 else min(availableWidth, entry.width)
+                        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
-                        }
+                            else -> 0f
+                        }).roundToInt()
                         val y = (rowTop + marginTop + when (align) {
                             "center" -> (availableHeight - childHeight) / 2
                             "flex-end" -> availableHeight - childHeight
@@ -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,9 +935,9 @@ 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).toFloat() + leading
             for ((index, entry) in line.entries.withIndex()) {
@@ -936,38 +945,40 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
                 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
+                // 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.roundToInt() else lineOffset + crossPosition
-                val y = if (orientation == HORIZONTAL) lineOffset + crossPosition else positionedMain.roundToInt()
+                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()
@@ -980,8 +991,8 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         onLayoutChanged?.invoke()
     }
 
-    private fun distribution(free: Int, count: Int): Pair<Float, Float> {
-        val available = free.toFloat()
+    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
@@ -2723,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)) }
@@ -2744,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)))
                     }
                 })

package/dist/api/mobile.d.ts

@@ -1375,12 +1375,14 @@ export declare const pushNotifications: {
     onReceive(callback: (data: Record<string, unknown>) => void): () => void;
 };
 export type HealthDataType = 'steps' | 'heartRate' | 'activeEnergy' | 'distance' | 'workouts' | 'restingHeartRate' | 'heartRateVariability' | 'bodyMass' | 'sleep'
-/** Food logged by any app, per day: kcal eaten, then grams of protein, carbohydrate and fat. Read only. */
+/** Food logged by any app, per day: kcal eaten, then grams of protein, carbohydrate and fat. */
  | 'dietaryEnergy' | 'dietaryProtein' | 'dietaryCarbohydrates' | 'dietaryFat'
 /** Mindful minutes (meditation, breathing): read with getMindfulSessions, written with saveMindfulSession. */
  | 'mindful';
 /** The types with one value per day. `sleep` is hours asleep, counted on the day you woke. */
 export type HealthDailyType = Exclude<HealthDataType, 'workouts' | 'mindful'>;
+/** Quantity types that can be written with `health.saveData()`. */
+export type HealthQuantityType = Exclude<HealthDataType, 'workouts' | 'sleep' | 'mindful'>;
 export interface HealthAuthorizationOptions {
     /** `false` asks to read only. Default: also allowed to save workouts. */
     write?: boolean;
@@ -1393,6 +1395,10 @@ export interface HealthDataResult {
     value: number;
     unit: string;
 }
+export interface HealthDataSaveResult {
+    /** HealthKit's UUID for the saved quantity sample. */
+    id: string;
+}
 export type HealthWorkoutType = 'running' | 'walking' | 'hiking' | 'cycling';
 export interface HealthWorkoutLocation {
     latitude: number;
@@ -1530,7 +1536,7 @@ export interface HealthMindfulSample {
     deviceName?: string;
 }
 /** The health reads and writes a host may or may not have, depending on the app build it runs in. */
-export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSleepIntervals' | 'saveMindfulSession' | 'getMindfulSessions';
+export type HealthReadMethod = 'getWorkouts' | 'getDailyStatistics' | 'getHeartRateSamples' | 'getSleepIntervals' | 'saveData' | 'saveMindfulSession' | 'getMindfulSessions';
 export declare const health: {
     /**
      * Whether this app build answers `method`. An app installed before a read
@@ -1544,6 +1550,8 @@ export declare const health: {
      */
     requestAuthorization(types: HealthDataType[], options?: HealthAuthorizationOptions): Promise<boolean>;
     getData(type: HealthDataType, options?: HealthDataOptions): Promise<HealthDataResult>;
+    /** Save one quantity sample, such as a meal's dietary energy or macros. iOS only for now. */
+    saveData(type: HealthQuantityType, value: number, options?: HealthDataOptions): Promise<HealthDataSaveResult>;
     saveWorkout(workout: HealthWorkout): Promise<HealthWorkoutResult>;
     /** Workouts in Apple Health, newest first. iOS only for now. */
     getWorkouts(options?: HealthWorkoutQuery): Promise<HealthWorkoutSample[]>;

package/dist/cli.js

@@ -3303,7 +3303,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.163";
+var version = "0.0.164";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -310,7 +310,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.163";
+var version = "0.0.164";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -58,7 +58,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.163";
+var version = "0.0.164";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftApp.swift

@@ -738,6 +738,18 @@ final class CraftChrome: ObservableObject {
         emit("craftTabSelect", ["id": tab.id])
     }
 
+    /// A completed horizontal swipe selects the adjacent tab. The shell owns
+    /// this path so it works over both native screens and the shared WebView.
+    /// The gesture recognizer yields before calling this for a screen-owned
+    /// horizontal scroll or custom pager.
+    func swipe(to id: String) {
+        guard id != selected, tabs.contains(where: { $0.id == id }) else { return }
+        withAnimation(Self.motion(.spring(response: 0.32, dampingFraction: 0.86))) { selected = id }
+        UISelectionFeedbackGenerator().selectionChanged()
+        guard CraftHybrid.shared.tabTapped(id, reselect: false) else { return }
+        emit("craftTabSelect", ["id": id])
+    }
+
     /// The animation, or none with Reduce Motion on: the selection jumps to
     /// its tab rather than springing there, as UIKit's own controls do.
     static func motion(_ animation: Animation) -> Animation? {
@@ -2514,6 +2526,21 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
                 }
+            case "saveHealthData":
+                if config.enableHealthKit {
+                    guard let dataType = body["type"] as? String,
+                          let value = (body["value"] as? NSNumber)?.doubleValue else {
+                        rejectCallback(callbackId, error: "saveHealthData was called without a type and numeric value", code: "INVALID_ARGUMENT")
+                        break
+                    }
+                    CraftHealth.shared.saveData(
+                        type: dataType,
+                        value: value,
+                        options: body
+                    ) { [weak self] in self?.answer(callbackId, $0) }
+                } else {
+                    rejectCallback(callbackId, error: "HealthKit is disabled", code: "CAPABILITY_DISABLED")
+                }
             case "saveHealthWorkout":
                 if config.enableHealthKit {
                     saveHealthWorkout(body: body, callbackId: callbackId)
@@ -5077,6 +5104,10 @@ struct CraftWebView: UIViewRepresentable {
                         options = options || {};
                         return craft._invoke('getHealthData', {type: type, startDate: options.startDate, endDate: options.endDate});
                     },
+                    saveData: function(type, value, options) {
+                        options = options || {};
+                        return craft._invoke('saveHealthData', {type: type, value: value, startDate: options.startDate, endDate: options.endDate});
+                    },
                     saveWorkout: function(workout) { return craft._invoke('saveHealthWorkout', workout || {}); },
                     getWorkouts: function(options) {
                         options = options || {};

package/dist/ios/templates/CraftHealth.swift

@@ -32,6 +32,13 @@ final class CraftHealth {
         case "getData":
             guard let type = args.first as? String else { return completion(.failure(CraftHealthError(message: "getData needs a type", code: "INVALID_ARGUMENT"))) }
             getData(type: type, startDate: options(1)["startDate"] as? Double, endDate: options(1)["endDate"] as? Double, completion: completion)
+        case "saveData":
+            guard let type = args.first as? String,
+                  args.count > 1,
+                  let value = (args[1] as? NSNumber)?.doubleValue else {
+                return completion(.failure(CraftHealthError(message: "saveData needs a type and numeric value", code: "INVALID_ARGUMENT")))
+            }
+            saveData(type: type, value: value, options: options(2), completion: completion)
         case "saveWorkout":
             saveWorkout(body: options(0), completion: completion)
         case "getWorkouts":
@@ -120,12 +127,15 @@ final class CraftHealth {
                 }
             case "dietaryEnergy", "dietaryProtein", "dietaryCarbohydrates", "dietaryFat":
                 // What a food log (MyFitnessPal, Lose It!, Cronometer...)
-                // writes to Apple Health: read only, never written back.
+                // writes to Apple Health. Request the write grant too unless
+                // the caller explicitly asked for a read-only authorization.
                 if let dietaryType = Self.healthQuantity(type)?.type {
                     readTypes.insert(dietaryType)
+                    if !readOnly { shareTypes.insert(dietaryType) }
                 }
             default:
-                break
+                completion(.failure(CraftHealthError(message: "Unknown health data type: \(type)", code: "INVALID_ARGUMENT")))
+                return
             }
         }
 
@@ -179,6 +189,42 @@ final class CraftHealth {
         healthStore.execute(query)
     }
 
+    /// Save one quantity sample, primarily a food-log entry. Dates are epoch
+    /// milliseconds; an omitted range records an instantaneous sample now.
+    func saveData(type: String, value: Double, options: [String: Any], completion: @escaping Completion) {
+        guard let healthStore = healthStore else {
+            completion(.failure(CraftHealthError(message: "HealthKit not available")))
+            return
+        }
+        guard value.isFinite, value >= 0 else {
+            completion(.failure(CraftHealthError(message: "saveData needs a finite, non-negative value", code: "INVALID_ARGUMENT")))
+            return
+        }
+        guard let spec = Self.healthQuantity(type), let qType = spec.type else {
+            completion(.failure(CraftHealthError(message: "Unknown health data type: \(type)", code: "INVALID_ARGUMENT")))
+            return
+        }
+        let startValue = options["startDate"] as? Double ?? Date().timeIntervalSince1970 * 1000
+        let endValue = options["endDate"] as? Double ?? startValue
+        guard startValue.isFinite, endValue.isFinite, endValue >= startValue else {
+            completion(.failure(CraftHealthError(message: "saveData needs a valid date range", code: "INVALID_ARGUMENT")))
+            return
+        }
+        let sample = HKQuantitySample(
+            type: qType,
+            quantity: HKQuantity(unit: spec.unit, doubleValue: value),
+            start: Date(timeIntervalSince1970: startValue / 1000),
+            end: Date(timeIntervalSince1970: endValue / 1000)
+        )
+        healthStore.save(sample) { success, error in
+            if success {
+                completion(.success(["id": sample.uuid.uuidString]))
+            } else {
+                completion(.failure(CraftHealthError(message: error?.localizedDescription ?? "Health data could not be saved")))
+            }
+        }
+    }
+
     func saveWorkout(body: [String: Any], completion: @escaping Completion) {
         guard let healthStore = healthStore else {
             completion(.failure(CraftHealthError(message: "HealthKit not available")))

package/dist/ios/templates/CraftHybrid.swift

@@ -1004,6 +1004,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     private var openingWeb = false
     private var firstFrameLogged = false
     private var tabBarHeight: CGFloat = 0
+    private var tabSwipeRecognizers: [UISwipeGestureRecognizer] = []
 
     init(config: CraftConfig) {
         self.config = config
@@ -1033,6 +1034,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         let tabs = hybrid.tabIds
         let start = CraftHybridRoutes.tab(owning: hybrid.startPath, among: tabs) ?? tabs.first ?? ""
         show(tab: start, rootPath: hybrid.startPath)
+        installTabSwipeGestures()
         if hybrid.hasWeb && hybrid.startsNative {
             DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { [weak self] in self?.attachWeb() }
         }
@@ -1043,6 +1045,42 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
 
     private var webAttached = false
 
+    private func installTabSwipeGestures() {
+        guard tabSwipeRecognizers.isEmpty else { return }
+        for direction in [UISwipeGestureRecognizer.Direction.left, .right] {
+            let recognizer = UISwipeGestureRecognizer(target: self, action: #selector(tabSwipeRecognized(_:)))
+            recognizer.direction = direction
+            recognizer.delegate = self
+            recognizer.cancelsTouchesInView = false
+            recognizer.delaysTouchesBegan = false
+            view.addGestureRecognizer(recognizer)
+            tabSwipeRecognizers.append(recognizer)
+        }
+    }
+
+    @objc private func tabSwipeRecognized(_ recognizer: UISwipeGestureRecognizer) {
+        let tabs = hybrid.tabIds
+        guard let index = tabs.firstIndex(of: currentTab), tabs.count > 1 else { return }
+        let next = recognizer.direction == .left ? index + 1 : index - 1
+        guard tabs.indices.contains(next) else { return }
+        CraftChrome.shared.swipe(to: tabs[next])
+    }
+
+    private func horizontalScrollAt(_ point: CGPoint, in root: UIView) -> Bool {
+        let local = root.convert(point, from: view)
+        guard root.bounds.contains(local), let hit = root.hitTest(local, with: nil) else { return false }
+        var candidate: UIView? = hit
+        while let current = candidate {
+            if let scroll = current as? UIScrollView,
+               scroll.isScrollEnabled,
+               scroll.alwaysBounceHorizontal || scroll.contentSize.width > scroll.bounds.width + 1 {
+                return true
+            }
+            candidate = current.superview
+        }
+        return false
+    }
+
     /// The web view joins the screen, behind the native screens, and loads.
     private func attachWeb() {
         guard let webHost, !webAttached else { return }
@@ -1481,8 +1519,19 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
     }
 
     func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+        if tabSwipeRecognizers.contains(where: { $0 === gestureRecognizer }) {
+            guard hybrid.tabIds.count > 1, let top = visibleStack?.topViewController else { return false }
+            if let native = top as? CraftNativeScreenController,
+               !native.tabSwipeEnabled || !native.contentSwipeBack { return false }
+            return !horizontalScrollAt(gestureRecognizer.location(in: view), in: top.view)
+        }
         guard let nav = visibleStack, isPopRecognizer(gestureRecognizer),
               nav.viewControllers.count > 1, nav.transitionCoordinator == nil else { return false }
+        if let native = nav.topViewController as? CraftNativeScreenController,
+           gestureRecognizer !== nav.interactivePopGestureRecognizer,
+           !native.contentSwipeBack {
+            return false
+        }
         if let native = nav.topViewController as? CraftNativeScreenController,
            gestureRecognizer !== nav.interactivePopGestureRecognizer,
            nativeScreenContainsHorizontalScroll(native) {

package/dist/ios/templates/CraftNativeActions.swift

@@ -40,7 +40,7 @@ enum CraftNativeActions {
     static func capabilities(config: CraftConfig) -> [String] {
         // `speech`, `audio` (background sound) and `eventStream` (a fetch read
         // as it arrives) need nothing the app has to declare.
-        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking"]
+        var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge"]
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -76,6 +76,9 @@ enum CraftNativeActions {
         // runs out of process and asks no permission. Taking a photo needs
         // the camera, which the app declares.
         values.append("files")
+        // Video and audio kept on the phone for offline (CraftNativeMedia),
+        // which the native Video element plays in place of the address.
+        values.append("media")
         if config.enableCamera { values.append("camera") }
         return values
     }
@@ -190,6 +193,19 @@ enum CraftNativeActions {
             return
         case ("Files", "remove"):
             sync = .success(CraftNativeFiles.remove(args.first as? String ?? ""))
+        case ("Media", "keep"):
+            keepMedia(requestToken: requestToken, args: args, completion: completion)
+            return
+        case ("Media", "path"):
+            sync = .success(CraftNativeMedia.local(args.first as? String ?? "")?.path ?? NSNull())
+        case ("Media", "prune"):
+            let keep = (args.first as? [Any] ?? []).compactMap { $0 as? String }
+            DispatchQueue.global(qos: .utility).async {
+                complete(requestToken, .success(CraftNativeMedia.prune(keep: keep)), completion)
+            }
+            return
+        case ("Media", "usage"):
+            sync = .success(CraftNativeMedia.usage())
         case ("Lifecycle", "getState"):
             sync = .success(currentAppState())
         case ("DeepLinks", "getInitialURL"):
@@ -440,6 +456,19 @@ enum CraftNativeActions {
                 complete(requestToken, .success(true), completion)
             }
             return
+        case ("Badge", "set"):
+            guard let value = args.first as? NSNumber,
+                  value.doubleValue.isFinite,
+                  value.doubleValue >= 0,
+                  value.doubleValue.rounded() == value.doubleValue else {
+                complete(requestToken, failure("INVALID_ARGUMENT", "Badge.set needs a non-negative whole number"), completion)
+                return
+            }
+            setBadgeCount(value.intValue) { complete(requestToken, $0, completion) }
+            return
+        case ("Badge", "clear"):
+            setBadgeCount(0) { complete(requestToken, $0, completion) }
+            return
         case ("Notifications", _):
             guard config.enableLocalNotifications else {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Local notifications are disabled"), completion)
@@ -614,6 +643,63 @@ enum CraftNativeActions {
         if !alreadyCancelled { task.resume() }
     }
 
+    /// `craft.media.keep`: the file at an address kept on the phone for
+    /// offline, fetched once (a copy already there answers at once, and two
+    /// screens asking at the same time share one download). A refused answer
+    /// (not 2xx) keeps nothing and says its status. Cancelled like fetch.
+    private static func keepMedia(
+        requestToken: String,
+        args: [Any],
+        completion: @escaping (Result<Any, CraftNativeActionError>) -> Void
+    ) {
+        guard let address = args.first as? String,
+              let url = URL(string: address),
+              let scheme = url.scheme?.lowercased(), scheme == "https" || scheme == "http",
+              url.host?.isEmpty == false else {
+            complete(requestToken, failure("INVALID_ARGUMENT", "media.keep needs an absolute http or https URL"), completion)
+            return
+        }
+        if let kept = CraftNativeMedia.local(address) {
+            complete(requestToken, .success(CraftNativeMedia.describe(address, kept)), completion)
+            return
+        }
+        let options = args.count > 1 ? args[1] as? [String: Any] ?? [:] : [:]
+        var request = URLRequest(url: url, timeoutInterval: craftNativeFetchTimeoutSeconds)
+        request.httpMethod = "GET"
+        if let headers = options["headers"] as? [String: Any] {
+            for (name, value) in headers {
+                guard let value = value as? String else {
+                    complete(requestToken, failure("INVALID_ARGUMENT", "media.keep header values must be strings"), completion)
+                    return
+                }
+                request.setValue(value, forHTTPHeaderField: name)
+            }
+        }
+        if CraftNativeMedia.join(address, { complete(requestToken, $0, completion) }) { return }
+        let task = fetchSession.downloadTask(with: request) { location, response, error in
+            cancellationLock.lock()
+            fetchTasks.removeValue(forKey: requestToken)
+            cancellationLock.unlock()
+            if let error = error {
+                let code = (error as? URLError)?.code == .timedOut ? "TIMEOUT" : "NETWORK_ERROR"
+                CraftNativeMedia.finish(address, failure(code, error.localizedDescription))
+                return
+            }
+            guard let http = response as? HTTPURLResponse, let location else {
+                CraftNativeMedia.finish(address, failure("NETWORK_ERROR", "media.keep received a response that is not HTTP"))
+                return
+            }
+            // The system deletes `location` once this returns: move it now.
+            CraftNativeMedia.finish(address, CraftNativeMedia.store(address, at: location, response: http))
+        }
+        cancellationLock.lock()
+        let alreadyCancelled = cancelledRequests.contains(requestToken)
+        if !alreadyCancelled { fetchTasks[requestToken] = task }
+        cancellationLock.unlock()
+        if alreadyCancelled { CraftNativeMedia.finish(address, failure("CANCELLED", "media.keep was cancelled")) }
+        else { task.resume() }
+    }
+
     private static func claimInitialDeepLink() -> URL? {
         cancellationLock.lock()
         defer { cancellationLock.unlock() }
@@ -920,6 +1006,30 @@ enum CraftNativeActions {
         }
     }
 
+    /// Set the app icon badge without requesting notification authorization.
+    /// Native screens use this same permission-free path as the page bridge.
+    private static func setBadgeCount(
+        _ count: Int,
+        completion: @escaping (Result<Any, CraftNativeActionError>) -> Void
+    ) {
+        DispatchQueue.main.async {
+            if #available(iOS 16.0, *) {
+                UNUserNotificationCenter.current().setBadgeCount(count) { error in
+                    DispatchQueue.main.async {
+                        if let error {
+                            completion(.failure(CraftNativeActionError(code: "NATIVE_CALL_FAILED", message: error.localizedDescription)))
+                        } else {
+                            completion(.success(true))
+                        }
+                    }
+                }
+            } else {
+                UIApplication.shared.applicationIconBadgeNumber = count
+                completion(.success(true))
+            }
+        }
+    }
+
     static func deepLinkData(_ url: URL) -> [String: Any] {
         let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
         return [

package/dist/ios/templates/CraftNativeFiles.swift

@@ -1,3 +1,4 @@
+import CryptoKit
 import Foundation
 import ImageIO
 import PhotosUI
@@ -375,3 +376,109 @@ enum CraftNativeFiles {
         return ["ok": false, "status": response.statusCode, "body": text]
     }
 }
+
+// `craft.media` on a native screen: video and audio kept on the phone for
+// when there is no signal (a gym's basement, a plane). Not tmp/craft-files,
+// which iOS and the sweep above both empty: Application Support/craft-media,
+// left out of iCloud backups because every file can be fetched again. A file
+// is named by its address's SHA-256, so the native `Video` element finds the
+// copy of the URL it was given and plays it instead, with no lookup in
+// JavaScript. The screen decides what to keep (`keep`) and what to drop
+// (`prune`); nothing is evicted behind its back.
+enum CraftNativeMedia {
+    static var root: URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? FileManager.default.temporaryDirectory
+        return base.appendingPathComponent("craft-media", isDirectory: true)
+    }
+
+    private static let lock = NSLock()
+    /// Addresses being fetched now, so a second `keep` waits for the first.
+    private static var inFlight: [String: [(Result<Any, CraftNativeActionError>) -> Void]] = [:]
+
+    /// Where `address`'s copy lives (whether or not it is there yet). The
+    /// extension is the address's, because AVPlayer reads the type from it.
+    static func file(for address: String) -> URL {
+        let digest = SHA256.hash(data: Data(address.utf8)).map { String(format: "%02x", $0) }.joined()
+        let ext = URL(string: address)?.pathExtension.lowercased() ?? ""
+        let safe = ext.range(of: "^[a-z0-9]{1,5}$", options: .regularExpression) != nil ? ext : "bin"
+        return root.appendingPathComponent("\(digest).\(safe)")
+    }
+
+    /// The copy of `address` on this phone, or nil.
+    static func local(_ address: String) -> URL? {
+        guard !address.isEmpty else { return nil }
+        let url = file(for: address)
+        return FileManager.default.fileExists(atPath: url.path) ? url : nil
+    }
+
+    static func describe(_ address: String, _ url: URL) -> [String: Any] {
+        let size = (try? url.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0
+        return ["ok": true, "url": address, "path": url.path, "size": size]
+    }
+
+    /// Joins a fetch of `address` already under way; true when one was.
+    static func join(_ address: String, _ done: @escaping (Result<Any, CraftNativeActionError>) -> Void) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        if inFlight[address] != nil {
+            inFlight[address]!.append(done)
+            return true
+        }
+        inFlight[address] = [done]
+        return false
+    }
+
+    static func finish(_ address: String, _ result: Result<Any, CraftNativeActionError>) {
+        lock.lock()
+        let waiting = inFlight.removeValue(forKey: address) ?? []
+        lock.unlock()
+        for done in waiting { done(result) }
+    }
+
+    /// A finished download moved into place (atomically, so a half-written
+    /// file is never played), or a refusal with the server's status.
+    static func store(_ address: String, at location: URL, response: HTTPURLResponse) -> Result<Any, CraftNativeActionError> {
+        guard (200..<300).contains(response.statusCode) else {
+            return .success(["ok": false, "url": address, "status": response.statusCode])
+        }
+        let fm = FileManager.default
+        do {
+            var folder = root
+            if !fm.fileExists(atPath: folder.path) {
+                try fm.createDirectory(at: folder, withIntermediateDirectories: true)
+                var values = URLResourceValues()
+                values.isExcludedFromBackup = true
+                try? folder.setResourceValues(values)
+            }
+            let target = file(for: address)
+            let staging = root.appendingPathComponent(UUID().uuidString + ".part")
+            try fm.moveItem(at: location, to: staging)
+            _ = try? fm.removeItem(at: target)
+            try fm.moveItem(at: staging, to: target)
+            return .success(describe(address, target))
+        }
+        catch {
+            return .failure(CraftNativeActionError(code: "IO_ERROR", message: "media.keep could not store the file: \(error.localizedDescription)"))
+        }
+    }
+
+    /// Removes every copy whose address is not in `keep`; answers how many.
+    static func prune(keep: [String]) -> Int {
+        let wanted = Set(keep.map { file(for: $0).lastPathComponent })
+        let files = (try? FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: nil)) ?? []
+        var removed = 0
+        for url in files where !wanted.contains(url.lastPathComponent) {
+            if (try? FileManager.default.removeItem(at: url)) != nil { removed += 1 }
+        }
+        return removed
+    }
+
+    /// What the kept copies come to, in bytes, and how many there are.
+    static func usage() -> [String: Any] {
+        let files = (try? FileManager.default.contentsOfDirectory(at: root, includingPropertiesForKeys: [.fileSizeKey])) ?? []
+        let kept = files.filter { $0.pathExtension != "part" }
+        let bytes = kept.reduce(0) { $0 + ((try? $1.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0) }
+        return ["files": kept.count, "bytes": bytes]
+    }
+}

package/dist/ios/templates/CraftNativeScreen.swift

@@ -341,8 +341,19 @@ private final class CraftNativeVideoView: UIView {
             detachPlayer()
             sourceURI = uri
             loops = false
-            guard let url = URL(string: uri), !uri.isEmpty, url.scheme != nil else {
+            // The copy `craft.media.keep` put on the phone plays in place of
+            // the address, so a kept video plays with no signal.
+            let kept = CraftNativeMedia.local(uri)
+            guard let url = kept ?? URL(string: uri), !uri.isEmpty, kept != nil || url.scheme != nil else {
                 playerController.player = nil
+                // A path with no scheme ("/videos/a.mp4") has nowhere to load
+                // from on a native screen. Say so rather than stay black.
+                if !uri.isEmpty {
+                    DispatchQueue.main.async { [weak self] in
+                        guard let self, self.sourceURI == uri else { return }
+                        self.fire("onError", ["message": "The video address is not a full URL: \(uri)"])
+                    }
+                }
                 return
             }
             let next = AVPlayer(url: url)
@@ -1110,6 +1121,10 @@ private class CraftNativeFlowView: UIStackView {
             }
             if start < items.count { lines.append(start..<items.count) }
         }
+        // Reconciliation reverses the child order for the requested main
+        // axis. A wrapped flex container must keep its lines in cross-axis
+        // order, so restore the groups without changing each line's order.
+        if reverse && wrap && lines.count > 1 { lines.reverse() }
 
         var lineMains: [CGFloat] = []
         var lineCrosses: [CGFloat] = []
@@ -1922,7 +1937,9 @@ private final class CraftNativeSvgView: UIView {
             if let fill = style["fill"] as? String ?? props["fill"] as? String { next.fill = fill }
             if let stroke = style["stroke"] as? String ?? props["stroke"] as? String { next.stroke = stroke }
             if let width = (style["strokeWidth"] as? NSNumber ?? props["strokeWidth"] as? NSNumber) { next.strokeWidth = CGFloat(truncating: width) }
-            if let opacity = props["opacity"] as? NSNumber ?? style["opacity"] as? NSNumber { next.opacity *= CGFloat(truncating: opacity) }
+            // Computed style wins over the component prop, matching Android
+            // and the browser's cascade when both provide opacity.
+            if let opacity = style["opacity"] as? NSNumber ?? props["opacity"] as? NSNumber { next.opacity *= CGFloat(truncating: opacity) }
             if let cap = props["strokeLinecap"] as? String { next.linecap = cap }
             if let join = props["strokeLinejoin"] as? String { next.linejoin = join }
             if let dashes = props["strokeDasharray"] as? [Any] { next.dashes = dashes.compactMap { ($0 as? NSNumber).map { CGFloat(truncating: $0) } } }
@@ -2709,7 +2726,8 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     /// - `craft.secureStorage.getSync(key)`: the Keychain item the web page's
     ///   `craft.secureStorage.set` wrote.
     /// - `craft.navigation.setOptions({ title, largeTitle, hidden, backTitle,
-    ///   rightButtons })`; a right button's tap is the event `navButton`.
+    ///   tabBarHidden, contentSwipeBack, tabSwipeEnabled, rightButtons })`; a right button's
+    ///   tap is the event `navButton`.
     ///
     /// A runtime that assigns `craft.storage` (or the others) afterwards keeps
     /// these: each namespace is a property whose setter adds them back to the
@@ -2953,6 +2971,13 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
     private var navigationBarHidden: Bool?
     /// The app's tab bar away while this screen shows (`tabBarHidden`).
     private var tabBarHidden = false
+    /// Whether iOS 26's content-wide back-swipe may begin on this screen.
+    /// Setting `contentSwipeBack: false` leaves the 32-point edge gesture.
+    private(set) var contentSwipeBack = true
+    /// Whether the shell's horizontal tab switch gesture may begin here.
+    /// This is separate so a screen can keep navigation back while owning its
+    /// own horizontal pager or chart gesture.
+    private(set) var tabSwipeEnabled = true
     private var prefersLargeTitle: Bool?
 
     /// Whether this screen asked for a bar of its own through `setOptions`: a
@@ -2988,6 +3013,12 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 CraftChrome.shared.setHiddenByScreen(hidden)
             }
         }
+        if let contentSwipeBack = options["contentSwipeBack"] as? Bool {
+            self.contentSwipeBack = contentSwipeBack
+        }
+        if let tabSwipeEnabled = options["tabSwipeEnabled"] as? Bool {
+            self.tabSwipeEnabled = tabSwipeEnabled
+        }
         if let hidden = options["hidden"] as? Bool {
             navigationBarHidden = hidden
             if navigationController?.topViewController === self {

package/dist/mobile.js

@@ -1385,6 +1385,12 @@ var health = {
       throw new Error("Health data is unavailable");
     return craft.health.getData(type, options);
   },
+  async saveData(type, value, options = {}) {
+    const craft = getCraftRoot();
+    if (!craft?.health?.saveData)
+      throw new Error("Saving health data is unavailable");
+    return craft.health.saveData(type, value, options);
+  },
   async saveWorkout(workout) {
     const craft = getCraftRoot();
     if (!craft?.health?.saveWorkout)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.163",
+  "version": "0.0.164",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",