craft-native 0.0.224 → 0.0.226

package/dist/android/src/index.js

@@ -549,6 +549,7 @@ function writeNativeShellSources(output, packagePath, packageName, config) {
   };
   write("CraftBluetooth.kt.template", "CraftBluetooth.kt");
   write("CraftNativeShell.kt.template", "CraftNativeShell.kt");
+  write("CraftNativeImageCache.kt.template", "CraftNativeImageCache.kt");
   write("CraftNativeBackground.kt.template", "CraftNativeBackground.kt");
   write(config.enableHealthConnect ? "CraftNativeHealth.kt.template" : "CraftNativeHealthStub.kt.template", "CraftNativeHealth.kt");
   write("CraftNativeServices.kt.template", "CraftNativeServices.kt", (source) => source.replace("{{NATIVE_PUSH_IMPORTS}}", config.enablePushNotifications ? "import com.google.firebase.messaging.FirebaseMessaging" : "").replace("{{NATIVE_PUSH_REGISTER}}", config.enablePushNotifications ? `        try {

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

@@ -0,0 +1,142 @@
+package {{PACKAGE_NAME}}
+
+import java.io.File
+import java.io.BufferedInputStream
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import java.io.IOException
+import java.io.OutputStream
+import java.security.MessageDigest
+import java.util.Locale
+
+internal data class CraftNativeImagePolicy(val expiresAt: Long)
+
+internal fun craftNativeImagePolicy(
+    requestHeaders: Map<String, String>,
+    responseHeaders: Map<String, List<String>>,
+    now: Long,
+): CraftNativeImagePolicy? {
+    // Persist only the anonymous content the server explicitly calls public.
+    // A custom header can carry an account credential just like Authorization.
+    if (requestHeaders.isNotEmpty()) return null
+    fun values(name: String) = responseHeaders.entries
+        .filter { it.key.equals(name, ignoreCase = true) }.flatMap { it.value }
+    val variants = values("Vary").flatMap { it.split(',') }.map { it.trim().lowercase(Locale.ROOT) }
+    if (values("Set-Cookie").isNotEmpty() || variants.any { it in setOf("*", "cookie", "authorization") }) return null
+    val directives = values("Cache-Control").flatMap { it.split(',') }.map { it.trim().lowercase(Locale.ROOT) }
+    if ("public" !in directives || directives.any { it.substringBefore('=').trim() in setOf("private", "no-store", "no-cache") }) return null
+    val ages = directives.filter { it.substringBefore('=').trim() == "max-age" }
+    if (ages.isEmpty()) return null
+    val seconds = ages.map {
+        it.substringAfter('=', "").trim().removeSurrounding("\"").toLongOrNull()?.takeIf { age -> age > 0 } ?: return null
+    }.min().coerceAtMost(31_536_000L)
+    val ageHeader = values("Age").firstOrNull()
+    val age = if (ageHeader == null) 0L else ageHeader.trim().toLongOrNull()?.takeIf { it >= 0 } ?: return null
+    val remaining = seconds - age
+    if (remaining <= 0) return null
+    return runCatching { CraftNativeImagePolicy(Math.addExact(now, remaining * 1000)) }.getOrNull()
+}
+
+internal class CraftNativeImageCache(
+    private val root: File,
+    private val maxBytes: Long = 32L * 1024 * 1024,
+    private val maxEntryBytes: Long = 8L * 1024 * 1024,
+    private val maxEntries: Int = 128,
+    private val now: () -> Long = System::currentTimeMillis,
+) {
+    init {
+        require(maxBytes > 0 && maxEntryBytes > 0 && maxEntries > 0)
+        // A process killed while encoding can leave a staging file behind.
+        // All instances share this lock, so another writer cannot own it now.
+        synchronized(lock) {
+            runCatching {
+                root.listFiles().orEmpty().filter { it.name.endsWith(".tmp") }.forEach(File::delete)
+                prune()
+            }
+        }
+    }
+
+    private fun file(address: String): File {
+        val digest = MessageDigest.getInstance("SHA-256").digest(address.toByteArray(Charsets.UTF_8))
+        val name = digest.joinToString("") { (it.toInt() and 255).toString(16).padStart(2, '0') }
+        return File(root, "$name.cache")
+    }
+
+    fun read(address: String): ByteArray? = synchronized(lock) {
+        runCatching {
+            val target = file(address)
+            if (!target.isFile) return@runCatching null
+            if (target.length() <= HEADER_BYTES || target.length() > HEADER_BYTES + minOf(maxEntryBytes, maxBytes)) {
+                target.delete()
+                return@runCatching null
+            }
+            val data = DataInputStream(BufferedInputStream(target.inputStream())).use { input ->
+                if (input.readInt() != MAGIC || input.readLong() <= now()) null else input.readBytes()
+            }
+            if (data == null || data.isEmpty()) { target.delete(); null }
+            else { target.setLastModified(now()); data }
+        }.getOrNull()
+    }
+
+    fun write(address: String, policy: CraftNativeImagePolicy, encode: (OutputStream) -> Boolean): Boolean = synchronized(lock) {
+        var staging: File? = null
+        try {
+            if (policy.expiresAt <= now() || (!root.isDirectory && !root.mkdirs())) return@synchronized false
+            val target = file(address)
+            staging = File.createTempFile(target.name, ".tmp", root)
+            staging.outputStream().buffered().use { raw ->
+                val header = DataOutputStream(raw)
+                header.writeInt(MAGIC)
+                header.writeLong(policy.expiresAt)
+                val payload = BoundedImageOutput(raw, minOf(maxEntryBytes, maxBytes))
+                if (!encode(payload) || payload.written == 0L) throw IOException("Incomplete cached image")
+                payload.flush()
+            }
+            // Freshness and pixels are committed together; a failed write
+            // never replaces an earlier, complete image with a partial file.
+            if (!staging.renameTo(target)) return@synchronized false
+            target.setLastModified(now())
+            prune()
+            true
+        }
+        catch (error: Exception) { false }
+        catch (error: OutOfMemoryError) { false }
+        finally { staging?.delete() }
+    }
+
+    fun remove(address: String) = synchronized(lock) { runCatching { file(address).delete() }; Unit }
+
+    private fun prune() {
+        val entries = root.listFiles().orEmpty().filter { entryName.matches(it.name) }.sortedBy(File::lastModified)
+        var count = entries.size
+        var bytes = entries.sumOf { (it.length() - HEADER_BYTES).coerceAtLeast(0) }
+        for (entry in entries) {
+            if (count <= maxEntries && bytes <= maxBytes) break
+            val size = (entry.length() - HEADER_BYTES).coerceAtLeast(0)
+            if (entry.delete()) { count--; bytes -= size }
+        }
+    }
+
+    private class BoundedImageOutput(private val output: OutputStream, private val limit: Long) : OutputStream() {
+        var written = 0L
+            private set
+        override fun write(value: Int) {
+            if (written >= limit) throw IOException("Cached image is too large")
+            output.write(value)
+            written++
+        }
+        override fun write(bytes: ByteArray, offset: Int, length: Int) {
+            if (written + length > limit) throw IOException("Cached image is too large")
+            output.write(bytes, offset, length)
+            written += length
+        }
+        override fun flush() = output.flush()
+    }
+
+    private companion object {
+        const val MAGIC = 0x43494d31
+        const val HEADER_BYTES = 12L
+        val entryName = Regex("^[a-f0-9]{64}\\.cache$")
+        val lock = Any()
+    }
+}

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

@@ -120,6 +120,7 @@ internal class CraftNativeServices(
                         done(success(CraftNativeMedia.prune(context, (0 until keep.length()).map { keep.optString(it) })))
                     }
                     "usage" -> done(success(CraftNativeMedia.usage(context)))
+                    "clear" -> done(success(CraftNativeMedia.clear(context)))
                     else -> done(failure("UNKNOWN_ACTION", "Unsupported Media method"))
                 }
                 "Background" -> {

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

@@ -1021,7 +1021,8 @@ internal object CraftNativeSymbols {
  * A native Video given an address with a copy here plays the copy.
  */
 internal object CraftNativeMedia {
-    private val inFlight = HashMap<String, MutableList<(CraftNativeCapabilityResult) -> Unit>>()
+    private data class Flight(val id: String, val waiting: MutableList<(CraftNativeCapabilityResult) -> Unit>)
+    private val inFlight = HashMap<String, Flight>()
     private val executor = Executors.newFixedThreadPool(2)
     private val main = Handler(Looper.getMainLooper())
 
@@ -1054,12 +1055,12 @@ internal object CraftNativeMedia {
         if (!cellular && metered(context)) {
             return done(CraftNativeCapabilityResult(data = JSONObject().put("ok", false).put("url", address).put("reason", "cellular")))
         }
-        synchronized(inFlight) {
+        val flight = synchronized(inFlight) {
             inFlight[address]?.let { waiting ->
-                waiting.add(done)
+                waiting.waiting.add(done)
                 return
             }
-            inFlight[address] = mutableListOf(done)
+            Flight(java.util.UUID.randomUUID().toString(), mutableListOf(done)).also { inFlight[address] = it }
         }
         executor.execute {
             val result = runCatching {
@@ -1073,7 +1074,7 @@ internal object CraftNativeMedia {
                     val target = file(context, address)
                     target.parentFile?.mkdirs()
                     // Written aside and moved into place, so a half-written file is never played.
-                    val staging = File(target.parentFile, "${target.name}.part")
+                    val staging = File(target.parentFile, "${target.name}.${flight.id}.part")
                     try {
                         val size = connection.inputStream.use { input -> staging.outputStream().use { input.copyTo(it) } }
                         val expected = connection.contentLengthLong
@@ -1081,6 +1082,9 @@ internal object CraftNativeMedia {
                             return@runCatching CraftNativeCapabilityResult(code = "NETWORK_ERROR", message = "media.keep received an incomplete file")
                         }
                         synchronized(inFlight) {
+                            if (inFlight[address]?.id != flight.id) {
+                                return@runCatching CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared")
+                            }
                             if (!staging.renameTo(target)) {
                                 return@runCatching CraftNativeCapabilityResult(code = "IO_ERROR", message = "media.keep could not store the file")
                             }
@@ -1098,7 +1102,7 @@ internal object CraftNativeMedia {
                 }
                 CraftNativeCapabilityResult(code = if (full) "NO_SPACE" else if (error is java.net.SocketTimeoutException) "TIMEOUT" else "NETWORK_ERROR", message = error.message ?: "media.keep failed")
             }
-            val waiting = synchronized(inFlight) { inFlight.remove(address) ?: mutableListOf() }
+            val waiting = synchronized(inFlight) { if (inFlight[address]?.id == flight.id) inFlight.remove(address)?.waiting.orEmpty() else emptyList() }
             main.post { waiting.forEach { it(result) } }
         }
     }
@@ -1115,12 +1119,31 @@ internal object CraftNativeMedia {
         var removed = 0
         synchronized(inFlight) {
             // A concurrent keep owns its target and staging file until it finishes.
-            val active = inFlight.keys.map { file(context, it).name }.toSet()
+            val active = inFlight.flatMap { (address, flight) ->
+                val name = file(context, address).name
+                listOf(name, "$name.${flight.id}.part")
+            }.toSet()
+            root(context).listFiles()?.forEach { file ->
+                if (file.name !in active && file.name !in wanted && file.delete()) removed++
+            }
+        }
+        return removed
+    }
+
+    /** Invalidates old transfers before deleting files; a later keep starts afresh. */
+    fun clear(context: Context): Int {
+        var removed = 0
+        var failure: java.io.IOException? = null
+        val waiting = synchronized(inFlight) {
+            val callbacks = inFlight.values.flatMap { it.waiting }
+            inFlight.clear()
             root(context).listFiles()?.forEach { file ->
-                val target = file.name.removeSuffix(".part")
-                if (target !in active && file.name !in wanted && file.delete()) removed++
+                if (file.delete()) removed++ else failure = java.io.IOException("The video cache could not be cleared")
             }
+            callbacks
         }
+        main.post { waiting.forEach { it(CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared")) } }
+        failure?.let { throw it }
         return removed
     }
 

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

@@ -122,6 +122,8 @@ import com.google.android.gms.maps.model.Polyline
 import com.google.android.gms.maps.model.PolylineOptions
 import org.json.JSONArray
 import org.json.JSONObject
+import java.io.File
+import java.net.HttpURLConnection
 import java.net.URL
 import java.text.SimpleDateFormat
 import java.util.Calendar
@@ -3805,6 +3807,7 @@ class MainActivity : AppCompatActivity() {
     private var windowSafeInsets = intArrayOf(0, 0, 0, 0)
     private var useMessagePorts = false
     private val imageExecutor = Executors.newFixedThreadPool(2)
+    private val imageCache by lazy { CraftNativeImageCache(File(cacheDir, "craft-native-images")) }
     /** Lays out each isolate's prelude (the synchronous stores) off the main thread. */
     private val preludeExecutor = Executors.newSingleThreadExecutor()
     private val imageSources = mutableMapOf<ImageView, String>()
@@ -4088,6 +4091,7 @@ class MainActivity : AppCompatActivity() {
                 show(target)
             } else {
                 host.removeView(target.view)
+                target.view.translationX = 0f
                 current.view.translationX = 0f
                 chrome?.selectTab(currentTab)
                 tabSwipeTarget = null
@@ -4156,13 +4160,22 @@ class MainActivity : AppCompatActivity() {
      * page on the app's site in the in-app browser. Another site's address
      * opens in the browser too.
      */
-    private fun navigateOpen(target: String, fromLink: Boolean = false) {
+    private fun navigateOpen(target: String, fromLink: Boolean = false, replace: Boolean = false) {
         val path = routes.appPath(target, urlSchemes)
         if (path == null) {
             openExternal(target)
             return
         }
         val match = routes.match(path)
+        if (replace && match != null && screens.isNotEmpty()) {
+            val stack = screens
+            val removed = stack.removeAt(stack.lastIndex)
+            val previous = stack.lastOrNull()
+            closeScreen(removed) {
+                if (screens === stack && stack.lastOrNull() === previous) navigateOpen(path, fromLink)
+            }
+            return
+        }
         val tab = routes.tabFor(path)
         if (tab != null) {
             selectTab(routes.tabs.indexOf(tab))
@@ -4492,6 +4505,11 @@ class MainActivity : AppCompatActivity() {
      * screen shown before hears true (its `navigation.onAppear`).
      */
     private fun show(screen: Screen) {
+        // A retained tab may have been the offscreen preview of a cancelled
+        // swipe, or the outgoing view of a completed swipe. Its animator can
+        // finish after the peer animator, so clear that ownership on display.
+        screen.view.animate().withEndAction(null).setListener(null).cancel()
+        screen.view.translationX = 0f
         // A navigation breadcrumb: the trail a crash report carries.
         if (visibleScreen !== screen) CraftCrashReporter.screenAppeared(screen.route ?: "home")
         val bars = chrome
@@ -4770,6 +4788,12 @@ class MainActivity : AppCompatActivity() {
                 // app script has no stack of its own; it uses NAVIGATE_OPEN.
                 if (visibleScreen !== screen) return
                 val route = payload.optString("screen").takeIf { it.isNotBlank() } ?: return
+                // Resolve and replace in one host operation. A pop followed by
+                // open would send the second message from a closing isolate.
+                if (message.optString("type") == "NAVIGATE_REPLACE" && route.startsWith("/")) {
+                    navigateOpen(route, replace = true)
+                    return
+                }
                 if (message.optString("type") == "NAVIGATE_REPLACE") {
                     val stack = screens
                     val removed = stack.removeAt(stack.lastIndex)
@@ -6101,7 +6125,9 @@ class MainActivity : AppCompatActivity() {
             null
         } else defaultBackground
         val overflow = craftNativeOptionalString(style.opt("overflow"))
-        view.clipToOutline = overflow == "hidden"
+        // A replaced image clips its own pixels to border-radius, including
+        // when its surrounding layout permits visible overflow.
+        view.clipToOutline = overflow == "hidden" || (view is ImageView && (radius > 0 || hasCornerRadii))
         if (view is ViewGroup) view.clipChildren = overflow == "hidden"
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P &&
             (style.has("shadowColor") || style.has("shadowOpacity") || style.has("shadowRadius"))
@@ -6499,12 +6525,38 @@ class MainActivity : AppCompatActivity() {
         }
         imageJobs[view] = imageExecutor.submit {
             val bitmap = runCatching {
-                val connection = URL(uri).openConnection().apply {
+                val publicRequest = headers.isEmpty() && Uri.parse(uri).userInfo.isNullOrEmpty()
+                if (publicRequest) {
+                    val bytes = imageCache.read(uri)
+                    if (bytes != null) {
+                        val saved = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+                        if (saved != null) return@runCatching saved
+                        imageCache.remove(uri)
+                    }
+                }
+                val connection = (URL(uri).openConnection() as HttpURLConnection).apply {
                     connectTimeout = 10_000
                     readTimeout = 10_000
+                    // This loader owns its bounded public cache. Do not let
+                    // an application's global ResponseCache retain requests.
+                    useCaches = false
                     headers.forEach { (name, value) -> setRequestProperty(name, value) }
                 }
-                connection.getInputStream().use(BitmapFactory::decodeStream)
+                try {
+                    val downloaded = connection.inputStream.use(BitmapFactory::decodeStream)
+                    if (publicRequest) {
+                        val responseHeaders = connection.headerFields.entries.filter { it.key != null }
+                            .associate { it.key!! to it.value.orEmpty() }
+                        val policy = if (connection.responseCode == HttpURLConnection.HTTP_OK)
+                            craftNativeImagePolicy(headers, responseHeaders, System.currentTimeMillis()) else null
+                        if (downloaded != null && policy != null) {
+                            // Encode only after a complete decode, then commit
+                            // before onLoad so a cold offline reopen is safe.
+                            imageCache.write(uri, policy) { downloaded.compress(Bitmap.CompressFormat.PNG, 100, it) }
+                        } else imageCache.remove(uri)
+                    }
+                    downloaded
+                } finally { connection.disconnect() }
             }.getOrNull()
             runOnUiThread {
                 if (imageSources[view] != requestKey) return@runOnUiThread

package/dist/browser.js

@@ -283,6 +283,13 @@ async function createBrowserPlatform(options = {}) {
   };
   const lifetime = new AbortController;
   let account = new AbortController;
+  let mediaTransfers = new AbortController;
+  let mediaWrites = Promise.resolve();
+  const writeMedia = (work) => {
+    const write = mediaWrites.then(work);
+    mediaWrites = write.catch(() => {});
+    return write;
+  };
   let mediaScope = persistence.scope();
   let wakeLock = null;
   let disposed = false;
@@ -365,6 +372,7 @@ async function createBrowserPlatform(options = {}) {
       if (!("caches" in window))
         return url;
       const scope = persistence.scope();
+      const transfer = mediaTransfers.signal;
       const existing = mediaURLs.get(url);
       if (existing)
         return existing;
@@ -372,7 +380,7 @@ async function createBrowserPlatform(options = {}) {
       if (!saved)
         return url;
       const local = URL.createObjectURL(await saved.blob());
-      if (disposed || scope !== persistence.scope()) {
+      if (disposed || transfer.aborted || scope !== persistence.scope()) {
         URL.revokeObjectURL(local);
         return url;
       }
@@ -629,6 +637,25 @@ async function createBrowserPlatform(options = {}) {
       if (module === "Media") {
         if (!("caches" in window))
           return unsupported(module, method);
+        if (method === "clear") {
+          mediaTransfers.abort();
+          mediaTransfers = new AbortController;
+          const name = cacheName();
+          return writeMedia(async () => {
+            const cache2 = await caches.open(name);
+            let removed = 0;
+            for (const entry of await cache2.keys()) {
+              if (await cache2.delete(entry))
+                removed++;
+              const local = mediaURLs.get(entry.url);
+              if (local)
+                URL.revokeObjectURL(local);
+              mediaURLs.delete(entry.url);
+            }
+            return removed;
+          });
+        }
+        signal = AbortSignal.any([signal, mediaTransfers.signal]);
         const cache = await caches.open(cacheName());
         if (method === "keep") {
           const url = String(args[0]);
@@ -646,7 +673,11 @@ async function createBrowserPlatform(options = {}) {
           signal.throwIfAborted();
           const headers = new Headers(response.headers);
           headers.set("x-craft-size", String(body.size));
-          await cache.put(url, new Response(body, { headers, status: response.status }));
+          await writeMedia(async () => {
+            signal.throwIfAborted();
+            await cache.put(url, new Response(body, { headers, status: response.status }));
+            signal.throwIfAborted();
+          });
           return { ok: true, url, path: url, size: body.size };
         }
         if (method === "path")

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/templates/CraftHybrid.swift

@@ -266,6 +266,8 @@ protocol CraftHybridScreenEvents: AnyObject {
     func nativeScreen(_ screen: CraftNativeScreenController, didFail message: String)
     /// `craft.navigation.open(path)`.
     func nativeScreen(_ screen: CraftNativeScreenController, open path: String)
+    /// `craft.navigation.replace(path)`: finish the current flow atomically.
+    func nativeScreen(_ screen: CraftNativeScreenController, replace path: String)
 }
 
 // MARK: - The shell
@@ -938,6 +940,10 @@ extension CraftHybrid: CraftHybridScreenEvents {
     func nativeScreen(_ screen: CraftNativeScreenController, open path: String) {
         open(path)
     }
+
+    func nativeScreen(_ screen: CraftNativeScreenController, replace path: String) {
+        controller?.showNative(path: path, replace: true)
+    }
 }
 
 /// The page's `craftHybrid` channel, only from a trusted origin's main frame.
@@ -1519,6 +1525,10 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         interruptTabSwipe(restoringSelection: true)
         let tabs = hybrid.tabIds
         if let tab = tabs.first(where: { CraftHybridRoutes.normalize($0) == match.path }) {
+            // Finish the flow in its original tab before selecting another.
+            if replace, let current = visibleStack, current.viewControllers.count > 1 {
+                current.setViewControllers(Array(current.viewControllers.dropLast()), animated: false)
+            }
             if tab != currentTab {
                 selectTabAsIfTapped(tab)
             }
@@ -1541,7 +1551,7 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
             return
         }
         let screen = entry(for: raw, isTabRoot: false, depth: nil)
-        if replace, nav.viewControllers.count > 1 {
+        if replace, !nav.viewControllers.isEmpty {
             nav.setViewControllers(Array(nav.viewControllers.dropLast()) + [screen], animated: true)
         } else {
             nav.pushViewController(screen, animated: true)
@@ -1900,6 +1910,11 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
         open(path)
     }
 
+    func nativeScreen(_ screen: CraftNativeScreenController, replace path: String) {
+        guard screen.navigationController?.topViewController === screen else { return }
+        showNative(path: path, replace: true)
+    }
+
     private func log(_ message: String) {
         #if DEBUG
         NSLog("[craft hybrid] %@", message)

package/dist/ios/templates/CraftNativeActions.swift

@@ -254,6 +254,12 @@ enum CraftNativeActions {
             return
         case ("Media", "usage"):
             sync = .success(CraftNativeMedia.usage())
+        case ("Media", "clear"):
+            DispatchQueue.global(qos: .utility).async {
+                do { complete(requestToken, .success(try CraftNativeMedia.clear()), completion) }
+                catch { complete(requestToken, failure("IO_ERROR", "The video cache could not be cleared"), completion) }
+            }
+            return
         case ("Lifecycle", "getState"):
             sync = .success(currentAppState())
         case ("DeepLinks", "getInitialURL"):
@@ -782,7 +788,7 @@ enum CraftNativeActions {
             request.allowsExpensiveNetworkAccess = false
             request.allowsConstrainedNetworkAccess = false
         }
-        if CraftNativeMedia.join(address, { complete(requestToken, $0, completion) }) { return }
+        guard let flight = CraftNativeMedia.begin(address, { complete(requestToken, $0, completion) }) else { return }
         let task = fetchSession.downloadTask(with: request) { location, response, error in
             cancellationLock.lock()
             fetchTasks.removeValue(forKey: requestToken)
@@ -790,25 +796,25 @@ enum CraftNativeActions {
             if let error = error {
                 // Refused only because the connection is metered: not a failure, a wait.
                 if let reason = (error as? URLError)?.networkUnavailableReason, reason == .expensive || reason == .constrained {
-                    CraftNativeMedia.finish(address, .success(["ok": false, "url": address, "reason": "cellular"]))
+                    CraftNativeMedia.finish(address, flight: flight, .success(["ok": false, "url": address, "reason": "cellular"]))
                     return
                 }
                 let code = (error as? URLError)?.code == .timedOut ? "TIMEOUT" : "NETWORK_ERROR"
-                CraftNativeMedia.finish(address, failure(CraftNativeMedia.errorCode(error, fallback: code), error.localizedDescription))
+                CraftNativeMedia.finish(address, flight: flight, failure(CraftNativeMedia.errorCode(error, fallback: code), error.localizedDescription))
                 return
             }
             guard let http = response as? HTTPURLResponse, let location else {
-                CraftNativeMedia.finish(address, failure("NETWORK_ERROR", "media.keep received a response that is not HTTP"))
+                CraftNativeMedia.finish(address, flight: flight, failure("NETWORK_ERROR", "media.keep received a response that is not HTTP"))
                 return
             }
             // The system deletes `location` once this returns: move it now.
-            CraftNativeMedia.finish(address, CraftNativeMedia.store(address, at: location, response: http))
+            CraftNativeMedia.finish(address, flight: flight, CraftNativeMedia.store(address, at: location, response: http, flight: flight))
         }
         cancellationLock.lock()
         let alreadyCancelled = cancelledRequests.contains(requestToken)
         if !alreadyCancelled { fetchTasks[requestToken] = task }
         cancellationLock.unlock()
-        if alreadyCancelled { CraftNativeMedia.finish(address, failure("CANCELLED", "media.keep was cancelled")) }
+        if alreadyCancelled { CraftNativeMedia.finish(address, flight: flight, failure("CANCELLED", "media.keep was cancelled")) }
         else { task.resume() }
     }
 

package/dist/ios/templates/CraftNativeFiles.swift

@@ -514,7 +514,11 @@ enum CraftNativeMedia {
 
     private static let lock = NSLock()
     /// Addresses being fetched now, so a second `keep` waits for the first.
-    private static var inFlight: [String: [(Result<Any, CraftNativeActionError>) -> Void]] = [:]
+    private struct Flight {
+        let id: UUID
+        var waiting: [(Result<Any, CraftNativeActionError>) -> Void]
+    }
+    private static var inFlight: [String: Flight] = [:]
 
     /// Where `address`'s copy lives (whether or not it is there yet). The
     /// extension is the address's, because AVPlayer reads the type from it.
@@ -537,28 +541,29 @@ enum CraftNativeMedia {
         return ["ok": true, "url": address, "path": url.path, "size": size]
     }
 
-    /// Joins a fetch of `address` already under way; true when one was.
-    static func join(_ address: String, _ done: @escaping (Result<Any, CraftNativeActionError>) -> Void) -> Bool {
+    /// A new download's identity, or nil after joining an existing download.
+    static func begin(_ address: String, _ done: @escaping (Result<Any, CraftNativeActionError>) -> Void) -> UUID? {
         lock.lock()
         defer { lock.unlock() }
         if inFlight[address] != nil {
-            inFlight[address]!.append(done)
-            return true
+            inFlight[address]!.waiting.append(done)
+            return nil
         }
-        inFlight[address] = [done]
-        return false
+        let id = UUID()
+        inFlight[address] = Flight(id: id, waiting: [done])
+        return id
     }
 
-    static func finish(_ address: String, _ result: Result<Any, CraftNativeActionError>) {
+    static func finish(_ address: String, flight: UUID, _ result: Result<Any, CraftNativeActionError>) {
         lock.lock()
-        let waiting = inFlight.removeValue(forKey: address) ?? []
+        let waiting = inFlight[address]?.id == flight ? inFlight.removeValue(forKey: address)?.waiting ?? [] : []
         lock.unlock()
         for done in waiting { done(result) }
     }
 
     /// A finished download moved into place (atomically, so a half-written
     /// file is never played), or a refusal with the server's status.
-    static func store(_ address: String, at location: URL, response: HTTPURLResponse) -> Result<Any, CraftNativeActionError> {
+    static func store(_ address: String, at location: URL, response: HTTPURLResponse, flight: UUID? = nil) -> Result<Any, CraftNativeActionError> {
         guard response.statusCode == 200 else {
             return .success(["ok": false, "url": address, "status": response.statusCode])
         }
@@ -566,6 +571,9 @@ enum CraftNativeMedia {
         // Commit and prune share a lock; neither can remove a file being committed.
         lock.lock()
         defer { lock.unlock() }
+        if let flight, inFlight[address]?.id != flight {
+            return .failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))
+        }
         let staging = root.appendingPathComponent(UUID().uuidString + ".part")
         defer { try? fm.removeItem(at: staging) }
         do {
@@ -596,6 +604,25 @@ enum CraftNativeMedia {
         }
     }
 
+    /// End an account's cache lifetime.
+    static func clear() throws -> Int {
+        lock.lock()
+        let waiting = inFlight.values.flatMap { $0.waiting }
+        inFlight.removeAll()
+        let fm = FileManager.default
+        let files = (try? fm.contentsOfDirectory(at: root, includingPropertiesForKeys: nil)) ?? []
+        var removed = 0
+        var failure: Error?
+        for url in files {
+            do { try fm.removeItem(at: url); removed += 1 }
+            catch { failure = error }
+        }
+        lock.unlock()
+        for done in waiting { done(.failure(CraftNativeActionError(code: "CANCELLED", message: "The video cache was cleared"))) }
+        if let failure { throw failure }
+        return removed
+    }
+
     /// Removes every copy whose address is not in `keep`; answers how many.
     static func prune(keep: [String]) -> Int {
         lock.lock()

package/dist/ios/templates/CraftNativeScreen.swift

@@ -5416,6 +5416,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             guard !isAppScript, navigationController?.topViewController === self,
                   let screen = payload["screen"] as? String, !screen.isEmpty,
                   let navigation = navigationController else { return }
+            if type == "NAVIGATE_REPLACE", screen.hasPrefix("/") {
+                hybridEvents?.nativeScreen(self, replace: screen)
+                return
+            }
             let params = payload["params"] as? [String: Any] ?? [:]
             let next = CraftNativeScreenController(config: config, routeName: screen, routeParams: params)
             next.hybridEvents = hybridEvents
@@ -6067,7 +6071,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if let current = image.image { image.image = imageForDisplay(current, view: image) }
             let requestedResizeMode = style["resizeMode"] as? String ?? props["resizeMode"] as? String
             image.contentMode = imageContentMode(requestedResizeMode)
-            image.clipsToBounds = image.contentMode == .scaleAspectFill
+            image.clipsToBounds = image.clipsToBounds || image.contentMode == .scaleAspectFill
             updateAuxiliaryHandler(events["onLoadStart"], in: &imageLoadStartHandlers, for: image)
             updateAuxiliaryHandler(events["onLoad"], in: &imageLoadHandlers, for: image)
             updateAuxiliaryHandler(events["onLoadEnd"], in: &imageLoadEndHandlers, for: image)
@@ -6086,7 +6090,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             if let current = background.image { background.image = imageForDisplay(current, view: background) }
             let requestedResizeMode = style["resizeMode"] as? String ?? props["resizeMode"] as? String
             background.contentMode = imageContentMode(requestedResizeMode)
-            background.clipsToBounds = background.contentMode == .scaleAspectFill
+            background.clipsToBounds = background.clipsToBounds || background.contentMode == .scaleAspectFill
             updateAuxiliaryHandler(events["onLoadStart"], in: &imageLoadStartHandlers, for: background)
             updateAuxiliaryHandler(events["onLoad"], in: &imageLoadHandlers, for: background)
             updateAuxiliaryHandler(events["onLoadEnd"], in: &imageLoadEndHandlers, for: background)
@@ -7006,6 +7010,7 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
         view.clipsToBounds = overflow == "hidden"
             || (view is UIScrollView && overflow != "visible")
             || (view is UILabel && (view.craftRequestedCornerRadius ?? 0) > 0)
+            || (view is UIImageView && (borderRadius > 0 || hasCornerRadii))
         view.layer.masksToBounds = view.clipsToBounds
         view.craftLayoutStyle = CraftNativeLayoutStyle(style)
         (view as? CraftNativeFlowView)?.invalidateMeasurements()

package/dist/mobile-testing.js

@@ -149,6 +149,8 @@ ${await Bun.file(join(fixtures, "media-cache.swift.fixture")).text()}`);
         print(await run(["xcrun", "simctl", "spawn", simulator, executable, base, "recover"]));
         if (counts.get("/ios/slow.mp4") !== 1)
           throw new Error("iOS duplicate fetch: keep did not coalesce");
+        if (counts.get("/ios/account/slow.mp4") !== 2)
+          throw new Error("iOS account switch did not start a fresh transfer");
         print("PASS: iOS simulator interruption, restart, retry, prune and cached video decode");
       }
     }
@@ -232,6 +234,8 @@ ${await Bun.file(join(fixtures, "media-cache.kt")).text()}`);
         await probe("recover");
         if (counts.get("/android/slow.mp4") !== 1)
           throw new Error("Android duplicate fetch: keep did not coalesce");
+        if (counts.get("/android/account/slow.mp4") !== 2)
+          throw new Error("Android account switch did not start a fresh transfer");
         print("PASS: Android emulator interruption, restart, retry, prune and cached video decode");
       }
     }

package/dist/testing/media-cache/media-cache.kt

@@ -75,10 +75,11 @@ class DownloadProbe : android.app.Instrumentation() {
                 "interrupt" -> {
                     CraftNativeMedia.prune(targetContext, emptyList())
                     CraftNativeMedia.keep(targetContext, restart, JSONObject(), true) {}
-                    val part = File(CraftNativeMedia.file(targetContext, restart).absolutePath + ".part")
+                    val target = CraftNativeMedia.file(targetContext, restart)
+                    fun partial() = target.parentFile!!.listFiles()?.any { it.name.startsWith(target.name + ".") && it.name.endsWith(".part") && it.length() > 0 } == true
                     val until = System.currentTimeMillis() + 25000
-                    while ((!part.exists() || part.length() == 0L) && System.currentTimeMillis() < until) Thread.sleep(25)
-                    check(part.length() > 0, "download is in progress before process death")
+                    while (!partial() && System.currentTimeMillis() < until) Thread.sleep(25)
+                    check(partial(), "download is in progress before process death")
                     android.os.Process.killProcess(android.os.Process.myPid())
                 }
                 "recover" -> {
@@ -111,6 +112,26 @@ class DownloadProbe : android.app.Instrumentation() {
                     check(answers.size == 2 && answers.all { it }, "concurrent downloads coalesce and survive prune")
                     check(root.listFiles()?.none { it.name.endsWith(".part") } != false, "no abandoned staging files remain")
                     CraftNativeMedia.prune(targetContext, emptyList())
+                    val privateVideo = "$base/account/slow.mp4"
+                    val previous = java.util.concurrent.CountDownLatch(1)
+                    var cancelled = false
+                    CraftNativeMedia.keep(targetContext, privateVideo, JSONObject(), true) { cancelled = it.code == "CANCELLED"; previous.countDown() }
+                    val privateTarget = CraftNativeMedia.file(targetContext, privateVideo)
+                    fun downloading() = root.listFiles()?.any { it.name.startsWith(privateTarget.name + ".") && it.name.endsWith(".part") && it.length() > 0 } == true
+                    val deadline = System.currentTimeMillis() + 25000
+                    while (!downloading() && System.currentTimeMillis() < deadline) Thread.sleep(10)
+                    check(downloading(), "the previous athlete's download is in progress before sign-out")
+                    CraftNativeMedia.clear(targetContext)
+                    check(previous.await(5, java.util.concurrent.TimeUnit.SECONDS) && cancelled, "sign-out cancels the previous athlete's download")
+                    check(CraftNativeMedia.local(targetContext, privateVideo) == null, "signed-out video is not playable from cache")
+                    check(keep(privateVideo), "the next athlete downloads the same URL in a new transfer")
+                    val media = android.media.MediaMetadataRetriever()
+                    try {
+                        media.setDataSource(CraftNativeMedia.local(targetContext, privateVideo)!!.absolutePath)
+                        check(media.getFrameAtTime(1000000) != null, "the next athlete's local video decodes after the old download settles")
+                    } finally { media.release() }
+                    CraftNativeMedia.clear(targetContext)
+                    check(CraftNativeMedia.local(targetContext, privateVideo) == null, "sign-out removes the next athlete's cached copy too")
                 }
             }
             result.putString("stream", "${proof}PASS: ${args.getString("phase")} native download probe")

package/dist/testing/media-cache/media-cache.swift.fixture

@@ -17,16 +17,16 @@ var latestTask: URLSessionTask?
 var latestErrorCode: String?
 func start(_ address: String, _ done: @escaping (Bool) -> Void) {
     if let local = CraftNativeMedia.local(address) { done((CraftNativeMedia.describe(address, local)["size"] as? Int ?? 0) > 0); return }
-    if CraftNativeMedia.join(address, { result in
+    guard let flight = CraftNativeMedia.begin(address, { result in
         if case .success(let data) = result { done((data as? [String: Any])?["ok"] as? Bool == true) }
         else if case .failure(let error) = result { latestErrorCode = error.code; done(false) }
-    }) { return }
+    }) else { return }
     let task = URLSession.shared.downloadTask(with: URL(string: address)!) { location, response, error in
         let result: Result<Any, CraftNativeActionError>
         if error != nil { result = .failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "Interrupted")) }
-        else if let location, let response = response as? HTTPURLResponse { result = CraftNativeMedia.store(address, at: location, response: response) }
+        else if let location, let response = response as? HTTPURLResponse { result = CraftNativeMedia.store(address, at: location, response: response, flight: flight) }
         else { result = .failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "No file")) }
-        CraftNativeMedia.finish(address, result)
+        CraftNativeMedia.finish(address, flight: flight, result)
     }
     latestTask = task
     task.resume()
@@ -116,3 +116,19 @@ check(answers == [true, true], "concurrent downloads coalesce and survive prune"
 let parts = (try? fm.contentsOfDirectory(atPath: CraftNativeMedia.root.path))?.filter { $0.hasSuffix(".part") } ?? []
 check(parts.isEmpty, "no abandoned staging files remain")
 _ = CraftNativeMedia.prune(keep: [])
+let privateVideo = base + "/account/slow.mp4"
+var previousAnswer: Bool?
+start(privateVideo) { previousAnswer = $0 }
+let previousTask = latestTask!
+wait { previousTask.countOfBytesReceived > 0 }
+_ = try CraftNativeMedia.clear()
+check(previousAnswer == false && latestErrorCode == "CANCELLED", "sign-out cancels the previous athlete's download")
+check(CraftNativeMedia.local(privateVideo) == nil, "signed-out video is not playable from cache")
+check(keep(privateVideo), "the next athlete downloads the same URL in a new transfer")
+wait { previousTask.state == .completed }
+let cached = CraftNativeMedia.local(privateVideo)!
+let generator = AVAssetImageGenerator(asset: AVURLAsset(url: cached))
+_ = try generator.copyCGImage(at: CMTime(seconds: 1, preferredTimescale: 600), actualTime: nil)
+check(true, "the next athlete's local video decodes after the old download settles")
+_ = try CraftNativeMedia.clear()
+check(CraftNativeMedia.local(privateVideo) == nil, "sign-out removes the next athlete's cached copy too")

package/package.json

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