craft-native 0.0.249 → 0.0.251

package/dist/android/src/index.js

@@ -316,10 +316,18 @@ async function createAndroidEmulator(options) {
 `);
     const deadline = bootStartedAt + bootTimeoutMs;
     const probeTimeout = () => Math.max(1, Math.min(1e4, deadline - Date.now()));
+    let connected = false;
+    let lastReconnectAt = 0;
     while (Date.now() < deadline && child.exitCode === null) {
       let booted = false;
       const connection = await run([adb, "devices"], undefined, probeTimeout(), true);
-      if (connection.code === 0 && connection.stdout.includes(`${serial}	device`)) {
+      const state = connection.stdout.split(/\r?\n/).find((line) => line.startsWith(`${serial}	`))?.split(/\s+/)[1];
+      if (connection.code === 0 && state === "offline" && connected && Date.now() - lastReconnectAt >= 30000 && Date.now() < deadline) {
+        lastReconnectAt = Date.now();
+        await run([adb, "-s", serial, "reconnect"], undefined, probeTimeout(), true);
+      }
+      if (connection.code === 0 && state === "device") {
+        connected = true;
         const completion = await run([adb, "-s", serial, "shell", "getprop", "sys.boot_completed"], undefined, probeTimeout(), true);
         if (completion.code === 0 && completion.stdout.trim() === "1") {
           const settings = await run([adb, "-s", serial, "shell", "settings", "get", "global", "animator_duration_scale"], undefined, probeTimeout(), true);

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

@@ -1238,7 +1238,8 @@ internal object CraftNativeMedia {
     private const val PREFS = "craft.media"
     private val lock = Any()
     /** Keeps waiting in this process for an address's transfer. */
-    private val waiting = HashMap<String, MutableList<(CraftNativeCapabilityResult) -> Unit>>()
+    private data class Waiting(val generation: Int, val answer: (CraftNativeCapabilityResult) -> Unit)
+    private val waiting = HashMap<String, MutableList<Waiting>>()
     /** One transfer writes an address's part file at a time. */
     private val writers = ConcurrentHashMap<String, Any>()
     private val background = Executors.newSingleThreadExecutor()
@@ -1276,44 +1277,69 @@ internal object CraftNativeMedia {
         if (uri == null || uri.scheme?.lowercase() !in setOf("http", "https") || uri.host.isNullOrBlank()) {
             return done(CraftNativeCapabilityResult(code = "INVALID_ARGUMENT", message = "media.keep needs an absolute http or https URL"))
         }
-        local(context, address)?.let { return done(CraftNativeCapabilityResult(data = describe(address, it))) }
         val app = context.applicationContext
-        synchronized(lock) { waiting.getOrPut(address) { mutableListOf() }.add(done) }
+        val started = synchronized(lock) {
+            local(app, address)?.let { return done(CraftNativeCapabilityResult(data = describe(address, it))) }
+            generation(app).also { waiting.getOrPut(address) { mutableListOf() }.add(Waiting(it, done)) }
+        }
         val wifiOnly = !cellular
         val work = androidx.work.WorkManager.getInstance(app)
         // The same address under the other rule gives way; its part file is resumed.
         work.cancelUniqueWork(workName(address, !wifiOnly))
         val request = androidx.work.OneTimeWorkRequestBuilder<CraftNativeMediaWorker>()
             .setConstraints(androidx.work.Constraints.Builder().setRequiredNetworkType(if (wifiOnly) androidx.work.NetworkType.UNMETERED else androidx.work.NetworkType.CONNECTED).build())
-            .setInputData(androidx.work.workDataOf("address" to address, "headers" to headers.toString(), "generation" to generation(app)))
+            .setInputData(androidx.work.workDataOf("address" to address, "headers" to headers.toString(), "generation" to started))
             .setBackoffCriteria(androidx.work.BackoffPolicy.EXPONENTIAL, 30, java.util.concurrent.TimeUnit.SECONDS)
             .addTag(TAG)
+            .addTag("$TAG:generation:$started")
             .addTag("$TAG:${digest(address)}")
             .build()
-        // A transfer running for this address is joined (KEEP), not started again. One
-        // only queued, or waiting out a retry's backoff, is replaced: asked for again,
-        // it runs now and resumes the part the last attempt left.
+        // Join a running or freshly queued transfer. Only a failed attempt's
+        // backoff is replaced so an explicit retry can resume immediately.
         val name = workName(address, wifiOnly)
         background.execute {
-            val running = runCatching { work.getWorkInfosForUniqueWork(name).get() }.getOrDefault(emptyList())
-                .any { it.state == androidx.work.WorkInfo.State.RUNNING }
-            work.enqueueUniqueWork(name, if (running) androidx.work.ExistingWorkPolicy.KEEP else androidx.work.ExistingWorkPolicy.REPLACE, request)
+            try {
+                if (generation(app) == started) {
+                    val pending = work.getWorkInfosForUniqueWork(name).get().any {
+                        "$TAG:generation:$started" in it.tags &&
+                            (it.state == androidx.work.WorkInfo.State.RUNNING ||
+                                (it.state == androidx.work.WorkInfo.State.ENQUEUED && it.runAttemptCount == 0))
+                    }
+                    // The next serial decision must see this enqueue's committed state.
+                    work.enqueueUniqueWork(name, if (pending) androidx.work.ExistingWorkPolicy.KEEP else androidx.work.ExistingWorkPolicy.REPLACE, request).result.get()
+                }
+            } catch (error: Exception) {
+                if (error is InterruptedException) Thread.currentThread().interrupt()
+                if (generation(app) == started) {
+                    deliver(context, address, started, CraftNativeCapabilityResult(code = "IO_ERROR", message = "media.keep could not schedule the download"))
+                }
+            }
         }
         val reason = when {
             !online(app) -> "offline"
             wifiOnly && metered(app) -> "cellular"
             else -> null
         }
-        if (reason != null) deliver(address, queued(address, reason))
+        if (reason != null) deliver(context, address, started, queued(address, reason))
     }
 
     private fun queued(address: String, reason: String) =
         CraftNativeCapabilityResult(data = JSONObject().put("ok", false).put("url", address).put("reason", reason).put("queued", true))
 
-    /** Answers every keep waiting for `address`. */
-    fun deliver(address: String, result: CraftNativeCapabilityResult) {
-        val answered = synchronized(lock) { waiting.remove(address).orEmpty() }
-        if (answered.isNotEmpty()) main.post { answered.forEach { it(result) } }
+    /** Answers only keeps belonging to this transfer's cache generation. */
+    fun deliver(context: Context, address: String, started: Int, result: CraftNativeCapabilityResult) {
+        val answered = synchronized(lock) {
+            val pending = waiting[address].orEmpty()
+            val matching = pending.filter { it.generation == started }
+            val remaining = pending.filter { it.generation != started }.toMutableList()
+            if (remaining.isEmpty()) waiting.remove(address) else waiting[address] = remaining
+            matching
+        }
+        if (answered.isNotEmpty()) main.post {
+            val current = if (generation(context) == started) result else
+                CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared")
+            answered.forEach { it.answer(current) }
+        }
     }
 
     enum class Outcome { DONE, RETRY }
@@ -1324,16 +1350,23 @@ internal object CraftNativeMedia {
      * waits. RETRY leaves the part file for the next attempt.
      */
     fun transfer(context: Context, address: String, headers: JSONObject, started: Int, attempt: Int, stopped: () -> Boolean): Outcome {
-        if (generation(context) != started) {
-            deliver(address, CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared"))
-            return Outcome.DONE
-        }
+        // clear() already answered the old generation's waiters. Never answer
+        // a new athlete's waiters from an obsolete worker for the same URL.
+        if (generation(context) != started) return Outcome.DONE
         local(context, address)?.let {
-            deliver(address, CraftNativeCapabilityResult(data = describe(address, it)))
+            deliver(context, address, started, CraftNativeCapabilityResult(data = describe(address, it)))
             return Outcome.DONE
         }
         val writer = writers.getOrPut(address) { Any() }
         synchronized(writer) {
+            // Another worker can finish, or sign-out can clear the cache, while
+            // this worker waits for the address's writer.
+            if (generation(context) != started) return Outcome.DONE
+            if (stopped()) return Outcome.RETRY
+            local(context, address)?.let {
+                deliver(context, address, started, CraftNativeCapabilityResult(data = describe(address, it)))
+                return Outcome.DONE
+            }
             val target = file(context, address)
             val staging = part(context, address)
             target.parentFile?.mkdirs()
@@ -1350,22 +1383,22 @@ internal object CraftNativeMedia {
                 }
                 if (full) {
                     staging.delete()
-                    deliver(address, CraftNativeCapabilityResult(code = "NO_SPACE", message = error.message ?: "The phone is out of space"))
+                    deliver(context, address, started, CraftNativeCapabilityResult(code = "NO_SPACE", message = error.message ?: "The phone is out of space"))
                     return Outcome.DONE
                 }
                 if (stopped()) return Outcome.RETRY
                 // Lost the connection part way: the part waits for the next attempt.
-                deliver(address, if (!online(context)) queued(address, "offline") else CraftNativeCapabilityResult(code = if (error is java.net.SocketTimeoutException) "TIMEOUT" else "NETWORK_ERROR", message = error.message ?: "media.keep failed"))
+                deliver(context, address, started, if (!online(context)) queued(address, "offline") else CraftNativeCapabilityResult(code = if (error is java.net.SocketTimeoutException) "TIMEOUT" else "NETWORK_ERROR", message = error.message ?: "media.keep failed"))
                 return if (attempt < 8) Outcome.RETRY else Outcome.DONE.also { staging.delete() }
             }
             when (fetched) {
                 is CraftResumableDownload.Fetched.Stopped, is CraftResumableDownload.Fetched.Restart -> return Outcome.RETRY
                 is CraftResumableDownload.Fetched.Refused -> {
-                    deliver(address, CraftNativeCapabilityResult(data = JSONObject().put("ok", false).put("url", address).put("status", fetched.status)))
+                    deliver(context, address, started, CraftNativeCapabilityResult(data = JSONObject().put("ok", false).put("url", address).put("status", fetched.status)))
                     return Outcome.DONE
                 }
                 is CraftResumableDownload.Fetched.Incomplete -> {
-                    deliver(address, CraftNativeCapabilityResult(code = "NETWORK_ERROR", message = "media.keep received an incomplete file"))
+                    deliver(context, address, started, CraftNativeCapabilityResult(code = "NETWORK_ERROR", message = "media.keep received an incomplete file"))
                     return if (attempt < 8) Outcome.RETRY else Outcome.DONE.also { staging.delete() }
                 }
                 is CraftResumableDownload.Fetched.Complete -> Unit
@@ -1373,16 +1406,15 @@ internal object CraftNativeMedia {
             synchronized(lock) {
                 if (generation(context) != started) {
                     staging.delete()
-                    deliver(address, CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared"))
                     return Outcome.DONE
                 }
                 target.delete()
                 if (!staging.renameTo(target)) {
-                    deliver(address, CraftNativeCapabilityResult(code = "IO_ERROR", message = "media.keep could not store the file"))
+                    deliver(context, address, started, CraftNativeCapabilityResult(code = "IO_ERROR", message = "media.keep could not store the file"))
                     return Outcome.DONE
                 }
             }
-            deliver(address, CraftNativeCapabilityResult(data = describe(address, target)))
+            deliver(context, address, started, CraftNativeCapabilityResult(data = describe(address, target)))
             return Outcome.DONE
         }
     }
@@ -1441,7 +1473,7 @@ internal object CraftNativeMedia {
             callbacks
         }
         androidx.work.WorkManager.getInstance(context.applicationContext).cancelAllWorkByTag(TAG)
-        main.post { answered.forEach { it(CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared")) } }
+        main.post { answered.forEach { it.answer(CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared")) } }
         failure?.let { throw it }
         return removed
     }

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

@@ -2557,7 +2557,6 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
     val content = CraftNativeFlexLayout(context)
     private val blocker = View(context)
     private var renderedVisible = false
-    private var dismissSuppressedByRequest = false
     private var animationGeneration = 0
     var focusToRestore: View? = null
     var onRequestClose: ((String) -> Unit)? = null
@@ -2582,22 +2581,11 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
 
     fun requestClose(reason: String = "backdrop") {
         val handler = onRequestClose ?: return
-        dismissSuppressedByRequest = true
         isClickable = false
         blocker.isEnabled = false
         handler(reason)
     }
 
-    fun consumeDismissSuppression(): Boolean {
-        val suppressed = dismissSuppressedByRequest
-        dismissSuppressedByRequest = false
-        return suppressed
-    }
-
-    fun clearDismissSuppression() {
-        dismissSuppressedByRequest = false
-    }
-
     fun setVisible(visible: Boolean, opacity: Float, animationType: String?) {
         if (visible) {
             isClickable = true
@@ -2656,7 +2644,6 @@ private class CraftNativeModalView(context: Context) : FrameLayout(context) {
         alpha = 0f
         isClickable = true
         blocker.isEnabled = true
-        dismissSuppressedByRequest = false
         onRequestClose = null
     }
 }
@@ -5410,15 +5397,13 @@ class MainActivity : AppCompatActivity() {
                         if (restore.isAttachedToWindow) restore.requestFocus()
                     }
                 }
-                if (visible) clearDismissSuppression()
-                val suppressDismiss = !visible && consumeDismissSuppression()
                 if (wasVisible != visible && (visible || wasVisible == true)) {
                     val lifecycleHandler = if (visible) {
                         craftNativeOptionalString(events.opt("onShow"))
                     } else {
                         craftNativeOptionalString(events.opt("onDismiss"))
                     }
-                    if (!lifecycleHandler.isNullOrBlank() && !suppressDismiss) {
+                    if (!lifecycleHandler.isNullOrBlank()) {
                         // Deliver lifecycle callbacks after reconciliation returns to
                         // the queue; the handler may immediately schedule another
                         // render against this native view.

package/dist/cli.js

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

package/dist/index.cjs

@@ -373,7 +373,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.249";
+var version = "0.0.251";
 
 // 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.249";
+var version = "0.0.251";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftNativeScreen.swift

@@ -3788,7 +3788,6 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
     private let blocker = UIView()
     private let backdropTap = UITapGestureRecognizer()
     private var renderedVisible = false
-    private var dismissSuppressedByRequest = false
     private var animationGeneration = 0
     var onRequestClose: ((String) -> Void)?
 
@@ -3877,25 +3876,15 @@ private final class CraftNativeModalView: UIView, UIGestureRecognizerDelegate {
         transform = .identity
         alpha = 0
         isUserInteractionEnabled = true
-        dismissSuppressedByRequest = false
         onRequestClose = nil
     }
 
     func requestClose(reason: String = "backdrop") {
         guard let onRequestClose else { return }
-        dismissSuppressedByRequest = true
         isUserInteractionEnabled = false
         onRequestClose(reason)
     }
 
-    func consumeDismissSuppression() -> Bool {
-        let suppressed = dismissSuppressedByRequest
-        dismissSuppressedByRequest = false
-        return suppressed
-    }
-
-    func clearDismissSuppression() { dismissSuppressedByRequest = false }
-
     @objc private func backdropTapped() { requestClose(reason: "backdrop") }
 
     func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
@@ -3993,9 +3982,10 @@ private final class CraftNativeScrollView: UIScrollView, UIGestureRecognizerDele
     required init?(coder: NSCoder) { nil }
 
     override func touchesShouldCancel(in view: UIView) -> Bool {
-        // A drag beginning on a button scrolls; lifting without dragging
-        // remains a tap. Sliders, switches and text fields keep tracking.
-        if view is UIButton { return true }
+        // Buttons and text fields yield once a scroll drag begins; an
+        // ordinary tap still reaches them immediately. Value controls such
+        // as sliders, switches and date pickers keep their tracking gesture.
+        if view is UIButton || view is UITextField { return true }
         if view is UIControl { return false }
         return super.touchesShouldCancel(in: view)
     }
@@ -7366,11 +7356,9 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
             modal.onRequestClose = nonEmptyHandler(events["onRequestClose"]).map { handler in
                 { [weak self] reason in self?.send(type: "EVENT", payload: ["handlerName": handler, "nativeEvent": ["reason": reason]]) }
             }
-            if visible { modal.clearDismissSuppression() }
-            let suppressDismiss = !visible && modal.consumeDismissSuppression()
             if wasVisible != visible, visible || wasVisible == true {
                 let lifecycleHandler = visible ? events["onShow"] : events["onDismiss"]
-                if let lifecycleHandler = nonEmptyHandler(lifecycleHandler), !suppressDismiss {
+                if let lifecycleHandler = nonEmptyHandler(lifecycleHandler) {
                     send(type: "EVENT", payload: ["handlerName": lifecycleHandler, "nativeEvent": [:]])
                 }
             }
@@ -7448,10 +7436,10 @@ final class CraftNativeScreenController: UIViewController, UIScrollViewDelegate,
                 // already-stopped view changes hidesWhenStopped to false.
                 // Android applies the requested visibility on every render;
                 // keep the two hosts in lockstep for dynamic prop changes.
-                indicator.isHidden = indicator.hidesWhenStopped
+                indicator.isHidden = style["display"] as? String == "none" || indicator.hidesWhenStopped
             } else {
                 indicator.startAnimating()
-                indicator.isHidden = false
+                indicator.isHidden = style["display"] as? String == "none"
             }
         case "Svg":
             let drawing = result as! CraftNativeSvgView

package/dist/ios/templates/CraftNativeServices.swift

@@ -690,8 +690,15 @@ enum CraftNativePush {
 
 // MARK: - Share sheet
 
-/// A URL stays a URL in Messages, AirDrop and Copy. Its title belongs in the
+/// A URL stays a URL in Messages and AirDrop. Its title belongs in the
 /// system preview and mail subject, rather than becoming a second text item.
+///
+/// Copy is the exception: it writes the address as text. A URL-only
+/// pasteboard item has no textual representation, so `UIPasteboard.string`
+/// is nil, a web page's `navigator.clipboard.readText()` gets nothing, and
+/// so does the simulator's `pbpaste` - the shared link copied as nothing
+/// anywhere text is read. Text that is an address is still detected as a
+/// link wherever it is pasted.
 final class CraftShareLink: NSObject, UIActivityItemSource {
     let url: URL
     let title: String
@@ -703,7 +710,9 @@ final class CraftShareLink: NSObject, UIActivityItemSource {
 
     func activityViewControllerPlaceholderItem(_ activityViewController: UIActivityViewController) -> Any { url }
 
-    func activityViewController(_ activityViewController: UIActivityViewController, itemForActivityType activityType: UIActivity.ActivityType?) -> Any? { url }
+    func activityViewController(_ activityViewController: UIActivityViewController, itemForActivityType activityType: UIActivity.ActivityType?) -> Any? {
+        activityType == .copyToPasteboard ? url.absoluteString : url
+    }
 
     func activityViewController(_ activityViewController: UIActivityViewController, subjectForActivityType activityType: UIActivity.ActivityType?) -> String { title }
 

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -139,6 +139,57 @@ final class DriverTests: XCTestCase {
         return nil
     }
 
+    /// About a third of a screen of scrolling, as a held drag.
+    ///
+    /// `app.swipeUp()` is a flick, and how far a flick throws a scroll view
+    /// depends on how its touches arrive: on a loaded machine, with a map
+    /// keeping the app busy, eight of them moved a trail page less than one
+    /// screen. A drag that stops before it lifts moves the content by its
+    /// own length every time. It runs between the middle of the screen and
+    /// the upper part, where a flick began too, so it stays off the keys when
+    /// a keyboard is up - an iOS 27 simulator reports its keyboard's frame
+    /// below the screen while drawing it over the lower half - and it stops
+    /// short of a keyboard whose frame is known.
+    func scrollPage(towardTop: Bool) {
+        let frame = app.frame
+        var lower = frame.minY + frame.height * 0.55
+        let keyboard = app.keyboards.firstMatch
+        if keyboard.exists, !keyboard.frame.isEmpty, keyboard.frame.minY < frame.maxY {
+            lower = min(lower, keyboard.frame.minY - 24)
+        }
+        let upper = max(frame.minY + frame.height * 0.15, lower - frame.height * 0.4)
+        let point = { (y: CGFloat) in self.app.coordinate(withNormalizedOffset: .zero).withOffset(CGVector(dx: frame.midX, dy: y)) }
+        let (from, to) = towardTop ? (point(upper), point(lower)) : (point(lower), point(upper))
+        from.press(forDuration: 0.05, thenDragTo: to, withVelocity: .default, thenHoldForDuration: 0.2)
+    }
+
+    /// Whether `target`, or a field inside it, holds the keyboard.
+    func hasKeyboardFocus(_ target: XCUIElement) -> Bool {
+        if (target.value(forKey: "hasKeyboardFocus") as? Bool) == true { return true }
+        return target.descendants(matching: .any).matching(NSPredicate(format: "hasKeyboardFocus == 1")).firstMatch.exists
+    }
+
+    /// Taps `target` until it holds the keyboard, for up to `seconds`.
+    ///
+    /// A tap is not focus. The first keyboard a freshly created simulator
+    /// shows takes its keyboard process many seconds to start - one CI run
+    /// spent 20s delivering the tap - and the field had not become first
+    /// responder when the text was typed, which failed with "Neither element
+    /// nor any descendant has keyboard focus". A later tap lands once the app
+    /// is idle again.
+    func focus(_ target: XCUIElement, seconds: Double = 15) -> Bool {
+        let end = Date().addingTimeInterval(seconds)
+        repeat {
+            target.tap()
+            let settle = Date().addingTimeInterval(3)
+            repeat {
+                if hasKeyboardFocus(target) { return true }
+                Thread.sleep(forTimeInterval: 0.25)
+            } while Date() < settle
+        } while Date() < end
+        return hasKeyboardFocus(target)
+    }
+
     func waitFor(_ text: String, _ seconds: Double) -> XCUIElement? {
         poll(seconds) { element(containing: text) }
     }
@@ -375,8 +426,10 @@ final class DriverTests: XCTestCase {
             let idParts = arg.split(separator: " ", maxSplits: 1).map(String.init)
             let target = identified(idParts[0])
             if target.waitForExistence(timeout: 10) {
-                target.tap()
-                Thread.sleep(forTimeInterval: 0.8)
+                guard focus(target) else {
+                    check(false, "typeid \(idParts[0]) takes keyboard focus")
+                    return
+                }
                 app.typeText(idParts.count > 1 ? idParts[1] : "")
                 note("typeid \(idParts[0]): ok")
             } else { XCTFail("Element not found"); note("FAIL typeid \(idParts[0]): NOT FOUND") }
@@ -402,8 +455,10 @@ final class DriverTests: XCTestCase {
             let index = Int(fieldParts[0]) ?? 0
             let fields = app.textFields.allElementsBoundByIndex + app.secureTextFields.allElementsBoundByIndex
             if index >= 0 && index < fields.count {
-                fields[index].tap()
-                Thread.sleep(forTimeInterval: 0.6)
+                guard focus(fields[index]) else {
+                    check(false, "field \(index) takes keyboard focus")
+                    return
+                }
                 app.typeText(fieldParts.count > 1 ? fieldParts[1] : "")
                 note("field \(index): ok")
             } else { XCTFail("Element not found"); note("FAIL field \(index): NOT FOUND (\(fields.count) fields)") }
@@ -447,14 +502,11 @@ final class DriverTests: XCTestCase {
             else { XCTFail("Element not found"); note("FAIL tab \(arg): NOT FOUND") }
         case "scrollto":
             var found = element(containing: arg)
-            var swipes = 0
-            while (found == nil || !(found!.isHittable)) && swipes < 8 {
-                if let target = found, !target.frame.isEmpty, target.frame.midY < app.frame.midY {
-                    app.swipeDown()
-                } else {
-                    app.swipeUp()
-                }
-                swipes += 1
+            var drags = 0
+            while (found == nil || !(found!.isHittable)) && drags < 12 {
+                let towardTop = found.map { !$0.frame.isEmpty && $0.frame.midY < app.frame.midY } ?? false
+                scrollPage(towardTop: towardTop)
+                drags += 1
                 found = element(containing: arg)
             }
             check(found != nil && found!.isHittable, "scrollto \(arg)")

package/dist/mobile-testing.js

@@ -55,6 +55,9 @@ async function verifyMobileMediaCache(options) {
   const bytes = new Uint8Array(await Bun.file(join(fixtures, "demo.mp4")).arrayBuffer());
   const counts = new Map;
   const resumed = new Set;
+  let lockedReleased = false;
+  let finishLocked;
+  let finishObsolete;
   const timers = new Set;
   const server = Bun.listen({
     hostname: "0.0.0.0",
@@ -73,6 +76,43 @@ async function verifyMobileMediaCache(options) {
         const path = socket.data.request.split(" ")[1];
         const n = (counts.get(path) || 0) + 1;
         counts.set(path, n);
+        if (path === "/android/inflight/slow.mp4" && n === 1) {
+          finishObsolete = () => socket.end(`HTTP/1.1 403 Forbidden\r
+Content-Length: 0\r
+Connection: close\r
+\r
+`);
+          return;
+        }
+        if (path === "/android/inflight/status") {
+          socket.end(`HTTP/1.1 200 OK\r
+Content-Length: 1\r
+Connection: close\r
+\r
+${finishObsolete ? "1" : "0"}`);
+          return;
+        }
+        if (path === "/android/inflight/release") {
+          finishObsolete?.();
+          finishObsolete = undefined;
+          socket.end(`HTTP/1.1 200 OK\r
+Content-Length: 0\r
+Connection: close\r
+\r
+`);
+          return;
+        }
+        if (path === "/android/locked/release") {
+          lockedReleased = true;
+          finishLocked?.();
+          finishLocked = undefined;
+          socket.end(`HTTP/1.1 200 OK\r
+Content-Length: 0\r
+Connection: close\r
+\r
+`);
+          return;
+        }
         const from = Number(/^range:\s*bytes=(\d+)-\s*$/im.exec(socket.data.request)?.[1] ?? Number.NaN);
         if (path === "/android/restart.mp4" && n > 1 && from > 0 && from < bytes.length) {
           resumed.add(path);
@@ -111,6 +151,13 @@ Connection: close\r
             socket.write(bytes.subarray(Math.floor(bytes.length / 2)));
           socket.end();
         };
+        if (path === "/android/locked/slow.mp4") {
+          if (lockedReleased)
+            finish();
+          else
+            finishLocked = finish;
+          return;
+        }
         if (slow) {
           const timer = setTimeout(() => {
             timers.delete(timer);
@@ -284,6 +331,16 @@ ${await Bun.file(join(fixtures, "media-cache.kt")).text()}`);
           throw new Error("Android did not resume the interrupted download from its part file");
         if (counts.get("/android/slow.mp4") !== 1)
           throw new Error("Android duplicate fetch: keep did not coalesce");
+        if (counts.get("/android/queued.mp4") !== 1)
+          throw new Error("Android queued work was replaced instead of joined");
+        if (counts.get("/android/locked/slow.mp4") !== 1)
+          throw new Error("Android waiting writer fetched an already completed video");
+        if (counts.get("/android/stale/slow.mp4") !== 1)
+          throw new Error("Android obsolete worker fetched across a cache generation");
+        if (counts.get("/android/inflight/slow.mp4") !== 2)
+          throw new Error("Android in-flight generations did not retain exactly their own transfers");
+        if (counts.get("/android/late-queued.mp4") !== 1)
+          throw new Error("Android kept obsolete queued work across a cache generation");
         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, resumed restart, retry, prune and cached video decode");

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

@@ -102,6 +102,89 @@ class DownloadProbe : android.app.Instrumentation() {
                     check(root.listFiles()?.none { it.name.endsWith(".part") && it.name != "${brokenTarget.name}.part" } != false, "a failed transfer leaves only its own part, to resume")
                     check(keep(broken), "same URL retries successfully, at once")
                     check(root.listFiles()?.none { it.name.endsWith(".part") } != false, "a finished transfer leaves no staging files")
+                    val queued = "$base/queued.mp4"
+                    val work = androidx.work.WorkManager.getInstance(targetContext)
+                    val queuedName = "craft-media:${CraftNativeMedia.digest(queued)}:any"
+                    val queuedRequest = androidx.work.OneTimeWorkRequestBuilder<CraftNativeMediaWorker>()
+                        .setInitialDelay(10, java.util.concurrent.TimeUnit.SECONDS)
+                        .setInputData(androidx.work.workDataOf("address" to queued, "headers" to "{}", "generation" to CraftNativeMedia.generation(targetContext)))
+                        .addTag("craft-media").addTag("craft-media:${CraftNativeMedia.digest(queued)}")
+                        .addTag("craft-media:generation:${CraftNativeMedia.generation(targetContext)}").build()
+                    work.enqueueUniqueWork(queuedName, androidx.work.ExistingWorkPolicy.KEEP, queuedRequest).result.get()
+                    val beforeJoin = work.getWorkInfoById(queuedRequest.id).get()!!
+                    check(beforeJoin.state == androidx.work.WorkInfo.State.ENQUEUED && beforeJoin.runAttemptCount == 0, "the coalescing regression starts with a fresh queued transfer")
+                    check(keep(queued), "keep joins the fresh queued transfer")
+                    val afterJoin = work.getWorkInfosForUniqueWork(queuedName).get()
+                    check(afterJoin.size == 1 && afterJoin.single().id == queuedRequest.id && afterJoin.single().state != androidx.work.WorkInfo.State.CANCELLED, "a second keep retains the original queued work identity")
+
+                    val locked = "$base/locked/slow.mp4"
+                    val started = CraftNativeMedia.generation(targetContext)
+                    var firstOutcome: CraftNativeMedia.Outcome? = null
+                    var secondOutcome: CraftNativeMedia.Outcome? = null
+                    val firstWriter = Thread { firstOutcome = CraftNativeMedia.transfer(targetContext, locked, JSONObject(), started, 0) { false } }
+                    val secondWriter = Thread { secondOutcome = CraftNativeMedia.transfer(targetContext, locked, JSONObject(), started, 0) { false } }
+                    firstWriter.start()
+                    val writingDeadline = System.currentTimeMillis() + 25000
+                    while (CraftNativeMedia.part(targetContext, locked).length() == 0L && System.currentTimeMillis() < writingDeadline) Thread.sleep(10)
+                    check(CraftNativeMedia.part(targetContext, locked).length() > 0L, "the first writer owns an active partial download")
+                    secondWriter.start()
+                    val blockedDeadline = System.currentTimeMillis() + 5000
+                    while (secondWriter.state != Thread.State.BLOCKED && secondWriter.isAlive && System.currentTimeMillis() < blockedDeadline) Thread.sleep(1)
+                    check(secondWriter.state == Thread.State.BLOCKED, "the second writer waits on the same address lock")
+                    java.net.URL("$base/locked/release").openConnection().getInputStream().use { it.readBytes() }
+                    firstWriter.join(25000)
+                    secondWriter.join(25000)
+                    check(!firstWriter.isAlive && !secondWriter.isAlive && firstOutcome == CraftNativeMedia.Outcome.DONE && secondOutcome == CraftNativeMedia.Outcome.DONE, "both address writers finish from the same cached copy")
+                    check(CraftNativeMedia.local(targetContext, locked) != null, "the coalesced writer leaves a complete local video")
+
+                    val stale = "$base/stale/slow.mp4"
+                    val staleGeneration = CraftNativeMedia.generation(targetContext)
+                    CraftNativeMedia.clear(targetContext)
+                    val currentDone = java.util.concurrent.CountDownLatch(1)
+                    var currentOK = false
+                    CraftNativeMedia.keep(targetContext, stale, JSONObject(), true) { currentOK = (it.data as? JSONObject)?.optBoolean("ok") == true; currentDone.countDown() }
+                    val currentDeadline = System.currentTimeMillis() + 25000
+                    while (CraftNativeMedia.part(targetContext, stale).length() == 0L && System.currentTimeMillis() < currentDeadline) Thread.sleep(10)
+                    check(CraftNativeMedia.part(targetContext, stale).length() > 0L, "the next generation has its own active transfer")
+                    check(CraftNativeMedia.transfer(targetContext, stale, JSONObject(), staleGeneration, 0) { false } == CraftNativeMedia.Outcome.DONE, "an obsolete worker exits without fetching")
+                    check(currentDone.await(25, java.util.concurrent.TimeUnit.SECONDS) && currentOK, "an obsolete worker cannot cancel the next generation's waiters")
+
+                    val inflight = "$base/inflight/slow.mp4"
+                    val inflightGeneration = CraftNativeMedia.generation(targetContext)
+                    var obsoleteOutcome: CraftNativeMedia.Outcome? = null
+                    val obsoleteWriter = Thread { obsoleteOutcome = CraftNativeMedia.transfer(targetContext, inflight, JSONObject(), inflightGeneration, 0) { false } }
+                    obsoleteWriter.start()
+                    fun oldRequestReachedServer() = java.net.URL("$base/inflight/status").readText() == "1"
+                    val inflightDeadline = System.currentTimeMillis() + 25000
+                    while (!oldRequestReachedServer() && System.currentTimeMillis() < inflightDeadline) Thread.sleep(10)
+                    check(oldRequestReachedServer(), "the obsolete generation is waiting for its HTTP response")
+                    CraftNativeMedia.clear(targetContext)
+                    val nextDone = java.util.concurrent.CountDownLatch(1)
+                    var nextOK = false
+                    CraftNativeMedia.keep(targetContext, inflight, JSONObject(), true) { nextOK = (it.data as? JSONObject)?.optBoolean("ok") == true; nextDone.countDown() }
+                    java.net.URL("$base/inflight/release").openConnection().getInputStream().use { it.readBytes() }
+                    obsoleteWriter.join(25000)
+                    check(!obsoleteWriter.isAlive && obsoleteOutcome == CraftNativeMedia.Outcome.DONE, "the old generation's delayed refusal finishes")
+                    check(nextDone.await(25, java.util.concurrent.TimeUnit.SECONDS) && nextOK, "an old in-flight refusal cannot consume the next generation's callback")
+
+                    val late = "$base/late-queued.mp4"
+                    val lateGeneration = CraftNativeMedia.generation(targetContext)
+                    CraftNativeMedia.clear(targetContext)
+                    val lateName = "craft-media:${CraftNativeMedia.digest(late)}:any"
+                    // Reproduce an obsolete scheduler enqueue landing after clear's cancellation.
+                    val lateRequest = androidx.work.OneTimeWorkRequestBuilder<CraftNativeMediaWorker>()
+                        .setInitialDelay(10, java.util.concurrent.TimeUnit.SECONDS)
+                        .setInputData(androidx.work.workDataOf("address" to late, "headers" to "{}", "generation" to lateGeneration))
+                        .addTag("craft-media").addTag("craft-media:${CraftNativeMedia.digest(late)}")
+                        .addTag("craft-media:generation:$lateGeneration").build()
+                    work.enqueueUniqueWork(lateName, androidx.work.ExistingWorkPolicy.KEEP, lateRequest).result.get()
+                    check(work.getWorkInfoById(lateRequest.id).get()!!.state == androidx.work.WorkInfo.State.ENQUEUED, "the obsolete queued request lands after clear")
+                    check(keep(late), "a new generation replaces obsolete queued work")
+                    val currentWork = work.getWorkInfosForUniqueWork(lateName).get()
+                    check(currentWork.size == 1 && currentWork.single().id != lateRequest.id &&
+                        "craft-media:generation:${CraftNativeMedia.generation(targetContext)}" in currentWork.single().tags &&
+                        currentWork.single().state != androidx.work.WorkInfo.State.CANCELLED,
+                        "obsolete queued work is replaced by a current-generation work identity")
                     check(!keep("$base/partial.mp4"), "unsolicited partial response is refused")
                     check(!keep("$base/empty.mp4"), "empty file is refused")
                     val slow = "$base/slow.mp4"

package/package.json

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