craft-native 0.0.254 → 0.0.272

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

@@ -226,6 +226,8 @@ private data class CraftNativeLayoutStyle(
     val bottom: Int? = null,
     val left: Int? = null,
     val alignSelf: String? = null,
+    /** CSS/Yoga order; Kotlin's stable sort preserves source order for ties. */
+    val order: Int = 0,
     val flexGrow: Double = 0.0,
     val flexShrink: Double? = null,
     val flexBasis: CraftNativeLength? = null,
@@ -252,6 +254,7 @@ private data class CraftNativeLayoutStyle(
                 position = craftNativeOptionalString(raw.opt("position")) ?: "relative",
                 top = number("top"), right = number("right"), bottom = number("bottom"), left = number("left"),
                 alignSelf = craftNativeOptionalString(raw.opt("alignSelf"))?.takeUnless { it == "auto" },
+                order = decimal("order")?.toInt() ?: 0,
                 flexGrow = decimal("flexGrow") ?: flex?.coerceAtLeast(0.0) ?: 0.0,
                 flexShrink = decimal("flexShrink") ?: flex?.let { if (it != 0.0) 1.0 else 0.0 },
                 flexBasis = length("flexBasis")
@@ -348,10 +351,131 @@ private class CraftNativeSvgView(context: Context) : View(context) {
     var drawing: JSONObject = JSONObject()
         set(value) {
             field = value
+            animates = hasAnimation(value.optJSONArray("children"))
             invalidate()
             requestLayout()
+            updateFrames()
         }
 
+    /** Whether a shape carries keyframes (SMIL `<animate attributeName="d">`, stx's `Animate`). */
+    private var animates = false
+    /** When this drawing's repetition began (System.nanoTime), 0 while still. */
+    private var animationStart = 0L
+    private var frameScheduled = false
+    private val frameCallback = android.view.Choreographer.FrameCallback { nextFrame() }
+
+    /** Moving now: shown, and animations are on (off is Android's reduced motion). */
+    val isAnimating: Boolean
+        get() = animates && isAttachedToWindow && isShown && ValueAnimator.areAnimatorsEnabled()
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        updateFrames()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        updateFrames()
+    }
+
+    override fun onVisibilityChanged(changedView: View, visibility: Int) {
+        super.onVisibilityChanged(changedView, visibility)
+        updateFrames()
+    }
+
+    /** One frame at a time from the display (Choreographer) while moving; none while still or away. */
+    private fun updateFrames() {
+        if (isAnimating) {
+            if (animationStart == 0L) animationStart = System.nanoTime()
+            if (!frameScheduled) {
+                frameScheduled = true
+                android.view.Choreographer.getInstance().postFrameCallback(frameCallback)
+            }
+        } else {
+            animationStart = 0L
+            if (frameScheduled) {
+                frameScheduled = false
+                android.view.Choreographer.getInstance().removeFrameCallback(frameCallback)
+            }
+        }
+    }
+
+    private fun nextFrame() {
+        frameScheduled = false
+        if (!isAnimating) return updateFrames()
+        // Drawn only while some of it is on screen; a row scrolled away keeps its time.
+        if (getLocalVisibleRect(android.graphics.Rect())) invalidate()
+        frameScheduled = true
+        android.view.Choreographer.getInstance().postFrameCallback(frameCallback)
+    }
+
+    private fun hasAnimation(children: JSONArray?): Boolean {
+        if (children == null) return false
+        return (0 until children.length()).any { index ->
+            val node = children.optJSONObject(index) ?: return@any false
+            if (node.optString("type") == "Animate") node.optJSONObject("props")?.has("frames") == true
+            else hasAnimation(node.optJSONArray("children"))
+        }
+    }
+
+    /** A shape's outline now: between its keyframes while moving, else its own. */
+    private fun outline(node: JSONObject): List<Float>? {
+        if (isAnimating && animationStart != 0L) {
+            val children = node.optJSONArray("children")
+            val animate = children?.let { list -> (0 until list.length()).mapNotNull { list.optJSONObject(it) }.firstOrNull { it.optString("type") == "Animate" } }
+            animate?.optJSONObject("props")?.let { keyframe(it, (System.nanoTime() - animationStart) / 1e9) }?.let { return it }
+        }
+        val geometry = node.optJSONObject("props")?.optJSONArray("geometry") ?: return null
+        return (0 until geometry.length()).map { craftNativeNumber(geometry.opt(it))?.toFloat() ?: Float.NaN }
+    }
+
+    companion object {
+        /**
+         * The outline `elapsed` seconds into an `Animate`'s repetitions, between
+         * the keyframes either side of now (SMIL's linear `calcMode`); null when
+         * it does not animate path data or its repetitions are over.
+         */
+        fun keyframe(props: JSONObject, elapsed: Double): List<Float>? {
+            if (props.optString("attributeName") != "d" || elapsed < 0) return null
+            val duration = craftNativeNumber(props.opt("duration"))?.takeIf { it.isFinite() && it > 0 } ?: return null
+            val raw = props.optJSONArray("frames") ?: return null
+            val frames = (0 until raw.length()).mapNotNull { index ->
+                raw.optJSONArray(index)?.let { frame -> (0 until frame.length()).map { craftNativeNumber(frame.opt(it))?.toFloat() ?: Float.NaN } }
+            }
+            if (frames.size < 2 || frames.size != raw.length()) return null
+            craftNativeNumber(props.opt("repeatCount"))?.let { if (it.isFinite() && elapsed >= it * duration) return null }
+            val given = props.optJSONArray("frameTimes")?.let { times -> (0 until times.length()).mapNotNull { craftNativeNumber(times.opt(it)) } }.orEmpty()
+            val times = if (given.size == frames.size) given else frames.indices.map { it.toDouble() / (frames.size - 1) }
+            val phase = (elapsed % duration) / duration
+            var index = 0
+            while (index < frames.size - 2 && times[index + 1] <= phase) index++
+            val span = times[index + 1] - times[index]
+            val share = if (span > 0) ((phase - times[index]) / span).coerceIn(0.0, 1.0).toFloat() else 0f
+            return interpolate(frames[index], frames[index + 1], share)
+        }
+
+        /** Two outlines with the same commands, a share of the way between; the first when they differ. */
+        fun interpolate(from: List<Float>, to: List<Float>, share: Float): List<Float> {
+            if (from.size != to.size || share <= 0f) return from
+            val out = from.toMutableList()
+            var index = 0
+            while (index < from.size) {
+                if (to[index] != from[index]) return from
+                val count = when (from[index].toInt()) {
+                    0, 1 -> 2
+                    2 -> 6
+                    3 -> 4
+                    4 -> 0
+                    else -> return from
+                }
+                if (index + count >= from.size) return from
+                for (offset in 1..count) out[index + offset] = from[index + offset] + (to[index + offset] - from[index + offset]) * share
+                index += count + 1
+            }
+            return out
+        }
+    }
+
     private data class SvgPaint(
         val fill: String? = "#000000",
         val stroke: String? = null,
@@ -486,25 +610,25 @@ private class CraftNativeSvgView(context: Context) : View(context) {
             when (node.optString("type")) {
                 "G" -> drawNodes(canvas, node.optJSONArray("children") ?: JSONArray(), paint)
                 "SvgText" -> drawText(canvas, node, paint)
+                "Animate" -> Unit
                 else -> drawPath(canvas, node, paint)
             }
         }
     }
 
     private fun drawPath(canvas: Canvas, node: JSONObject, style: SvgPaint) {
-        val props = node.optJSONObject("props") ?: JSONObject()
-        val geometry = props.optJSONArray("geometry") ?: return
-        if ((0 until geometry.length()).any { craftNativeNumber(geometry.opt(it))?.toFloat()?.isFinite() != true }) return
+        val geometry = outline(node) ?: return
+        if (geometry.any { !it.isFinite() }) return
         val path = Path()
         var index = 0
-        while (index < geometry.length()) {
-            val command = craftNativeNumber(geometry.opt(index))?.toInt() ?: break
-            fun number(offset: Int): Float = craftNativeNumber(geometry.opt(index + offset))?.toFloat() ?: Float.NaN
+        while (index < geometry.size) {
+            val command = geometry[index].toInt()
+            fun number(offset: Int): Float = geometry[index + offset]
             when (command) {
-                0 -> if (index + 2 < geometry.length()) { path.moveTo(number(1), number(2)); index += 3 } else break
-                1 -> if (index + 2 < geometry.length()) { path.lineTo(number(1), number(2)); index += 3 } else break
-                2 -> if (index + 6 < geometry.length()) { path.cubicTo(number(1), number(2), number(3), number(4), number(5), number(6)); index += 7 } else break
-                3 -> if (index + 4 < geometry.length()) { path.quadTo(number(1), number(2), number(3), number(4)); index += 5 } else break
+                0 -> if (index + 2 < geometry.size) { path.moveTo(number(1), number(2)); index += 3 } else break
+                1 -> if (index + 2 < geometry.size) { path.lineTo(number(1), number(2)); index += 3 } else break
+                2 -> if (index + 6 < geometry.size) { path.cubicTo(number(1), number(2), number(3), number(4), number(5), number(6)); index += 7 } else break
+                3 -> if (index + 4 < geometry.size) { path.quadTo(number(1), number(2), number(3), number(4)); index += 5 } else break
                 4 -> { path.close(); index += 1 }
                 else -> break
             }
@@ -759,6 +883,42 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
     private var safeAreaPadding = intArrayOf(0, 0, 0, 0)
     private var applyingPadding = false
     private var safeAreaEdges = setOf("top", "right", "bottom", "left")
+    private var shieldedModalTouch = false
+    private var dismissibleModalTouch: CraftNativeModalView? = null
+
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+        if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+            val x = event.x.roundToInt()
+            val y = event.y.roundToInt()
+            dismissibleModalTouch = (childCount - 1 downTo 0).asSequence()
+                .map { getChildAt(it) }
+                .filterIsInstance<CraftNativeModalView>()
+                .firstOrNull { child ->
+                    child.dismissOnOutsideTap && child.visibility == View.VISIBLE && child.alpha > 0.01f
+                        && (x < child.left || x >= child.right || y < child.top || y >= child.bottom)
+                }
+            shieldedModalTouch = (childCount - 1 downTo 0).any { index ->
+                val child = getChildAt(index)
+                child is CraftNativeModalView && !child.blocksBackground && child.visibility == View.VISIBLE
+                    && (x < child.left || x >= child.right || y < child.top || y >= child.bottom)
+                    && child.hasBlockingModalBelow()
+            }
+        }
+        dismissibleModalTouch?.let { modal ->
+            if (event.actionMasked == MotionEvent.ACTION_UP) {
+                modal.requestClose(reason = "backdrop")
+                dismissibleModalTouch = null
+            } else if (event.actionMasked == MotionEvent.ACTION_CANCEL) {
+                dismissibleModalTouch = null
+            }
+            return true
+        }
+        if (shieldedModalTouch) {
+            if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL) shieldedModalTouch = false
+            return true
+        }
+        return super.dispatchTouchEvent(event)
+    }
 
     override fun setPadding(left: Int, top: Int, right: Int, bottom: Int) {
         if (!applyingPadding) authoredPadding = intArrayOf(left, top, right, bottom)
@@ -991,6 +1151,11 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         invalidateMeasurementAncestors(parent)
     }
 
+    /** Flex/grid order with Kotlin's stable sort retaining source order for ties. */
+    private fun orderedChildIndices(): List<Int> = (0 until childCount).sortedWith(
+        compareBy<Int> { styles[getChildAt(it)]?.order ?: 0 }.thenBy { it },
+    )
+
     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: 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>)
@@ -1002,7 +1167,7 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val lines = mutableListOf<Line>()
         val absolute = mutableListOf<Entry>()
         val pending = mutableListOf<Entry>()
-        for (index in 0 until childCount) {
+        for (index in orderedChildIndices()) {
             val child = getChildAt(index)
             if (child.visibility == GONE) continue
             val style = styles[child] ?: CraftNativeLayoutStyle()
@@ -1010,13 +1175,25 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             val horizontalMargins = (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
             val verticalMargins = (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
             if (child is CraftNativeModalView) {
-                val modalWidth = max(0, width - paddingLeft - paddingRight)
-                val modalHeight = max(0, height - paddingTop - paddingBottom)
-                child.measure(
-                    View.MeasureSpec.makeMeasureSpec(modalWidth, View.MeasureSpec.EXACTLY),
-                    View.MeasureSpec.makeMeasureSpec(modalHeight, View.MeasureSpec.EXACTLY),
-                )
-                absolute += Entry(child, style, modalWidth, modalHeight)
+                if (child.blocksBackground) {
+                    val modalWidth = max(0, width - paddingLeft - paddingRight)
+                    val modalHeight = max(0, height - paddingTop - paddingBottom)
+                    child.measure(
+                        View.MeasureSpec.makeMeasureSpec(modalWidth, View.MeasureSpec.EXACTLY),
+                        View.MeasureSpec.makeMeasureSpec(modalHeight, View.MeasureSpec.EXACTLY),
+                    )
+                    absolute += Entry(child, style, modalWidth, modalHeight)
+                } else {
+                    // A non-modal popup is still promoted to the screen root,
+                    // but its authored absolute style controls its viewport
+                    // frame instead of turning it into a full-screen child.
+                    // The root content box is the same screenViewport origin
+                    // returned by View.measure; safe-area padding is not
+                    // injected a second time here.
+                    val childWidth = measureChildWidth(child, style, width - paddingLeft - paddingRight, horizontalMargins)
+                    val childHeight = measureChildHeight(child, style, height - paddingTop - paddingBottom, verticalMargins)
+                    absolute += Entry(child, style, childWidth, childHeight)
+                }
                 continue
             }
             val childWidth = measureChildWidth(child, style, width - paddingLeft - paddingRight, horizontalMargins)
@@ -1101,7 +1278,7 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         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) {
+        for (index in orderedChildIndices()) {
             val child = getChildAt(index)
             if (child.visibility == GONE) continue
             val style = styles[child] ?: CraftNativeLayoutStyle()
@@ -1109,13 +1286,19 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
             val horizontalMargins = (lp?.leftMargin ?: 0) + (lp?.rightMargin ?: 0)
             val verticalMargins = (lp?.topMargin ?: 0) + (lp?.bottomMargin ?: 0)
             if (child is CraftNativeModalView) {
-                val modalWidth = max(0, width - paddingLeft - paddingRight)
-                val modalHeight = max(0, height - paddingTop - paddingBottom)
-                child.measure(
-                    View.MeasureSpec.makeMeasureSpec(modalWidth, View.MeasureSpec.EXACTLY),
-                    View.MeasureSpec.makeMeasureSpec(modalHeight, View.MeasureSpec.EXACTLY),
-                )
-                absolute += Entry(child, style, modalWidth, modalHeight)
+                if (child.blocksBackground) {
+                    val modalWidth = max(0, width - paddingLeft - paddingRight)
+                    val modalHeight = max(0, height - paddingTop - paddingBottom)
+                    child.measure(
+                        View.MeasureSpec.makeMeasureSpec(modalWidth, View.MeasureSpec.EXACTLY),
+                        View.MeasureSpec.makeMeasureSpec(modalHeight, View.MeasureSpec.EXACTLY),
+                    )
+                    absolute += Entry(child, style, modalWidth, modalHeight)
+                } else {
+                    val childWidth = measureChildWidth(child, style, width - paddingLeft - paddingRight, horizontalMargins)
+                    val childHeight = measureChildHeight(child, style, height - paddingTop - paddingBottom, verticalMargins)
+                    absolute += Entry(child, style, childWidth, childHeight)
+                }
                 continue
             }
             val childWidth = measureChildWidth(child, style, cellWidth.roundToInt(), horizontalMargins)
@@ -1149,7 +1332,7 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         val columnWidths = IntArray(columns)
         val rowHeights = mutableListOf<Int>()
         var flowIndex = 0
-        for (index in 0 until childCount) {
+        for (index in orderedChildIndices()) {
             val child = getChildAt(index)
             if (child.visibility == GONE) continue
             val style = styles[child] ?: CraftNativeLayoutStyle()
@@ -1796,7 +1979,7 @@ internal class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         if (absolute.isEmpty() && lines.isNotEmpty() && (lines.size == 1 || wrap)) {
             val sharedEntries = if (wrap) lines.flatMap { it.entries } else lines[0].entries
             val sharedTree = sharedTreeFrames(sharedEntries, width, height)
-            if (sharedTree != null && (sharedTree.nodes.size > sharedEntries.size + 1 || grid)) {
+            if (sharedTree != null && (sharedTree.nodes.size > sharedEntries.size + 1 || grid || reverse || wrapReverse || gridAutoRows != null || gridRows != null)) {
                 for (index in 1 until sharedTree.nodes.size) {
                     val view = sharedTree.nodes[index].view ?: continue
                     val offset = index * 4
@@ -2560,6 +2743,8 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
     private var animationGeneration = 0
     var focusToRestore: View? = null
     var onRequestClose: ((String) -> Unit)? = null
+    var viewportStyle = JSONObject()
+    var declarationPath = ""
 
     var transparent: Boolean = false
         set(value) {
@@ -2567,6 +2752,18 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
             blocker.setBackgroundColor(if (value) Color.TRANSPARENT else Color.argb(82, 0, 0, 0))
         }
 
+    /** Existing Modal nodes block by default; non-modal popups let outside taps through. */
+    var blocksBackground: Boolean = true
+        set(value) {
+            field = value
+            isClickable = value
+            blocker.isClickable = value
+            blocker.isEnabled = value
+        }
+
+    /** A non-modal popup may opt into consuming an outside tap for dismissal. */
+    var dismissOnOutsideTap: Boolean = false
+
     init {
         isClickable = true
         blocker.isClickable = true
@@ -2580,6 +2777,7 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
     }
 
     fun requestClose(reason: String = "backdrop") {
+        if (!blocksBackground && !dismissOnOutsideTap) return
         val handler = onRequestClose ?: return
         isClickable = false
         blocker.isEnabled = false
@@ -2588,8 +2786,8 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
 
     fun setVisible(visible: Boolean, opacity: Float, animationType: String?) {
         if (visible) {
-            isClickable = true
-            blocker.isEnabled = true
+            isClickable = blocksBackground
+            blocker.isEnabled = blocksBackground
         }
         if (renderedVisible == visible && visibility == if (visible) View.VISIBLE else View.GONE) {
             if (visible && alpha != opacity) alpha = opacity
@@ -2643,9 +2841,33 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
         translationY = 0f
         alpha = 0f
         isClickable = true
+        blocksBackground = true
+        dismissOnOutsideTap = false
         blocker.isEnabled = true
         onRequestClose = null
     }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        if (!blocksBackground) {
+            if (dismissOnOutsideTap && event.action == MotionEvent.ACTION_UP) {
+                requestClose(reason = "backdrop")
+                return true
+            }
+            // Do not let an outside popup tap fall through to a blocking modal
+            // below it; a normal non-modal popup remains pass-through.
+            return hasBlockingModalBelow()
+        }
+        return super.onTouchEvent(event)
+    }
+
+    fun hasBlockingModalBelow(): Boolean {
+        val group = parent as? ViewGroup ?: return false
+        val index = group.indexOfChild(this)
+        return index > 0 && (0 until index).any { siblingIndex ->
+            val sibling = group.getChildAt(siblingIndex)
+            sibling is CraftNativeModalView && sibling.blocksBackground && sibling.visibility == View.VISIBLE && sibling.alpha > 0.01f
+        }
+    }
 }
 
 private data class LayoutBounds(
@@ -2902,7 +3124,8 @@ internal class CraftNativeInputEcho {
  * A native screen's `<Video>`: the platform's VideoView.
  *
  * It plays without taking audio focus, so the person's music carries on
- * under it, as on iOS. `onLoad`, `onPlay`, `onPause`, `onEnd` and `onError`
+ * under it, as on iOS. `onLoadStart`, `onLoad`, `onLoadEnd`, `onPlay`,
+ * `onPause`, `onEnd` and `onError`
  * reach the screen in the web's names, from the controls as well as from
  * props. With `pictureInPicture` the activity takes it into a floating
  * window when the person leaves the app while it plays (MainActivity
@@ -2918,6 +3141,8 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
     private var ended = false
     private var muted = false
     private var resizeMode = "contain"
+    private var requestedTimeSeconds: Double? = null
+    private var pendingSeekSeconds: Double? = null
     private var preparedPlayer: MediaPlayer? = null
     /** The screen's handlers by event name, and how an event reaches them. */
     var handlers: JSONObject = JSONObject()
@@ -2946,12 +3171,25 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
         setAudioFocusRequest(AudioManager.AUDIOFOCUS_NONE)
     }
 
-    fun configure(source: Any?, autoplay: Boolean, paused: Boolean, loop: Boolean, muted: Boolean, controls: Boolean, resizeMode: String?, pictureInPicture: Boolean = false) {
+    private fun applyPendingSeek() {
+        val target = pendingSeekSeconds ?: return
+        if (preparedPlayer == null) return
+        val current = currentPosition.coerceAtLeast(0) / 1000.0
+        pendingSeekSeconds = null
+        if (kotlin.math.abs(current - target) > 0.25) seekTo((target * 1000.0).roundToInt().coerceAtLeast(0))
+    }
+
+    fun configure(source: Any?, autoplay: Boolean, paused: Boolean, loop: Boolean, muted: Boolean, currentTime: Any?, controls: Boolean, resizeMode: String?, pictureInPicture: Boolean = false) {
         val uri = when (source) {
             is String -> source
             is JSONObject -> craftNativeOptionalString(source.opt("uri")).orEmpty()
             else -> ""
         }
+        val nextTime = craftNativeNumber(currentTime)?.takeIf { it.isFinite() && it >= 0.0 }
+        if (nextTime != requestedTimeSeconds) {
+            requestedTimeSeconds = nextTime
+            pendingSeekSeconds = nextTime
+        }
         shouldLoop = loop
         val nextShouldPlay = autoplay && !paused
         if (playIntent != nextShouldPlay) {
@@ -2971,6 +3209,7 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
         setMediaController(if (controls) MediaController(context).also { it.setAnchorView(this) } else null)
         if (uri != sourceUri) {
             sourceUri = uri
+            pendingSeekSeconds = requestedTimeSeconds
             userPaused = false
             ended = false
             stopPlayback()
@@ -2980,6 +3219,7 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
             // A copy kept on the phone (craft.media.keep) plays in place of
             // the address: offline in a gym with no signal.
             val kept = CraftNativeMedia.local(context, uri)
+            fire("onLoadStart")
             setVideoURI(if (kept != null) Uri.fromFile(kept) else Uri.parse(uri))
             setOnPreparedListener { mediaPlayer ->
                 preparedPlayer = mediaPlayer
@@ -2987,7 +3227,9 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
                 mediaPlayer.isLooping = shouldLoop
                 val volume = if (this.muted) 0f else 1f
                 mediaPlayer.setVolume(volume, volume)
+                applyPendingSeek()
                 fire("onLoad", JSONObject().put("duration", duration / 1000.0))
+                fire("onLoadEnd")
                 if (shouldPlay) start()
             }
             setOnCompletionListener {
@@ -3005,6 +3247,7 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
             }
         }
         if (uri.isBlank()) return
+        applyPendingSeek()
         runCatching {
             if (shouldPlay && !isPlaying && !userPaused && !ended) start()
             else if (!shouldPlay && isPlaying) pause()
@@ -3074,6 +3317,8 @@ private class CraftNativeVideoView(context: Context) : VideoView(context) {
         stopPlayback()
         setPlaying(false)
         sourceUri = ""
+        requestedTimeSeconds = null
+        pendingSeekSeconds = null
         playIntent = null
         userPaused = false
         ended = false
@@ -4619,6 +4864,7 @@ class MainActivity : AppCompatActivity() {
         put("viewMeasure")
         put("viewScroll")
         put("viewReparent")
+        put("viewNonModalPresentation")
     }
 
     private fun appVersion(): Pair<String, String> = runCatching {
@@ -4906,6 +5152,9 @@ class MainActivity : AppCompatActivity() {
             if (!updateParentLayoutStyle(updated, document.optJSONObject("style") ?: JSONObject())) return false
         }
         if (applied.isNotEmpty()) {
+            // Updating a modal's content may reattach its nested popups to
+            // their declaration parent. Restore the screen overlay contract.
+            promoteModalOverlays(screen)
             scheduleLayoutEvents(screen)
         }
         return true
@@ -4995,6 +5244,7 @@ class MainActivity : AppCompatActivity() {
         screen.controls.putAll(next)
         screen.handlers.keys.retainAll(retainedViews(screen))
         screen.view.setChildStyle(tree, document.optJSONObject("style") ?: JSONObject(), resources.displayMetrics.density)
+        promoteModalOverlays(screen)
         updateSafeAreaViews()
         // A full render can change a view's custom layout style without
         // changing the root bounds. Ensure native @layout observers still see
@@ -5003,6 +5253,45 @@ class MainActivity : AppCompatActivity() {
         if (visibleScreen === screen) applyStatusBar(screen)
     }
 
+    /** Keep Modal nodes in the screen viewport even when declared in a clipped subtree. */
+    private fun promoteModalOverlays(screen: Screen) {
+        if (screen.modalVisibility.isEmpty()) return
+        // Snapshot parent-before-child order before moving anything. The
+        // controls map registers descendants first, which would place a
+        // parent modal above its own popup when brought forward in that order.
+        val overlays = mutableListOf<CraftNativeModalView>()
+        fun collect(view: View) {
+            if (view is CraftNativeModalView) overlays.add(view)
+            if (view is ViewGroup) for (index in 0 until view.childCount) collect(view.getChildAt(index))
+        }
+        collect(screen.view)
+        // A previous targeted update may already have promoted siblings in a
+        // different order. Use declaration paths, with numeric child indices,
+        // so a nested popup stays above its parent after every update.
+        overlays.sortWith(Comparator { first, second ->
+            val firstPath = first.declarationPath.split('.')
+            val secondPath = second.declarationPath.split('.')
+            for (index in 0 until min(firstPath.size, secondPath.size)) {
+                val left = firstPath[index]
+                val right = secondPath[index]
+                val leftIndex = left.toIntOrNull()
+                val rightIndex = right.toIntOrNull()
+                val order = if (leftIndex != null && rightIndex != null) leftIndex.compareTo(rightIndex) else left.compareTo(right)
+                if (order != 0) return@Comparator order
+            }
+            firstPath.size.compareTo(secondPath.size)
+        })
+        overlays.forEach { modal ->
+            if (modal.parent !== screen.view) {
+                (modal.parent as? ViewGroup)?.removeView(modal)
+                screen.view.addView(modal)
+                // Removing a view clears its old parent's flex style.
+                screen.view.setChildStyle(modal, modal.viewportStyle, resources.displayMetrics.density)
+            }
+            modal.bringToFront()
+        }
+    }
+
     private fun applyStatusBar(screen: Screen) {
         val controller = WindowCompat.getInsetsController(window, window.decorView)
         val night = (resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
@@ -5365,6 +5654,15 @@ class MainActivity : AppCompatActivity() {
             "Modal" -> (previous as? CraftNativeModalView ?: CraftNativeModalView(this)).apply {
                 val focusBeforeContent = screen.view.findFocus()
                 transparent = craftNativeBoolean(props.opt("transparent"))
+                blocksBackground = !craftNativeBoolean(props.opt("nonModal"))
+                dismissOnOutsideTap = craftNativeBoolean(props.opt("dismissOnOutsideTap"))
+                // Modal nodes are promoted from their declaration parent to
+                // the screen root. Keep the authored layout style with that
+                // promoted child so non-modal absolute coordinates remain in
+                // the screen viewport rather than the old clipped parent.
+                viewportStyle = style
+                declarationPath = path
+                screen.view.setChildStyle(this, style, resources.displayMetrics.density)
                 content.configure(style, resources.displayMetrics.density)
                 reconcileChildren(screen, content, children, identity, next, style, previousControls)
                 // Dynamic :visible bindings arrive as a display style mutation;
@@ -5598,6 +5896,7 @@ class MainActivity : AppCompatActivity() {
                     paused = craftNativeBoolean(props.opt("paused")),
                     loop = craftNativeBoolean(props.opt("loop")),
                     muted = craftNativeBoolean(props.opt("muted")),
+                    currentTime = props.opt("currentTime"),
                     controls = craftNativeBoolean(props.opt("controls")),
                     resizeMode = craftNativeResizeMode(style, props),
                     pictureInPicture = craftNativeBoolean(props.opt("pictureInPicture")),
@@ -6001,6 +6300,7 @@ class MainActivity : AppCompatActivity() {
             if (layout.getChildAt(index) is CraftNativeFlexSpacer) layout.removeViewAt(index)
         }
         val desired = mutableListOf<View>()
+        val desiredOrder = mutableMapOf<View, Int>()
         for (index in 0 until children.length()) {
             val child = children.opt(index)
             val childView = when (child) {
@@ -6013,9 +6313,12 @@ class MainActivity : AppCompatActivity() {
             }
             if (childView != null) desired.add(childView)
             if (childView != null && child is JSONObject) {
-                layout.setChildStyle(childView, child.optJSONObject("style") ?: JSONObject(), resources.displayMetrics.density)
+                val childStyle = child.optJSONObject("style") ?: JSONObject()
+                layout.setChildStyle(childView, childStyle, resources.displayMetrics.density)
+                desiredOrder[childView] = craftNativeFiniteNumber(childStyle, "order", 0.0).toInt()
             }
         }
+        desired.sortWith(compareBy { desiredOrder[it] ?: 0 })
         if (craftNativeOptionalString(style.opt("flexDirection"))?.endsWith("-reverse") == true) desired.reverse()
         val desiredSet = desired.toSet()
         for (index in layout.childCount - 1 downTo 0) {
@@ -6754,6 +7057,7 @@ class MainActivity : AppCompatActivity() {
                 linkedControl -> "link"
                 type in setOf("TouchableOpacity", "TouchableHighlight", "Pressable") -> "button"
                 type == "Icon" -> "image"
+                type in setOf("FlatList", "SectionList") -> "list"
                 else -> type.lowercase()
             }
         }
@@ -7467,6 +7771,12 @@ class MainActivity : AppCompatActivity() {
         // released/recycled rows so a later identity cannot inherit a closure
         // that still captures the previous row's screen state.
         released.forEach {
+            // Modals are promoted out of their logical layout into the
+            // screen overlay. Removing the logical node therefore does not
+            // remove the native view through ordinary child reconciliation;
+            // detach every released view so an open popup cannot survive as
+            // an orphan after its owner unmounts.
+            (it.parent as? ViewGroup)?.removeView(it)
             // AdapterView (including Spinner, our native Picker) rejects
             // setOnClickListener altogether. Its selection callback is
             // detached below; ordinary Views still need their click target

package/dist/android/templates/build.gradle.kts.app.template

@@ -111,6 +111,11 @@ dependencies {
     // Android Health Connect (included only when enabled)
 {{HEALTH_CONNECT_DEPENDENCIES}}
 
+    // Android Health Services live exercise tracking (included only when enabled)
+{{HEALTH_SERVICES_DEPENDENCIES}}
+
+{{WALLET_DEPENDENCY}}
+
     // On-device computer vision APIs exposed by CraftBridge
     implementation("com.google.mlkit:barcode-scanning:17.3.0")
     implementation("com.google.mlkit:image-labeling:17.0.9")