craft-native 0.0.490 → 0.0.492

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

@@ -294,6 +294,8 @@ internal class CraftNativeRoutes(config: JSONObject) {
 /** One process-wide boundary for committed storage reads and mutations. */
 internal object CraftNativeStorage {
     val lock = Any()
+    /** The secure store's writes, one at a time across every host in the process: a rollback restores what it read. */
+    val secureLock = Any()
     fun jsonEqual(left: Any?, right: Any?): Boolean {
         if (left == null || left === JSONObject.NULL) return right == null || right === JSONObject.NULL
         if (left is Boolean || right is Boolean) return left is Boolean && right is Boolean && left == right
@@ -365,6 +367,30 @@ internal class CraftNativeStores private constructor(
         cache
     }
 
+    /**
+     * Checkpoints that have been asked for and are not on disk yet, the
+     * newest per name; a null is one being deleted. A read finds these first,
+     * as UIKit's `CraftSnapshots.read` finds its `pending`, so a screen opened
+     * right after a checkpoint is seeded with it, and one opened right after
+     * a sign-out is not seeded with the account that just left (#507). The
+     * number is which request put the entry there. Guarded by itself.
+     */
+    private val pendingSnapshots = HashMap<String, Pair<Long, String?>>()
+    private var snapshotRevision = 0L
+
+    /** What a read gives now: the snapshots on disk with those on their way laid over them. */
+    private fun currentSnapshots(): Map<String, String> {
+        synchronized(pendingSnapshots) {
+            if (pendingSnapshots.isEmpty()) return snapshotCache
+            val current = HashMap(snapshotCache)
+            for ((name, waiting) in pendingSnapshots) {
+                val json = waiting.second
+                if (json == null) current.remove(name) else current[name] = json
+            }
+            return current
+        }
+    }
+
     /**
      * Everything an isolate needs before its first line runs, as JSON text:
      * `{ storage: { key: json }, secure: { key: value }, snapshots: { name: json } }`.
@@ -388,7 +414,7 @@ internal class CraftNativeStores private constructor(
         out.append(',')
         section("secure", runCatching { secure?.all?.mapNotNull { (key, value) -> (value as? String)?.let { key to it } }?.toMap() }.getOrNull() ?: emptyMap())
         out.append(',')
-        section("snapshots", snapshotCache)
+        section("snapshots", currentSnapshots())
         out.append('}')
         return out.toString()
     }
@@ -396,7 +422,12 @@ internal class CraftNativeStores private constructor(
     /** The same, parsed (tests and small hosts). */
     fun preload(): JSONObject = JSONObject(preloadText())
 
-    fun snapshot(name: String): String? = snapshotCache[name]
+    fun snapshot(name: String): String? {
+        synchronized(pendingSnapshots) {
+            val waiting = pendingSnapshots[name]
+            return if (waiting != null) waiting.second else snapshotCache[name]
+        }
+    }
 
     /**
      * One secure value, read directly rather than through the preload.
@@ -425,44 +456,79 @@ internal class CraftNativeStores private constructor(
             main.post { done(false) }
             return
         }
-        writer.execute {
-            val file = snapshotFile(name)
-            val previous = snapshotCache[name]
-            val ok = runCatching {
-                if (json == null) {
-                    !file.exists() || file.delete()
-                } else {
-                    snapshotFiles.set(file, json)
-                    true
+        // UIKit refuses a payload that is not JSON before it touches the
+        // disk, and a checkpoint kept on one host and refused on the other is
+        // the divergence this contract exists to prevent (#396).
+        if (json != null && !craftNativeIsJsonText(json)) {
+            main.post { done(false) }
+            return
+        }
+        // Admitting the write and queueing it are one step, as on UIKit:
+        // apart, an older request could reach the disk after a newer one
+        // while readers were already being given the newer value.
+        synchronized(pendingSnapshots) {
+            snapshotRevision += 1
+            val mine = snapshotRevision
+            pendingSnapshots[name] = mine to json
+            writer.execute {
+                val file = snapshotFile(name)
+                val ok = runCatching {
+                    if (json == null) {
+                        !file.exists() || file.delete()
+                    } else {
+                        snapshotFiles.set(file, json)
+                        true
+                    }
+                }.getOrDefault(false)
+                if (ok) {
+                    if (json == null) snapshotCache.remove(name) else snapshotCache[name] = json
+                }
+                val current = synchronized(pendingSnapshots) {
+                    if (pendingSnapshots[name]?.first == mine) pendingSnapshots.remove(name)
+                    snapshot(name)
+                }
+                main.post {
+                    // Isolates optimistically display their write. Each is
+                    // told what a read gives now: the checkpoint when it was
+                    // kept, the confirmed value when it was not, and a newer
+                    // one still on its way in either case, so an older write
+                    // settling cannot set a screen back behind it.
+                    changed("snapshots", name, current, null)
+                    done(ok)
                 }
-            }.getOrDefault(false)
-            if (ok) {
-                if (json == null) snapshotCache.remove(name) else snapshotCache[name] = json
-            }
-            main.post {
-                // Isolates optimistically display their write. Restore the
-                // confirmed value before rejecting an unsuccessful checkpoint.
-                changed("snapshots", name, if (ok) json else previous, null)
-                done(ok)
             }
         }
     }
 
     /** `craft.snapshots.clear(keep)`: every snapshot but those named, as a sign-out does. */
     fun clearSnapshots(keep: Set<String>, done: (Boolean) -> Unit) {
-        writer.execute {
-            val removed = mutableListOf<String>()
-            var ok = true
-            snapshotsDir.listFiles()?.forEach { file ->
-                if (!file.name.endsWith(".json")) return@forEach
-                val name = snapshotName(file) ?: return@forEach
-                if (name in keep) return@forEach
-                if (file.delete()) removed.add(name) else ok = false
-            }
-            removed.forEach(snapshotCache::remove)
-            main.post {
-                removed.forEach { changed("snapshots", it, null, null) }
-                done(ok)
+        synchronized(pendingSnapshots) {
+            // Gone for a reader from this moment, as on UIKit, where a clear
+            // is a delete of every name.
+            snapshotRevision += 1
+            val mine = snapshotRevision
+            val doomed = currentSnapshots().keys.filter { it !in keep }
+            doomed.forEach { pendingSnapshots[it] = mine to null }
+            writer.execute {
+                val removed = mutableListOf<String>()
+                var ok = true
+                snapshotsDir.listFiles()?.forEach { file ->
+                    if (!file.name.endsWith(".json")) return@forEach
+                    val name = snapshotName(file) ?: return@forEach
+                    if (name in keep) return@forEach
+                    if (file.delete()) removed.add(name) else ok = false
+                }
+                removed.forEach(snapshotCache::remove)
+                val current = synchronized(pendingSnapshots) {
+                    doomed.forEach { if (pendingSnapshots[it]?.first == mine) pendingSnapshots.remove(it) }
+                    // One that could not be deleted is still there, and one
+                    // written since the clear was asked for is on its way.
+                    (removed + doomed).distinct().associateWith { snapshot(it) }
+                }
+                main.post {
+                    current.forEach { (name, json) -> changed("snapshots", name, json, null) }
+                    done(ok)
+                }
             }
         }
     }
@@ -905,6 +971,7 @@ internal class CraftNativeChrome(
     private val fonts: CraftNativeChromeFonts = CraftNativeChromeFonts(),
 ) : LinearLayout(context) {
     val content = FrameLayout(context)
+    private val body = FrameLayout(context)
     private val bar = LinearLayout(context)
     private val backButton = ImageView(context)
     private val leadingButtons = LinearLayout(context)
@@ -915,6 +982,7 @@ internal class CraftNativeChrome(
     private val tabRow = LinearLayout(context)
     private val accessory = FrameLayout(context)
     private val companionRow = LinearLayout(context)
+    private val accessoryGroup = LinearLayout(context)
     private val companionViews = mutableListOf<Pair<FrameLayout, JSONObject>>()
     private var renderedCompanionSpecs = ""
     private val accessoryIcon = ImageView(context)
@@ -995,7 +1063,8 @@ internal class CraftNativeChrome(
         largeTitleView.ellipsize = TextUtils.TruncateAt.END
         largeTitleView.setPadding(dp(16), 0, dp(16), dp(8))
         addView(largeTitleView, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT))
-        addView(content, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 0, 1f))
+        body.addView(content, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+        addView(body, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 0, 1f))
         tabBar.orientation = HORIZONTAL
         tabBar.gravity = Gravity.CENTER
         tabs.forEachIndexed { index, tab ->
@@ -1045,7 +1114,9 @@ internal class CraftNativeChrome(
         tabRow.addView(tabBar, LayoutParams(0, dp(64), 1f))
         companionRow.orientation = HORIZONTAL
         companionRow.gravity = Gravity.CENTER_VERTICAL
-        tabRow.addView(companionRow, LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, dp(64)))
+        accessoryGroup.orientation = HORIZONTAL
+        accessoryGroup.gravity = Gravity.CENTER
+        accessoryGroup.addView(companionRow, LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT))
         accessory.addView(accessoryIcon, FrameLayout.LayoutParams(dp(26), dp(26), Gravity.CENTER))
         accessoryBadge.textSize = 10f
         accessoryBadge.gravity = Gravity.CENTER
@@ -1055,7 +1126,8 @@ internal class CraftNativeChrome(
         accessory.addView(accessoryBadge, FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, dp(18), Gravity.TOP or Gravity.END))
         accessory.setOnClickListener { accessorySpec?.optString("path")?.let { onAccessory?.invoke(it) } }
         accessory.visibility = View.GONE
-        tabRow.addView(accessory, LayoutParams(dp(64), dp(64)).apply { marginStart = dp(8) })
+        accessoryGroup.addView(accessory, LayoutParams(dp(64), dp(64)).apply { marginStart = dp(8) })
+        tabRow.addView(accessoryGroup, LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT))
         addView(tabRow, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, dp(72)))
         tabRow.visibility = if (tabs.isEmpty()) View.GONE else View.VISIBLE
         refreshColors()
@@ -1067,7 +1139,8 @@ internal class CraftNativeChrome(
                 val overHorizontalScroll = onTabSwipeShouldDefer?.invoke(event.x, event.y) == true
                 horizontalScrollDeferred = overHorizontalScroll
                 if (overHorizontalScroll) parent?.requestDisallowInterceptTouchEvent(true)
-                swipeTracking = tabs.size > 1 && tabSwipeEnabled && !overHorizontalScroll && tabRow.visibility == View.VISIBLE && event.y < tabRow.top
+                val overActions = android.graphics.Rect().let { accessoryGroup.getGlobalVisibleRect(it) && it.contains(event.rawX.toInt(), event.rawY.toInt()) }
+                swipeTracking = tabs.size > 1 && tabSwipeEnabled && !overActions && !overHorizontalScroll && tabRow.visibility == View.VISIBLE && event.y < tabRow.top
                 swipeIntercepted = false
                 swipeDownX = event.x
                 swipeDownY = event.y
@@ -1211,10 +1284,45 @@ internal class CraftNativeChrome(
             accessoryBadge.text = it.optString("badge").takeUnless { badge -> badge == "null" }.orEmpty().take(8)
             accessoryBadge.visibility = if (accessoryBadge.text.isEmpty()) View.GONE else View.VISIBLE
         }
+        layoutAccessoryGroup(tabBarHidden)
         tabSwipeEnabled = options.optBoolean("tabSwipeEnabled", true)
         refreshColors()
     }
 
+    /** The same actions and popup anchors survive switching between grouped and separate chrome. */
+    private fun layoutAccessoryGroup(hidden: Boolean) {
+        val layout = accessorySpec?.optString("layout").orEmpty()
+        val grouped = layout == "vertical" || layout == "horizontal"
+        val parent = if (grouped) body else tabRow
+        if (accessoryGroup.parent !== parent) {
+            (accessoryGroup.parent as? ViewGroup)?.removeView(accessoryGroup)
+            if (grouped) body.addView(accessoryGroup, FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.BOTTOM or Gravity.END).apply {
+                marginEnd = dp(20)
+                bottomMargin = dp(8)
+            }) else tabRow.addView(accessoryGroup, LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT))
+        }
+        val vertical = layout == "vertical"
+        accessoryGroup.orientation = if (vertical) VERTICAL else HORIZONTAL
+        companionRow.orientation = accessoryGroup.orientation
+        accessoryGroup.setPadding(if (grouped) dp(2) else 0, if (grouped) dp(2) else 0, if (grouped) dp(2) else 0, if (grouped) dp(2) else 0)
+        accessoryGroup.visibility = if (accessorySpec == null || hidden || tabs.isEmpty()) View.GONE else View.VISIBLE
+        accessoryGroup.tag = if (grouped) "craft-tab-accessory-group" else null
+        accessoryGroup.elevation = if (grouped) dp(6).toFloat() else 0f
+        accessoryGroup.clipToOutline = grouped
+        companionViews.forEach { (action, _) ->
+            action.layoutParams = LayoutParams(dp(48), dp(48)).apply { marginStart = if (grouped) 0 else dp(8) }
+        }
+        accessory.layoutParams = LayoutParams(dp(if (grouped) 48 else 64), dp(if (grouped) 48 else 64)).apply { marginStart = if (grouped) 0 else dp(8) }
+        val divider = GradientDrawable().apply { setColor(Color.argb(48, 128, 128, 128)); setSize(dp(1), dp(1)) }
+        for (row in listOf(accessoryGroup, companionRow)) {
+            row.showDividers = if (grouped) SHOW_DIVIDER_MIDDLE else SHOW_DIVIDER_NONE
+            row.dividerDrawable = if (grouped) divider.constantState?.newDrawable() else null
+            row.dividerPadding = dp(12)
+        }
+        // An empty companion row must not leave a divider above a single icon.
+        companionRow.visibility = if (companionViews.isEmpty()) View.GONE else View.VISIBLE
+    }
+
     fun selectTab(index: Int) {
         selectedTab = index
         refreshColors()
@@ -1309,16 +1417,18 @@ internal class CraftNativeChrome(
         largeTitleView.setTextColor(navigationTitleColor ?: text)
         backButton.imageTintList = ColorStateList.valueOf(accent)
         val surface = if (dark) Color.parseColor("#1C1C1E") else Color.parseColor("#F9F9F9")
+        val grouped = accessoryGroup.parent === body
+        accessoryGroup.background = if (grouped) GradientDrawable().apply { setColor(surface); cornerRadius = dp(26).toFloat() } else null
         tabBar.background = GradientDrawable().apply { setColor(surface); cornerRadius = dp(32).toFloat() }
         val primarySelected = accessorySpec?.let { isAccessorySelected(it) } == true
         accessory.isSelected = primarySelected
         companionViews.forEach { (action, item) ->
             val selected = isAccessorySelected(item)
             action.isSelected = selected
-            action.background = GradientDrawable().apply { setColor(if (selected) Color.argb(36, Color.red(accent), Color.green(accent), Color.blue(accent)) else surface); cornerRadius = dp(32).toFloat() }
+            action.background = if (grouped) rippleBackground() else GradientDrawable().apply { setColor(if (selected) Color.argb(36, Color.red(accent), Color.green(accent), Color.blue(accent)) else surface); cornerRadius = dp(32).toFloat() }
             (action.getChildAt(0) as ImageView).setImageDrawable(CraftNativeIcons.drawable(context, null, item.optString("symbol"), if (selected) accent else text))
         }
-        accessory.background = GradientDrawable().apply { setColor(if (primarySelected) Color.argb(36, Color.red(accent), Color.green(accent), Color.blue(accent)) else surface); cornerRadius = dp(32).toFloat() }
+        accessory.background = if (grouped) rippleBackground() else GradientDrawable().apply { setColor(if (primarySelected) Color.argb(36, Color.red(accent), Color.green(accent), Color.blue(accent)) else surface); cornerRadius = dp(32).toFloat() }
         accessorySpec?.let { accessoryIcon.setImageDrawable(CraftNativeIcons.drawable(context, null, it.optString("symbol"), if (primarySelected) accent else text)) }
         tabViews.forEachIndexed { index, (icon, label) ->
             tabBar.getChildAt(index).isSelected = index == selectedTab && !accessorySelected
@@ -2140,3 +2250,182 @@ internal object CraftNativeIcons {
         override fun getOpacity(): Int = android.graphics.PixelFormat.TRANSLUCENT
     }
 }
+
+/**
+ * Whether `text` is JSON that UIKit's own writer would also accept.
+ *
+ * UIKit refuses a snapshot whose payload is not JSON, before it touches the
+ * disk: `JSONSerialization.jsonObject(with:options: [.fragmentsAllowed])`
+ * returning nil fails the write. Android had no such check, so a payload iOS
+ * rejected was written here and the two hosts disagreed about whether a
+ * checkpoint had been kept (#396).
+ *
+ * The grammar is Foundation's, measured rather than assumed, because it is
+ * not RFC 8259 and a strict parser would have diverged in the other
+ * direction:
+ *
+ *  - top-level fragments are allowed (`42`, `"text"`, `null`);
+ *  - **one** trailing comma is allowed in an object or array — `{"a":1,}`
+ *    and `[1,]` are accepted, `{"a":1,,}` and `[,1]` are not;
+ *  - a lone surrogate escape is rejected, a matched pair accepted;
+ *  - a raw control character inside a string is rejected, its escape is not;
+ *  - `00`, `+1`, `.5`, `1.`, `1.0e`, `NaN` and `Infinity` are all rejected;
+ *  - trailing content after the value is rejected, surrounding space is not.
+ *
+ * `org.json` cannot stand in for this: `JSONTokener` accepts unquoted keys,
+ * single quotes and more, so it would admit payloads UIKit refuses.
+ * `android.util.JsonReader` in strict mode refuses top-level fragments that
+ * UIKit accepts. Both are wrong in a direction that matters, which is why
+ * this is scanned here and pinned against Foundation itself by
+ * `packages/android/src/snapshot-json-contract.test.ts`.
+ */
+private class CraftNativeJsonScanner(private val text: String) {
+    private var at = 0
+
+    fun validate(): Boolean {
+        skipWhitespace()
+        if (!value()) return false
+        skipWhitespace()
+        return at == text.length
+    }
+
+    private fun skipWhitespace() {
+        while (at < text.length && (text[at] == ' ' || text[at] == '\t' || text[at] == '\n' || text[at] == '\r')) at++
+    }
+
+    private fun value(): Boolean {
+        if (at >= text.length) return false
+        return when (text[at]) {
+            '{' -> obj()
+            '[' -> arr()
+            '"' -> string()
+            't' -> literal("true")
+            'f' -> literal("false")
+            'n' -> literal("null")
+            else -> number()
+        }
+    }
+
+    private fun literal(word: String): Boolean {
+        if (!text.startsWith(word, at)) return false
+        at += word.length
+        return true
+    }
+
+    /** After a member, consume the separator. Returns null when malformed. */
+    private fun afterMember(closing: Char): Boolean? {
+        skipWhitespace()
+        if (at >= text.length) return null
+        return when (text[at]) {
+            ',' -> {
+                at++
+                skipWhitespace()
+                // Foundation allows exactly one trailing comma before the
+                // close. A second comma, or a close that never comes, is not.
+                if (at < text.length && text[at] == closing) { at++; true } else false
+            }
+            closing -> { at++; true }
+            else -> null
+        }
+    }
+
+    private fun obj(): Boolean {
+        at++
+        skipWhitespace()
+        if (at < text.length && text[at] == '}') { at++; return true }
+        while (true) {
+            skipWhitespace()
+            if (at >= text.length || text[at] != '"') return false
+            if (!string()) return false
+            skipWhitespace()
+            if (at >= text.length || text[at] != ':') return false
+            at++
+            skipWhitespace()
+            if (!value()) return false
+            val done = afterMember('}') ?: return false
+            if (done) return true
+        }
+    }
+
+    private fun arr(): Boolean {
+        at++
+        skipWhitespace()
+        if (at < text.length && text[at] == ']') { at++; return true }
+        while (true) {
+            skipWhitespace()
+            if (!value()) return false
+            val done = afterMember(']') ?: return false
+            if (done) return true
+        }
+    }
+
+    private fun string(): Boolean {
+        at++
+        var pendingHighSurrogate = false
+        while (at < text.length) {
+            val character = text[at]
+            when {
+                character == '"' -> { at++; return !pendingHighSurrogate }
+                character == '\\' -> {
+                    at++
+                    if (at >= text.length) return false
+                    val escape = text[at]
+                    if (escape == 'u') {
+                        if (at + 4 >= text.length) return false
+                        var code = 0
+                        for (offset in 1..4) {
+                            val digit = Character.digit(text[at + offset], 16)
+                            if (digit < 0) return false
+                            code = code * 16 + digit
+                        }
+                        at += 5
+                        val high = code in 0xD800..0xDBFF
+                        val low = code in 0xDC00..0xDFFF
+                        // A low surrogate is only legal directly after a high
+                        // one, and a high one must be followed by a low one.
+                        if (pendingHighSurrogate != low) return false
+                        pendingHighSurrogate = high
+                        continue
+                    }
+                    if (pendingHighSurrogate) return false
+                    if (escape !in listOf('"', '\\', '/', 'b', 'f', 'n', 'r', 't')) return false
+                    at++
+                }
+                character.code < 0x20 -> return false
+                else -> {
+                    if (pendingHighSurrogate) return false
+                    at++
+                }
+            }
+        }
+        return false
+    }
+
+    private fun number(): Boolean {
+        val start = at
+        if (at < text.length && text[at] == '-') at++
+        val integerStart = at
+        while (at < text.length && text[at] in '0'..'9') at++
+        if (at == integerStart) return false
+        // A leading zero may not be followed by another digit.
+        if (text[integerStart] == '0' && at - integerStart > 1) return false
+        if (at < text.length && text[at] == '.') {
+            at++
+            val fractionStart = at
+            while (at < text.length && text[at] in '0'..'9') at++
+            if (at == fractionStart) return false
+        }
+        if (at < text.length && (text[at] == 'e' || text[at] == 'E')) {
+            at++
+            if (at < text.length && (text[at] == '+' || text[at] == '-')) at++
+            val exponentStart = at
+            while (at < text.length && text[at] in '0'..'9') at++
+            if (at == exponentStart) return false
+        }
+        return at > start
+    }
+}
+
+/** Whether a snapshot payload is JSON both hosts accept. */
+private fun craftNativeIsJsonText(text: String): Boolean = CraftNativeJsonScanner(text).validate()
+

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

@@ -26,7 +26,17 @@ internal class CraftNativeSounds(
 ) {
     private data class Sound(
         val player: MediaPlayer,
+        /** Where the player is right now, part-way through a fade included. */
         var volume: Float,
+        /**
+         * The volume that was asked for. A fade moves `volume` toward or away
+         * from this and must not overwrite it: with one number for both, a
+         * pause during a fade left the sound at whatever fraction the fade had
+         * reached, and `resume` played it there for the rest of its life —
+         * `play({ volume: 1, fadeIn: 2000 })` paused at 500 ms came back at
+         * 0.25. UIKit keeps the two apart and resumes at the asked-for volume.
+         */
+        var asked: Float,
         var paused: Boolean = false,
         var interrupted: Boolean = false,
         var prepared: Boolean = false,
@@ -66,7 +76,7 @@ internal class CraftNativeSounds(
         // Its player, pending load and cancellation handle still belong to it.
         stop(id, 0.0)
         val player = MediaPlayer()
-        val sound = Sound(player, if (fadeIn > 0) 0f else volume, pending = done)
+        val sound = Sound(player, if (fadeIn > 0) 0f else volume, asked = volume, pending = done)
         sounds[id] = sound
         fun settle(result: CraftNativeCapabilityResult) {
             val answer = sound.pending ?: return
@@ -144,7 +154,19 @@ internal class CraftNativeSounds(
     fun resume(id: String): Boolean {
         val sound = sounds[id] ?: return false
         if (focusSuspended) return false
-        if (sound.prepared) runCatching { sound.player.start() }.onFailure { return false }
+        // UIKit answers false for a sound that is not paused, and a caller
+        // reading the answer to learn whether anything was resumed should not
+        // get a different one here.
+        if (!sound.paused) return false
+        if (sound.prepared) {
+            // A pause cancels a fade where it stands. Land on the volume that
+            // was asked for rather than on the fraction the fade had reached.
+            // Left alone until the player is prepared: a fade-in that has not
+            // begun yet still starts from silence when it does.
+            sound.volume = sound.asked
+            applyVolume(sound)
+            runCatching { sound.player.start() }.onFailure { return false }
+        }
         sound.paused = false
         sound.interrupted = false
         return true
@@ -154,6 +176,7 @@ internal class CraftNativeSounds(
         val sound = sounds[id] ?: return false
         if (!volume.isFinite() || !fade.isFinite() || fade < 0) return false
         val target = volume.coerceIn(0.0, 1.0).toFloat()
+        sound.asked = target
         sound.fade?.let(main::removeCallbacks)
         sound.fade = null
         if (fade > 0 && !sound.paused) ramp(sound, target, fade / 1000.0)

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

@@ -149,6 +149,27 @@ private fun craftNativeBoolean(value: Any?, fallback: Boolean = false): Boolean
 
 private fun craftNativeInt(value: Any?, fallback: Int): Int = (value as? Number)?.toInt() ?: fallback
 
+/**
+ * Where a field's text and hint begin, vertically.
+ *
+ * The platform's `Widget.EditText` carries `gravity = center_vertical`, and
+ * nothing between it and this app overrides it: `Theme.CraftApp` inherits
+ * `Theme.Material3.DayNight.NoActionBar`, no Material3 theme binds
+ * `android:editTextStyle`, and AppCompat binds it to
+ * `Widget.AppCompat.EditText`, whose chain reaches `android:Widget.EditText`
+ * without touching gravity. A single-line field is never taller than its
+ * text, so the centring cannot show; a field given a `minHeight` drew its
+ * first line — and its hint — halfway down the box, where iOS and the web
+ * both start at the top (#502).
+ *
+ * Only the vertical bits are replaced. The horizontal ones are left exactly
+ * as they were, because `textAlign` resolves through `textAlignment`, whose
+ * default of `TEXT_ALIGNMENT_INHERIT` can still fall back to this gravity.
+ */
+private fun craftNativeVerticalGravity(current: Int, multiline: Boolean): Int =
+    (current and Gravity.VERTICAL_GRAVITY_MASK.inv()) or (if (multiline) Gravity.TOP else Gravity.CENTER_VERTICAL)
+
+
 /**
  * A scroll event's geometry in density-independent units.
  *
@@ -6689,6 +6710,8 @@ class MainActivity : AppCompatActivity() {
                 if (isSingleLine == multiline) isSingleLine = !multiline
                 val wantedLines = if (multiline) craftNativeInt(props.opt("numberOfLines"), Int.MAX_VALUE).coerceAtLeast(1) else 1
                 if (maxLines != wantedLines) maxLines = wantedLines
+                val wantedGravity = craftNativeVerticalGravity(gravity, multiline)
+                if (gravity != wantedGravity) gravity = wantedGravity
                 isEnabled = craftNativeBoolean(props.opt("editable"), true)
                 configureTextStyle(this, style)
                 // The style's padding is where the text starts, as on iOS and

package/dist/cli.js

@@ -1025,6 +1025,9 @@ async function detachDiskImage(mount, options = {}) {
     await wait(attempt * 2000);
   }
 }
+function attachedDevice(attachOutput) {
+  return attachOutput.match(/^(\/dev\/disk\d+)(?=\s)/m)?.[1] ?? null;
+}
 async function createDiskImage(opts) {
   if (!/^[^/:\n]{1,27}$/.test(opts.volumeName))
     return { success: false, error: `Invalid DMG volume name "${opts.volumeName}"; must be 1..27 chars without /, :, or newline` };
@@ -1068,7 +1071,7 @@ async function createDiskImage(opts) {
     phase = "layout";
     writeInstallerLayout(mount, opts.volumeName, bundleName);
     phase = "detach";
-    const detached = await detachDiskImage(mount);
+    const detached = await detachDiskImage(attachedDevice(attachment) ?? mount);
     if (!detached.success) {
       detachAttempts = detached.attempts;
       throw new Error(detached.error);
@@ -1083,7 +1086,7 @@ async function createDiskImage(opts) {
 Disk image lifecycle: ${JSON.stringify({ phase, image: writable, mount, attachment, detachAttempts })}` };
   } finally {
     if (mounted)
-      await runTool("hdiutil", ["detach", mount, "-force"]);
+      await runTool("hdiutil", ["detach", attachedDevice(attachment) ?? mount, "-force"]);
     removeTempDir(scratch);
   }
 }
@@ -3243,7 +3246,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.490";
+var version = "0.0.492";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -376,7 +376,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.490";
+var version = "0.0.492";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;
@@ -1393,6 +1393,9 @@ async function detachDiskImage(mount, options = {}) {
     await wait(attempt * 2000);
   }
 }
+function attachedDevice(attachOutput) {
+  return attachOutput.match(/^(\/dev\/disk\d+)(?=\s)/m)?.[1] ?? null;
+}
 async function createDiskImage(opts) {
   if (!/^[^/:\n]{1,27}$/.test(opts.volumeName))
     return { success: false, error: `Invalid DMG volume name "${opts.volumeName}"; must be 1..27 chars without /, :, or newline` };
@@ -1436,7 +1439,7 @@ async function createDiskImage(opts) {
     phase = "layout";
     writeInstallerLayout(mount, opts.volumeName, bundleName);
     phase = "detach";
-    const detached = await detachDiskImage(mount);
+    const detached = await detachDiskImage(attachedDevice(attachment) ?? mount);
     if (!detached.success) {
       detachAttempts = detached.attempts;
       throw new Error(detached.error);
@@ -1451,7 +1454,7 @@ async function createDiskImage(opts) {
 Disk image lifecycle: ${JSON.stringify({ phase, image: writable, mount, attachment, detachAttempts })}` };
   } finally {
     if (mounted)
-      await runTool("hdiutil", ["detach", mount, "-force"]);
+      await runTool("hdiutil", ["detach", attachedDevice(attachment) ?? mount, "-force"]);
     removeTempDir(scratch);
   }
 }