craft-native 0.0.358 → 0.0.359

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

@@ -0,0 +1,260 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import org.json.JSONObject
+import java.io.File
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Screen-owned `craft.audio` playback for native Android routes.
+ *
+ * Each id owns one MediaPlayer, so effects can overlap and a replacement
+ * invalidates the previous load. The player is released on every terminal
+ * path, including cancellation, decode failure and screen teardown.
+ */
+internal class CraftNativeSounds(private val context: Context) {
+    private data class Sound(
+        val player: MediaPlayer,
+        var volume: Float,
+        var paused: Boolean = false,
+        var interrupted: Boolean = false,
+        var prepared: Boolean = false,
+        var fade: Runnable? = null,
+        var pending: ((CraftNativeCapabilityResult) -> Unit)? = null,
+    )
+
+    private val main = Handler(Looper.getMainLooper())
+    private val sounds = mutableMapOf<String, Sound>()
+    private val audioManager by lazy { context.getSystemService(Context.AUDIO_SERVICE) as AudioManager }
+    private val focusRequest by lazy {
+        AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+            .setAudioAttributes(AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_GAME)
+                .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                .build())
+            .setAcceptsDelayedFocusGain(false)
+            .setOnAudioFocusChangeListener({ change -> onAudioFocusChange(change) }, main)
+            .build()
+    }
+
+    /** `{ id, event: "ended" | "error", message? }` for the screen bridge. */
+    var emit: ((JSONObject) -> Unit)? = null
+
+    fun play(id: String, address: String, options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (id.isBlank()) return done(failure("INVALID_ARGUMENT", "audio.play needs an id"))
+        val uri = source(address)
+            ?: return done(failure("INVALID_ARGUMENT", "audio.play needs an absolute http, https, file or content URL"))
+        stop(id, 0.0)
+
+        val requestedVolume = options.optDouble("volume", 1.0)
+        val volume = requestedVolume.takeIf { it.isFinite() }?.coerceIn(0.0, 1.0)?.toFloat()
+            ?: return done(failure("INVALID_ARGUMENT", "audio.play volume must be a finite number between 0 and 1"))
+        val fadeIn = options.optDouble("fadeIn", 0.0)
+        if (!fadeIn.isFinite() || fadeIn < 0) return done(failure("INVALID_ARGUMENT", "audio.play fadeIn must be a non-negative finite number"))
+        val player = MediaPlayer()
+        val sound = Sound(player, if (fadeIn > 0) 0f else volume, pending = done)
+        sounds[id] = sound
+        fun settle(result: CraftNativeCapabilityResult) {
+            val answer = sound.pending ?: return
+            sound.pending = null
+            answer(result)
+        }
+        fun failed(message: String) {
+            if (sounds[id] !== sound) return
+            settle(failure("AUDIO_ERROR", message))
+            remove(id)
+            emit?.invoke(JSONObject().put("id", id).put("event", "error").put("message", message))
+        }
+
+        if (audioManager.requestAudioFocus(focusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+            settle(failure("AUDIO_FOCUS_DENIED", "Audio focus was denied by the operating system"))
+            remove(id)
+            emit?.invoke(JSONObject().put("id", id).put("event", "error").put("message", "Audio focus was denied by the operating system"))
+            return
+        }
+
+        runCatching {
+            player.setAudioAttributes(AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_GAME)
+                .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                .build())
+            player.isLooping = options.optBoolean("loop", false)
+            player.setVolume(if (fadeIn > 0) 0f else volume, if (fadeIn > 0) 0f else volume)
+            player.setOnPreparedListener {
+                if (sounds[id] !== sound) return@setOnPreparedListener
+                sound.prepared = true
+                if (!sound.paused && !sound.interrupted) player.start()
+                settle(CraftNativeCapabilityResult(data = true))
+                if (fadeIn > 0) {
+                    if (!sound.paused) ramp(sound, volume, fadeIn / 1000.0)
+                    else { sound.volume = volume; player.setVolume(volume, volume) }
+                }
+            }
+            player.setOnCompletionListener {
+                if (sounds[id] !== sound) return@setOnCompletionListener
+                remove(id)
+                emit?.invoke(JSONObject().put("id", id).put("event", "ended"))
+            }
+            player.setOnErrorListener { _, what, extra ->
+                failed("The sound could not be played ($what, $extra)")
+                true
+            }
+            player.setDataSource(context, uri)
+            player.prepareAsync()
+        }.onFailure { error ->
+            if (sounds[id] === sound) {
+                settle(failure("AUDIO_ERROR", error.message ?: "The sound could not be loaded"))
+                remove(id)
+                emit?.invoke(JSONObject().put("id", id).put("event", "error").put("message", error.message ?: "The sound could not be loaded"))
+            }
+        }
+    }
+
+    /** Cancellation belongs to this playback, not a later reuse of its id. */
+    fun cancellation(id: String): () -> Unit {
+        val sound = sounds[id]
+        return { if (sound != null && sounds[id] === sound) remove(id) }
+    }
+
+    fun pause(id: String): Boolean {
+        val sound = sounds[id] ?: return false
+        sound.fade?.let(main::removeCallbacks)
+        sound.fade = null
+        runCatching { if (sound.player.isPlaying) sound.player.pause() }
+        sound.paused = true
+        sound.interrupted = false
+        return true
+    }
+
+    fun resume(id: String): Boolean {
+        val sound = sounds[id] ?: return false
+        if (sound.prepared) runCatching { sound.player.start() }.onFailure { return false }
+        sound.paused = false
+        sound.interrupted = false
+        return true
+    }
+
+    fun setVolume(id: String, volume: Double, fade: Double): Boolean {
+        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.fade?.let(main::removeCallbacks)
+        sound.fade = null
+        if (fade > 0 && !sound.paused) ramp(sound, target, fade / 1000.0)
+        else {
+            sound.volume = target
+            sound.player.setVolume(target, target)
+        }
+        return true
+    }
+
+    fun stop(id: String, fadeOut: Double): Boolean {
+        val sound = sounds[id] ?: return false
+        if (!fadeOut.isFinite() || fadeOut < 0) return false
+        if (fadeOut > 0 && !sound.paused) {
+            ramp(sound, 0f, fadeOut / 1000.0) { if (sounds[id] === sound) remove(id) }
+        } else remove(id)
+        return true
+    }
+
+    fun stopAll(fadeOut: Double): Boolean {
+        if (!fadeOut.isFinite() || fadeOut < 0) return false
+        sounds.keys.toList().forEach { stop(it, fadeOut) }
+        return true
+    }
+
+    fun close() {
+        sounds.keys.toList().forEach(::remove)
+        emit = null
+    }
+
+    private fun source(address: String): Uri? {
+        val text = address.trim()
+        if (text.isBlank()) return null
+        CraftNativeMedia.local(context, text)?.let { file: File -> return Uri.fromFile(file) }
+        val uri = runCatching { Uri.parse(text) }.getOrNull() ?: return null
+        return uri.takeIf { it.scheme?.lowercase() in setOf("http", "https", "file", "content") && !it.toString().contains(" ") }
+    }
+
+    private fun remove(id: String) {
+        val sound = sounds.remove(id) ?: return
+        sound.fade?.let(main::removeCallbacks)
+        sound.fade = null
+        runCatching {
+            sound.player.setOnPreparedListener(null)
+            sound.player.setOnCompletionListener(null)
+            sound.player.setOnErrorListener(null)
+            sound.player.stop()
+        }
+        sound.player.release()
+        if (sounds.isEmpty()) audioManager.abandonAudioFocusRequest(focusRequest)
+        val answer = sound.pending
+        sound.pending = null
+        answer?.invoke(failure("CANCELLED", "Audio playback was stopped or replaced"))
+    }
+
+    private fun onAudioFocusChange(change: Int) {
+        when (change) {
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                sounds.keys.toList().forEach { id ->
+                    if (sounds[id] != null) {
+                        remove(id)
+                        emit?.invoke(JSONObject().put("id", id).put("event", "error").put("message", "Audio focus was lost"))
+                    }
+                }
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> sounds.values.toList().forEach { sound ->
+                if (!sound.paused) {
+                    sound.interrupted = true
+                    if (sound.prepared) runCatching { sound.player.pause() }
+                }
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> sounds.values.toList().forEach { sound ->
+                runCatching { sound.player.setVolume(sound.volume * 0.2f, sound.volume * 0.2f) }
+            }
+            AudioManager.AUDIOFOCUS_GAIN -> sounds.values.toList().forEach { sound ->
+                if (sound.interrupted && !sound.paused) {
+                    sound.interrupted = false
+                    if (sound.prepared) runCatching { sound.player.start() }
+                } else {
+                    runCatching { sound.player.setVolume(sound.volume, sound.volume) }
+                }
+            }
+        }
+    }
+
+    private fun ramp(sound: Sound, target: Float, seconds: Double, done: (() -> Unit)? = null) {
+        sound.fade?.let(main::removeCallbacks)
+        val start = sound.volume
+        val began = android.os.SystemClock.uptimeMillis()
+        val duration = max(1L, (seconds * 1000).toLong())
+        val tick = object : Runnable {
+            override fun run() {
+                if (!sounds.containsValue(sound)) return
+                val progress = min(1.0, (android.os.SystemClock.uptimeMillis() - began).toDouble() / duration).toFloat()
+                val value = start + (target - start) * progress
+                sound.player.setVolume(value, value)
+                sound.volume = value
+                if (progress >= 1f) {
+                    sound.fade = null
+                    done?.invoke()
+                } else {
+                    sound.fade = this
+                    main.postDelayed(this, 33L)
+                }
+            }
+        }
+        sound.fade = tick
+        main.post(tick)
+    }
+
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+}

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

@@ -740,6 +740,115 @@ private class CraftNativeSvgView(context: Context) : View(context) {
     private data class Quadruple<T1, T2, T3, T4>(val first: T1, val second: T2, val third: T3, val fourth: T4)
 }
 
+/** One photo contract and loader shared by the Google and MapLibre hosts. */
+internal data class CraftMarkerPhoto(val address: String, val size: Float, val circle: Boolean) {
+    companion object {
+        fun from(props: JSONObject): CraftMarkerPhoto? {
+            val address = props.opt("image") as? String ?: return null
+            val uri = Uri.parse(address)
+            if (!uri.scheme.equals("https", true) || uri.host.isNullOrBlank() || uri.userInfo != null) return null
+            // Current STX releases preserve unknown HTML/binding spellings.
+            val rawSize = props.opt("imageSize") ?: props.opt("imagesize") ?: props.opt("image-size")
+            val shape = props.opt("imageShape") ?: props.opt("imageshape") ?: props.opt("image-shape")
+            val size = (rawSize as? Number)?.toDouble()?.takeIf { it.isFinite() } ?: 30.0
+            return CraftMarkerPhoto(address, size.coerceIn(16.0, 96.0).toFloat(), shape != "square")
+        }
+    }
+}
+
+internal class CraftMarkerPhotos(private val context: Context, private val changed: () -> Unit) {
+    private class Entry(val spec: CraftMarkerPhoto) {
+        var job: Future<*>? = null
+        var bitmap: Bitmap? = null
+    }
+    private val entries = mutableMapOf<String, Entry>()
+    private val executor = Executors.newFixedThreadPool(2)
+    private val main = Handler(Looper.getMainLooper())
+
+    fun bitmap(id: String, spec: CraftMarkerPhoto? = null): Bitmap? = entries[id]?.takeIf { spec == null || it.spec == spec }?.bitmap
+
+    fun reconcile(wanted: Map<String, CraftMarkerPhoto>) {
+        entries.keys.filter { entries[it]?.spec != wanted[it] }.forEach { entries.remove(it)?.job?.cancel(true) }
+        wanted.forEach { (id, spec) ->
+            if (entries.containsKey(id)) return@forEach
+            val entry = Entry(spec)
+            entries[id] = entry
+            entry.job = executor.submit {
+                val bitmap = runCatching { load(spec) }.getOrNull()
+                main.post {
+                    if (entries[id] !== entry) return@post
+                    entry.bitmap = bitmap
+                    entry.job = null
+                    if (bitmap != null) changed()
+                }
+            }
+        }
+    }
+
+    private fun load(spec: CraftMarkerPhoto): Bitmap? {
+        val kept = CraftNativeMedia.local(context, spec.address)
+        val bytes = if (kept != null) kept.inputStream().use(::readBounded) else download(spec.address)
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeByteArray(bytes, 0, bytes.size, bounds)
+        if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null
+        val size = (spec.size * context.resources.displayMetrics.density).roundToInt().coerceAtLeast(1)
+        var sample = 1
+        while (bounds.outWidth / (sample * 2) >= size && bounds.outHeight / (sample * 2) >= size) sample *= 2
+        val source = BitmapFactory.decodeByteArray(bytes, 0, bytes.size, BitmapFactory.Options().apply { inSampleSize = sample }) ?: return null
+        try {
+            val result = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
+            val scale = maxOf(size.toFloat() / source.width, size.toFloat() / source.height)
+            val matrix = Matrix().apply {
+                setScale(scale, scale)
+                postTranslate((size - source.width * scale) / 2, (size - source.height * scale) / 2)
+            }
+            val shader = android.graphics.BitmapShader(source, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP).apply { setLocalMatrix(matrix) }
+            val paint = Paint(Paint.ANTI_ALIAS_FLAG or Paint.FILTER_BITMAP_FLAG).apply { this.shader = shader }
+            val canvas = Canvas(result)
+            if (spec.circle) canvas.drawCircle(size / 2f, size / 2f, size / 2f, paint)
+            else canvas.drawRect(0f, 0f, size.toFloat(), size.toFloat(), paint)
+            return result
+        } finally { source.recycle() }
+    }
+
+    private fun readBounded(input: java.io.InputStream): ByteArray {
+        val output = java.io.ByteArrayOutputStream()
+        val buffer = ByteArray(8192)
+        while (true) {
+            if (Thread.currentThread().isInterrupted) throw java.io.InterruptedIOException()
+            val count = input.read(buffer)
+            if (count < 0) return output.toByteArray()
+            require(output.size() + count <= 8 * 1024 * 1024) { "Marker image exceeds 8 MiB" }
+            output.write(buffer, 0, count)
+        }
+    }
+
+    private fun download(address: String): ByteArray {
+        var url = URL(address)
+        repeat(6) {
+            require(url.protocol.equals("https", true) && url.userInfo == null)
+            val connection = (url.openConnection() as HttpURLConnection).apply {
+                connectTimeout = 10_000; readTimeout = 10_000
+                instanceFollowRedirects = false; useCaches = false
+            }
+            try {
+                when (connection.responseCode) {
+                    200 -> return connection.inputStream.use(::readBounded)
+                    301, 302, 303, 307, 308 -> url = URL(url, requireNotNull(connection.getHeaderField("Location")))
+                    else -> error("Marker image request failed")
+                }
+            } finally { connection.disconnect() }
+        }
+        error("Too many marker image redirects")
+    }
+
+    fun destroy() {
+        entries.values.forEach { it.job?.cancel(true) }
+        entries.clear()
+        executor.shutdownNow()
+    }
+}
+
 {{NATIVE_MAP_HOST}}
 
 /** A finite celebration owned by a View, never by the JavaScript frame loop. */
@@ -4141,6 +4250,10 @@ class MainActivity : AppCompatActivity() {
         val pendingCapabilities = mutableSetOf<String>()
         val capabilityTimeouts = mutableMapOf<String, Runnable>()
         val audio = CraftNativeAudio()
+        val sounds = CraftNativeSounds(view.context)
+        val soundRequestCancellers = mutableMapOf<String, () -> Unit>()
+        /** Snapshot writes awaiting the writer thread; close rejects them once. */
+        val pendingSyncResults = mutableSetOf<String>()
         var active = true
         var closing = false
             private set
@@ -4156,6 +4269,9 @@ class MainActivity : AppCompatActivity() {
             active = false
             closing = true
             audio.close()
+            soundRequestCancellers.values.toList().forEach { it() }
+            soundRequestCancellers.clear()
+            sounds.close()
             // Evaluation completion does not mean its outbound messages have
             // reached the host. Close only after the ordered channel barrier,
             // so onDestroy's final writes run before navigation continues.
@@ -4687,6 +4803,9 @@ class MainActivity : AppCompatActivity() {
         activeScreen.view.onLayoutChanged = {
             if (activeScreen.active) emitLayoutEvents(activeScreen)
         }
+        activeScreen.sounds.emit = { payload ->
+            if (activeScreen.active) send(activeScreen, "SOUND_EVENT", payload)
+        }
         screen = activeScreen
         CraftNativeHub.register(activeScreen.capabilityScope) { type, payload ->
             if (activeScreen.active) send(activeScreen, type, payload)
@@ -5064,6 +5183,7 @@ class MainActivity : AppCompatActivity() {
     /** The bridge's capability names: Craft's core set and this host's services. */
     private fun capabilityNames(): JSONArray = capabilities.names().apply {
         services.names().forEach { name -> put(name) }
+        put("audio")
         put("viewFocus")
         put("viewMeasure")
         put("viewScroll")
@@ -5082,13 +5202,20 @@ class MainActivity : AppCompatActivity() {
     /** A synchronous store written in an isolate (CraftNativeShell.kt's prelude). */
     private fun syncWrite(screen: Screen, payload: JSONObject) {
         val id = payload.optString("id").takeIf { it.isNotBlank() }
+        val store = payload.optString("store")
+        if (id != null) screen.pendingSyncResults.add(id)
         val reply: (Boolean) -> Unit = { ok ->
-            if (id != null && screen.active) send(screen, "SYNC_RESULT", JSONObject().put("id", id).put("ok", ok))
+            if (id != null && screen.pendingSyncResults.remove(id) && (screen.active || screen.closing)) {
+                send(screen, "SYNC_RESULT", JSONObject().put("id", id).put("ok", ok))
+            }
         }
         val key = payload.optString("key")
         val value = if (payload.isNull("value")) null else payload.optString("value")
-        when (payload.optString("store")) {
-            "storage" -> if (key.isNotBlank()) stores.setStorage(key, value, from = screen.capabilityScope)
+        when (store) {
+            "storage" -> if (key.isNotBlank()) {
+                stores.setStorage(key, value, from = screen.capabilityScope)
+                if (id != null) reply(true)
+            } else if (id != null) reply(false)
             "snapshots" -> if (payload.optBoolean("clear")) {
                 val keep = payload.optJSONArray("keep") ?: JSONArray()
                 stores.clearSnapshots((0 until keep.length()).map { keep.optString(it) }.toSet(), reply)
@@ -5329,6 +5456,7 @@ class MainActivity : AppCompatActivity() {
                     val token = "${screen.capabilityScope}/$id"
                     val pending = screen.pendingCapabilities.remove(token)
                     screen.capabilityTimeouts.remove(token)?.let(capabilityHandler::removeCallbacks)
+                    screen.soundRequestCancellers.remove(token)?.invoke()
                     if (pending) capabilities.cancel(token)
                 }
             }
@@ -7254,6 +7382,12 @@ class MainActivity : AppCompatActivity() {
         }
         imageJobs[view] = imageExecutor.submit {
             val bitmap = runCatching {
+                // Prefer the authored URL's private/offline copy. Never put
+                // these pixels in the public HTTP cache: media.clear owns them.
+                CraftNativeMedia.local(this, uri)?.let { kept ->
+                    val decoded = kept.inputStream().use(BitmapFactory::decodeStream)
+                    return@runCatching decoded.takeIf { CraftNativeMedia.local(this, uri) == kept }
+                }
                 val publicRequest = headers.isEmpty() && Uri.parse(requestUri).userInfo.isNullOrEmpty()
                 if (publicRequest) {
                     val bytes = imageCache.read(requestUri)
@@ -7508,6 +7642,7 @@ class MainActivity : AppCompatActivity() {
         val timeout = Runnable {
             if (!screen.active || !screen.pendingCapabilities.remove(token)) return@Runnable
             screen.capabilityTimeouts.remove(token)
+            screen.soundRequestCancellers.remove(token)?.invoke()
             capabilities.cancel(token)
             send(screen, "API_ERROR", JSONObject()
                 .put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION)
@@ -7525,6 +7660,14 @@ class MainActivity : AppCompatActivity() {
         val method = payload.optString("method")
         val perform: ((CraftNativeCapabilityResult) -> Unit) -> Unit = if (module == "View") {
             { completion -> performView(screen, method, args, completion) }
+        } else if (module == "Audio") {
+            { completion ->
+                val id = args.optString(0)
+                performAudio(screen, method, args, completion)
+                if (method == "play" && id.isNotBlank() && screen.pendingCapabilities.contains(token)) {
+                    screen.soundRequestCancellers[token] = screen.sounds.cancellation(id)
+                }
+            }
         } else if (services.handles(module)) {
             { completion -> services.perform(module, method, args, completion) }
         } else {
@@ -7542,6 +7685,7 @@ class MainActivity : AppCompatActivity() {
         perform { result ->
             if ((!screen.active && !screen.closing) || !screen.pendingCapabilities.remove(token)) return@perform
             screen.capabilityTimeouts.remove(token)?.let(capabilityHandler::removeCallbacks)
+            screen.soundRequestCancellers.remove(token)
             val response = JSONObject()
                 .put("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION)
                 .put("requestId", id)
@@ -7551,6 +7695,27 @@ class MainActivity : AppCompatActivity() {
         }
     }
 
+    private fun performAudio(
+        screen: Screen,
+        method: String,
+        args: JSONArray,
+        completion: (CraftNativeCapabilityResult) -> Unit,
+    ) {
+        val id = args.optString(0)
+        when (method) {
+            "play" -> {
+                val address = args.optString(1)
+                screen.sounds.play(id, address, args.optJSONObject(2) ?: JSONObject(), completion)
+            }
+            "pause" -> completion(CraftNativeCapabilityResult(data = screen.sounds.pause(id)))
+            "resume" -> completion(CraftNativeCapabilityResult(data = screen.sounds.resume(id)))
+            "setVolume" -> completion(CraftNativeCapabilityResult(data = screen.sounds.setVolume(id, args.optDouble(1, Double.NaN), args.optJSONObject(2)?.optDouble("fade", 0.0) ?: 0.0)))
+            "stop" -> completion(CraftNativeCapabilityResult(data = screen.sounds.stop(id, args.optJSONObject(1)?.optDouble("fadeOut", 0.0) ?: 0.0)))
+            "stopAll" -> completion(CraftNativeCapabilityResult(data = screen.sounds.stopAll(args.optJSONObject(0)?.optDouble("fadeOut", 0.0) ?: 0.0)))
+            else -> completion(CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported Audio method"))
+        }
+    }
+
     /** View operations are screen-owned: node ids only exist while a route is mounted. */
     private fun performView(
         screen: Screen,
@@ -8165,6 +8330,13 @@ class MainActivity : AppCompatActivity() {
 
     private fun closeScreen(screen: Screen, done: () -> Unit = {}) {
         if (!screen.active) { screen.close(done); return }
+        // A snapshot writer may still be replacing a file after the isolate
+        // starts teardown. Reject its promise before the port is closed; the
+        // worker's later completion sees the id was already consumed.
+        screen.pendingSyncResults.toList().forEach { id ->
+            send(screen, "SYNC_RESULT", JSONObject().put("id", id).put("ok", false))
+        }
+        screen.pendingSyncResults.clear()
         CraftNativeHub.unregister(screen.capabilityScope)
         screen.timers.values.forEach(capabilityHandler::removeCallbacks)
         screen.timers.clear()

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/templates/CraftNativeFiles.swift

@@ -192,10 +192,12 @@ enum CraftNativeFiles {
         do {
             let url = try newFile(named: name)
             guard let destination = CGImageDestinationCreateWithURL(url as CFURL, UTType.jpeg.identifier as CFString, 1, nil) else {
+                try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
                 return .failure(CraftNativeActionError(code: "WRITE_ERROR", message: "The photo could not be saved"))
             }
             CGImageDestinationAddImage(destination, image, [kCGImageDestinationLossyCompressionQuality: quality] as CFDictionary)
             guard CGImageDestinationFinalize(destination) else {
+                try? FileManager.default.removeItem(at: url.deletingLastPathComponent())
                 return .failure(CraftNativeActionError(code: "WRITE_ERROR", message: "The photo could not be saved"))
             }
             return .success(describe(url, type: "image/jpeg", extra: ["width": image.width, "height": image.height]))
@@ -731,11 +733,11 @@ enum CraftNativeMedia {
         lock.lock()
         defer { lock.unlock() }
         if let flight, inFlight[address]?.id != flight {
-            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))
         }
         // A background transfer from before the cache was cleared (sign-out).
         if let stillWanted, !stillWanted() {
-            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))
         }
         let staging = root.appendingPathComponent(UUID().uuidString + ".part")
         defer { try? fm.removeItem(at: staging) }
@@ -784,7 +786,7 @@ enum CraftNativeMedia {
             catch { failure = error }
         }
         lock.unlock()
-        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))) }
+        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The media cache was cleared"))) }
         if let failure { throw failure }
         return removed
     }