@keepsnappy/react-native 0.1.0-alpha.17 → 0.1.0-alpha.19

package/README.md

@@ -72,6 +72,7 @@ All values are read at **bundle time** (Expo CLI loads `.env*` into the Metro pr
 | `EXPO_PUBLIC_KEEPSNAPPY_SAMPLER` | `KEEPSNAPPY_SAMPLER` | `auto` / `manual` / `off` | Native resource sampler default. Unset: `auto` when `KEEPSNAPPY_AUTO=1`, else `off`. |
 | `EXPO_PUBLIC_KEEPSNAPPY_SAMPLER_MS` | `KEEPSNAPPY_SAMPLER_MS` | ms, 250–60000 | Auto sampling interval (default 4000; windows also get a sample at open and at close). |
 | `EXPO_PUBLIC_KEEPSNAPPY_PROFILE` | `KEEPSNAPPY_PROFILE` | `1` = on | Default of `profile`: per-component update causes per window (any renderer), plus self/total ms and updaters with the profiling renderer (`react.profile`). |
+| `EXPO_PUBLIC_KEEPSNAPPY_TAP_TEXT` | `KEEPSNAPPY_TAP_TEXT` | `0` = off, anything else = on (default) | Privacy switch for tap names. On: a tap with no `testID` and no `accessibilityLabel` falls back to the text under it (first 40 characters) in its legacy name. Off: that text is never read; the tap is named by its nearest named component, else `tag:<n>`. Place keys never contain text either way. Set `0` when screens show personal data in buttons. |
 | `EXPO_PUBLIC_KEEPSNAPPY_REACT_EXPORT` | `KEEPSNAPPY_REACT_EXPORT` | `1` = on | Default of `rexport`: a React DevTools v5 export per window (`Documents/keepsnappy/react-<process>-<window id>-<name>.json`, TraceSift's input). Inside a run (a run token is set) the files are held and written at `flush=1`; otherwise at window end. |
 | `EXPO_PUBLIC_KEEPSNAPPY_CPUPROF`, `..._CPUPROF_HZ` | `KEEPSNAPPY_CPUPROF` | `1` = on; Hz (default 250) | Default of `cpuprof`/`cpuhz`: Hermes sampling profiler (iOS), `Documents/keepsnappy/cpu-<process>-<span>.cpuprofile`. Inside a run it samples from the first window to `flush=1` and stops and dumps there, so the synchronous dump never lands in a measured window; otherwise one file per span of overlapping windows, dumped when the last one ends. `<process>` is the launch's `processId` (startup line), so launches never overwrite each other. |
 | `KEEPSNAPPY_REACT_PROFILING` (Metro process; also read by the config plugin) | | `1` / `switch` / unset | `1`: `withKeepSnappy` resolves RN's production renderer to `ReactFabric-profiling` (fiber durations, updaters), flag or not; for dedicated perf builds (docs/plans/37). `switch` (flag on only, ignored with the flag off): both Fabric renderers go into the bundle and each process loads one at launch (below). Unset: production renderer only. |

package/android/src/main/java/expo/modules/keepsnappy/KeepSnappyModule.kt

@@ -17,10 +17,12 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
 import android.widget.TextView
+import expo.modules.kotlin.Promise
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import java.io.File
 import java.io.FileOutputStream
+import java.io.InterruptedIOException
 import java.io.RandomAccessFile
 import java.net.HttpURLConnection
 import java.net.URL
@@ -29,6 +31,12 @@ import java.security.MessageDigest
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.Executors
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledThreadPoolExecutor
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
 import java.util.zip.GZIPOutputStream
 
 private const val TAG = "KEEPSNAPPY"
@@ -53,6 +61,11 @@ private const val SPOOL_READ_MAX = 16L * 1024 * 1024
 // The API parses at most 64 MiB of a raw profile file (MAX_RAW_BYTES in apps/api cpu-worker.ts).
 private const val ARTIFACT_MAX_BYTES = 64L * 1024 * 1024
 private const val COPY_BUFFER = 64 * 1024
+// Upload workers, one per SDK lane (ARTIFACT_UPLOAD_CONCURRENCY in js/sdk/artifacts.ts; test/artifacts.test.ts keeps
+// them equal). Expo runs every AsyncFunction of a module on one shared thread, which would PUT the lanes' files one
+// after the other.
+private const val ARTIFACT_UPLOAD_LANES = 8
+private const val POOL_IDLE_SECONDS = 30L
 
 // Files that lived in external storage before the move to filesDir.
 private val LEGACY_STATE_FILES = listOf("activation.json", "push-spool.jsonl")
@@ -60,7 +73,6 @@ private val LEGACY_STATE_FILES = listOf("activation.json", "push-spool.jsonl")
 // Created by Expo at app start whether or not the SDK measures: nothing here may
 // do work before a function is called (a dormant build calls activationRead only).
 // UNTESTED ON DEVICE (activation, spool): compiled only, like the sampler.
-// NOT YET COMPILED: moveLegacyState and the streamed uploadArtifact (night of 2026-10-14).
 class KeepSnappyModule : Module() {
   private val mainHandler = Handler(Looper.getMainLooper())
 
@@ -162,9 +174,27 @@ class KeepSnappyModule : Module() {
     samplerCreated = true
     KeepSnappySampler({ appContext.reactContext }, { appContext.currentActivity }, ::writeLog)
   }
-  private val io: ExecutorService by lazy {
-    Executors.newSingleThreadExecutor { r -> Thread(r, "keepsnappy-io") }
+  // The three pools below are created on first use and shut down in OnDestroy (a JS reload creates a new module); their
+  // idle threads also time out, so a pool used once does not keep a thread.
+  private val ioPool = lazy { Executors.newSingleThreadExecutor { r -> Thread(r, "keepsnappy-io") } }
+  private val io: ExecutorService get() = ioPool.value
+  private val uploadsPool = lazy {
+    ThreadPoolExecutor(
+      ARTIFACT_UPLOAD_LANES, ARTIFACT_UPLOAD_LANES, POOL_IDLE_SECONDS, TimeUnit.SECONDS, LinkedBlockingQueue<Runnable>(),
+    ) { r -> Thread(r, "keepsnappy-upload").apply { isDaemon = true } }.apply { allowCoreThreadTimeOut(true) }
   }
+  private val uploads: ExecutorService get() = uploadsPool.value
+  // Ends a PUT at its deadline: HttpURLConnection's timeouts bound one connect or read, not a write or the whole upload.
+  private val uploadTimerPool = lazy {
+    ScheduledThreadPoolExecutor(1) { r -> Thread(r, "keepsnappy-upload-timer").apply { isDaemon = true } }.apply {
+      setKeepAliveTime(POOL_IDLE_SECONDS, TimeUnit.SECONDS)
+      allowCoreThreadTimeOut(true)
+      removeOnCancelPolicy = true
+    }
+  }
+  private val uploadTimer: ScheduledExecutorService get() = uploadTimerPool.value
+  // Set once the module is destroyed: a worker still running then must not touch the (gone) JS context.
+  @Volatile private var destroyed = false
 
   // activation.json and the push journal (run tokens) live in internal storage: on Android 9
   // and older another app with storage permission could read or plant files in external storage.
@@ -231,7 +261,9 @@ class KeepSnappyModule : Module() {
   // sha256 of the gzip, PUT to the signed URL the API handed out. status 0: no HTTP answer.
   // The gzip is streamed to a temp file (hashed while written) and PUT from it, so neither
   // the file nor its gzip is held in memory; a file over the API's cap is not read at all.
+  // `timeoutMs` bounds gzip + PUT from here, whatever the call waited for a worker.
   private fun uploadArtifact(fileName: String, url: String, headers: Map<String, String>, timeoutMs: Double): Map<String, Any?> {
+    val deadline = SystemClock.elapsedRealtime() + timeoutMs.toLong()
     val context = appContext.reactContext
     val base = context?.getExternalFilesDir(null)
     val file = base?.let { File(File(it, "keepsnappy"), fileName.replace('/', '_')) }
@@ -259,25 +291,38 @@ class KeepSnappyModule : Module() {
       val sha = digest.digest().joinToString("") { "%02x".format(it) }
       val gzBytes = gzFile.length()
       val out = mutableMapOf<String, Any?>("bytes" to length.toInt(), "gzBytes" to gzBytes.toInt(), "sha256" to sha)
-      var connection: HttpURLConnection? = null
+      val left = deadline - SystemClock.elapsedRealtime()
+      if (left <= 0) {
+        out["status"] = 0
+        out["error"] = "timeout before the PUT"
+        return out
+      }
+      val connection = AtomicReference<HttpURLConnection?>(null)
+      val cut = uploadTimer.schedule({ connection.get()?.disconnect() }, left, TimeUnit.MILLISECONDS)
       try {
         val conn = URL(url).openConnection() as HttpURLConnection
-        connection = conn
+        connection.set(conn)
         conn.requestMethod = "PUT"
         conn.doOutput = true
-        conn.connectTimeout = timeoutMs.toInt()
-        conn.readTimeout = timeoutMs.toInt()
+        conn.connectTimeout = left.toInt()
+        conn.readTimeout = left.toInt()
         conn.setFixedLengthStreamingMode(gzBytes)
         for ((key, value) in headers) {
           conn.setRequestProperty(key, value)
         }
-        conn.outputStream.use { sink -> gzFile.inputStream().use { it.copyTo(sink, COPY_BUFFER) } }
+        conn.outputStream.use { sink ->
+          // disconnect() before the stream is open cuts nothing, so a deadline that passed while it opened is caught
+          // here; one that passes after this is a disconnect on an open stream, which fails the write.
+          if (cut.isDone) throw InterruptedIOException("deadline")
+          gzFile.inputStream().use { it.copyTo(sink, COPY_BUFFER) }
+        }
         out["status"] = conn.responseCode
       } catch (e: Exception) {
         out["status"] = 0
-        out["error"] = e.toString()
+        out["error"] = if (cut.isDone) "timeout after ${timeoutMs.toLong()} ms: $e" else e.toString()
       } finally {
-        connection?.disconnect()
+        cut.cancel(false)
+        connection.get()?.disconnect()
       }
       return out
     } finally {
@@ -356,8 +401,14 @@ class KeepSnappyModule : Module() {
     }
 
     OnDestroy {
+      destroyed = true
       if (samplerCreated) sampler.configure("off", 0.0)
       commandListen(false)
+      // Queued uploads are dropped; a PUT already running ends at its own deadline (the timer, shut down, still fires
+      // what it holds).
+      if (uploadsPool.isInitialized()) uploadsPool.value.shutdownNow()
+      if (uploadTimerPool.isInitialized()) uploadTimerPool.value.shutdown()
+      if (ioPool.isInitialized()) ioPool.value.shutdown()
     }
 
     Function("commandListen") { on: Boolean ->
@@ -466,9 +517,25 @@ class KeepSnappyModule : Module() {
       )
     }
 
-    // Called at flush only, never inside a measured window; runs off the JS thread.
-    AsyncFunction("artifactUpload") { fileName: String, url: String, headers: Map<String, String>, timeoutMs: Double ->
-      uploadArtifact(fileName, url, headers, timeoutMs)
+    // Called at flush only, never inside a measured window; runs on the upload workers, off the JS thread and off
+    // Expo's shared AsyncFunction thread.
+    AsyncFunction("artifactUpload") { fileName: String, url: String, headers: Map<String, String>, timeoutMs: Double, promise: Promise ->
+      uploads.execute {
+        if (destroyed) return@execute
+        val result = try {
+          uploadArtifact(fileName, url, headers, timeoutMs)
+        } catch (e: Throwable) {
+          mapOf("status" to 0, "error" to e.toString())
+        }
+        // A reload mid-flush destroys the module while this worker runs: its JS context is gone, nothing waits for it.
+        // UNTESTED ON DEVICE: compiled only; a reload during a flush needs a device run.
+        if (destroyed) return@execute
+        try {
+          promise.resolve(result)
+        } catch (e: Throwable) {
+          Log.w(TAG, "artifactUpload: no one to answer: $e")
+        }
+      }
     }
 
     // getExternalFilesDir needs no permission and `adb pull` reads it from a

package/ios/KeepSnappyGzip.swift

@@ -0,0 +1,91 @@
+import Compression
+import CryptoKit
+import Foundation
+
+// Gzip (RFC 1952) of a file streamed into another, so neither the file nor its gzip is held in memory: one chunk at a
+// time, whatever the file's size. The Compression framework's zlib codec writes raw DEFLATE (RFC 1951); the header and trailer are added
+// here.
+enum KeepSnappyGzip {
+  struct Result {
+    let bytes: Int
+    let gzBytes: Int
+    // Of the gzip as written.
+    let sha256: String
+  }
+
+  private static let chunk = 64 * 1024
+
+  // nil: the file could not be read, compressed or written.
+  static func file(_ source: URL, to target: URL) -> Result? {
+    guard let input = InputStream(url: source) else { return nil }
+    guard FileManager.default.createFile(atPath: target.path, contents: nil),
+          let output = try? FileHandle(forWritingTo: target) else { return nil }
+    defer { try? output.close() }
+    input.open()
+    defer { input.close() }
+
+    var hasher = SHA256()
+    var gzBytes = 0
+    var writeFailed = false
+    func write(_ data: Data) {
+      guard !writeFailed else { return }
+      do {
+        try output.write(contentsOf: data)
+        hasher.update(data: data)
+        gzBytes += data.count
+      } catch {
+        writeFailed = true
+      }
+    }
+
+    write(Data([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff]))
+    var crc: UInt32 = 0xFFFF_FFFF
+    var size = 0
+    do {
+      let filter = try OutputFilter(.compress, using: .zlib) { (deflated: Data?) in
+        if let deflated { write(deflated) }
+      }
+      var buffer = [UInt8](repeating: 0, count: chunk)
+      while true {
+        let n = input.read(&buffer, maxLength: buffer.count)
+        if n < 0 { return nil }
+        if n == 0 { break }
+        let data = Data(buffer[0..<n])
+        crc = crc32Update(crc, data)
+        size += n
+        try filter.write(data)
+      }
+      try filter.finalize()
+    } catch {
+      return nil
+    }
+    var crcOut = (crc ^ 0xFFFF_FFFF).littleEndian
+    var sizeOut = UInt32(truncatingIfNeeded: size).littleEndian
+    var trailer = Data()
+    withUnsafeBytes(of: &crcOut) { trailer.append(contentsOf: $0) }
+    withUnsafeBytes(of: &sizeOut) { trailer.append(contentsOf: $0) }
+    write(trailer)
+    if writeFailed { return nil }
+    let sha = hasher.finalize().map { String(format: "%02x", $0) }.joined()
+    return Result(bytes: size, gzBytes: gzBytes, sha256: sha)
+  }
+
+  private static let crcTable: [UInt32] = (0..<256).map { n -> UInt32 in
+    var c = UInt32(n)
+    for _ in 0..<8 {
+      c = (c & 1) != 0 ? 0xEDB8_8320 ^ (c >> 1) : c >> 1
+    }
+    return c
+  }
+
+  // CRC-32 (IEEE) running state: start at 0xFFFFFFFF, xor the end with 0xFFFFFFFF.
+  private static func crc32Update(_ start: UInt32, _ data: Data) -> UInt32 {
+    var c = start
+    data.withUnsafeBytes { (buffer: UnsafeRawBufferPointer) in
+      for byte in buffer {
+        c = crcTable[Int((c ^ UInt32(byte)) & 0xFF)] ^ (c >> 8)
+      }
+    }
+    return c
+  }
+}

package/ios/KeepSnappyModule.swift

@@ -1,4 +1,3 @@
-import CryptoKit
 import ExpoModulesCore
 import Foundation
 import UIKit
@@ -224,46 +223,12 @@ public class KeepSnappyModule: Module {
 
     // A raw profile file of a run (plan 40 §3.6): gzip, sha256 of the gzip, PUT to the
     // signed URL the API handed out. Called at flush only, never inside a measured window.
-    // status 0: no HTTP answer (missing file, network error, timeout).
-    // The file is memory-mapped (clean pages, not app memory) and checked against the API's cap
-    // before it is read; only the gzip is built in memory.
-    // NOT YET COMPILED: the size check and the mapped read (night of 2026-10-14).
+    // status 0: no HTTP answer (missing file, network error, timeout). Runs on the upload
+    // workers: Expo runs a module's AsyncFunctions on one serial queue.
     AsyncFunction("artifactUpload") { (fileName: String, url: String, headers: [String: String], timeoutMs: Double, promise: Promise) in
-      guard let file = Self.fileIfPresent(fileName.replacingOccurrences(of: "/", with: "_")) else {
-        promise.resolve(["status": 0, "error": "file missing"])
-        return
+      Self.uploadQueue.addOperation {
+        promise.resolve(Self.uploadArtifact(fileName: fileName, url: url, headers: headers, timeoutMs: timeoutMs))
       }
-      let size = ((try? FileManager.default.attributesOfItem(atPath: file.path))?[.size] as? NSNumber)?.int64Value ?? 0
-      if size > Self.artifactMaxBytes {
-        promise.resolve(["status": 413, "error": "file is \(size) bytes, over \(Self.artifactMaxBytes)"])
-        return
-      }
-      guard let raw = try? Data(contentsOf: file, options: .alwaysMapped) else {
-        promise.resolve(["status": 0, "error": "file missing"])
-        return
-      }
-      guard let target = URL(string: url), let gz = Self.gzip(raw) else {
-        promise.resolve(["status": 0, "bytes": raw.count, "error": "gzip or url failed"])
-        return
-      }
-      let sha = SHA256.hash(data: gz).map { String(format: "%02x", $0) }.joined()
-      var request = URLRequest(url: target, timeoutInterval: max(1, timeoutMs / 1000))
-      request.httpMethod = "PUT"
-      for (key, value) in headers {
-        request.setValue(value, forHTTPHeaderField: key)
-      }
-      URLSession.shared.uploadTask(with: request, from: gz) { _, response, error in
-        var out: [String: Any] = [
-          "status": (response as? HTTPURLResponse)?.statusCode ?? 0,
-          "bytes": raw.count,
-          "gzBytes": gz.count,
-          "sha256": sha,
-        ]
-        if let error {
-          out["error"] = error.localizedDescription
-        }
-        promise.resolve(out)
-      }.resume()
     }
 
     Function("cpuProfileDump") { (fileName: String) -> [String: Any]? in
@@ -281,6 +246,76 @@ public class KeepSnappyModule: Module {
   // The API parses at most 64 MiB of a raw profile file (MAX_RAW_BYTES in apps/api cpu-worker.ts).
   private static let artifactMaxBytes: Int64 = 64 * 1024 * 1024
 
+  // Upload workers, one per SDK lane (ARTIFACT_UPLOAD_CONCURRENCY in js/sdk/artifacts.ts; test/artifacts.test.ts keeps
+  // them equal). A worker holds its file until the PUT is answered.
+  private static let artifactUploadLanes = 8
+  // Static lets: initialised once, safely from any thread.
+  private static let uploadQueue: OperationQueue = {
+    let queue = OperationQueue()
+    queue.name = "com.gigaverse.keepsnappy.upload"
+    queue.maxConcurrentOperationCount = KeepSnappyModule.artifactUploadLanes
+    queue.qualityOfService = .utility
+    return queue
+  }()
+  private static let uploadSession: URLSession = {
+    let config = URLSessionConfiguration.default
+    config.httpMaximumConnectionsPerHost = KeepSnappyModule.artifactUploadLanes
+    return URLSession(configuration: config)
+  }()
+
+  // The gzip is streamed to a temp file (hashed while written) and PUT from it, so neither the file
+  // nor its gzip is held in memory; a file over the API's cap is not read at all. `timeoutMs`
+  // bounds gzip + PUT from here, whatever the call waited for a worker.
+  private static func uploadArtifact(fileName: String, url: String, headers: [String: String], timeoutMs: Double) -> [String: Any] {
+    let deadline = DispatchTime.now() + .milliseconds(Int(max(0, timeoutMs)))
+    guard let file = fileIfPresent(fileName.replacingOccurrences(of: "/", with: "_")) else {
+      return ["status": 0, "error": "file missing"]
+    }
+    let size = ((try? FileManager.default.attributesOfItem(atPath: file.path))?[.size] as? NSNumber)?.int64Value ?? 0
+    if size > Self.artifactMaxBytes {
+      return ["status": 413, "error": "file is \(size) bytes, over \(Self.artifactMaxBytes)"]
+    }
+    guard let target = URL(string: url) else {
+      return ["status": 0, "bytes": Int(size), "error": "bad url"]
+    }
+    let gzFile = FileManager.default.temporaryDirectory.appendingPathComponent("keepsnappy-upload-\(UUID().uuidString).gz")
+    defer { try? FileManager.default.removeItem(at: gzFile) }
+    guard let gz = KeepSnappyGzip.file(file, to: gzFile) else {
+      return ["status": 0, "bytes": Int(size), "error": "gzip failed"]
+    }
+    var out: [String: Any] = ["status": 0, "bytes": gz.bytes, "gzBytes": gz.gzBytes, "sha256": gz.sha256]
+    let leftNs = Int64(deadline.uptimeNanoseconds) - Int64(DispatchTime.now().uptimeNanoseconds)
+    if leftNs <= 0 {
+      out["error"] = "timeout before the PUT"
+      return out
+    }
+    var request = URLRequest(url: target, timeoutInterval: max(1, Double(leftNs) / 1e9))
+    request.httpMethod = "PUT"
+    for (key, value) in headers {
+      request.setValue(value, forHTTPHeaderField: key)
+    }
+    let answered = DispatchSemaphore(value: 0)
+    var status = 0
+    var failure: String?
+    let task = uploadSession.uploadTask(with: request, fromFile: gzFile) { _, response, error in
+      status = (response as? HTTPURLResponse)?.statusCode ?? 0
+      failure = error?.localizedDescription
+      answered.signal()
+    }
+    task.resume()
+    // URLRequest's timeout is between two packets; the whole PUT ends at the deadline.
+    if answered.wait(timeout: deadline) == .timedOut {
+      task.cancel()
+      answered.wait()
+      failure = "timeout after \(Int(timeoutMs)) ms: \(failure ?? "cancelled")"
+    }
+    out["status"] = status
+    if let failure {
+      out["error"] = failure
+    }
+    return out
+  }
+
   private static func outputDir() -> URL? {
     guard let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else { return nil }
     let dir = docs.appendingPathComponent("keepsnappy", isDirectory: true)
@@ -288,36 +323,6 @@ public class KeepSnappyModule: Module {
     return dir
   }
 
-  // RFC 1952 around Foundation's zlib codec, which writes raw DEFLATE (RFC 1951).
-  private static func gzip(_ data: Data) -> Data? {
-    guard let deflated = try? (data as NSData).compressed(using: .zlib) as Data else { return nil }
-    var out = Data([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff])
-    out.append(deflated)
-    var crc = crc32(data).littleEndian
-    var size = UInt32(truncatingIfNeeded: data.count).littleEndian
-    withUnsafeBytes(of: &crc) { out.append(contentsOf: $0) }
-    withUnsafeBytes(of: &size) { out.append(contentsOf: $0) }
-    return out
-  }
-
-  private static let crcTable: [UInt32] = (0..<256).map { n -> UInt32 in
-    var c = UInt32(n)
-    for _ in 0..<8 {
-      c = (c & 1) != 0 ? 0xEDB8_8320 ^ (c >> 1) : c >> 1
-    }
-    return c
-  }
-
-  private static func crc32(_ data: Data) -> UInt32 {
-    var c: UInt32 = 0xFFFF_FFFF
-    data.withUnsafeBytes { (buffer: UnsafeRawBufferPointer) in
-      for byte in buffer {
-        c = crcTable[Int((c ^ UInt32(byte)) & 0xFF)] ^ (c >> 8)
-      }
-    }
-    return c ^ 0xFFFF_FFFF
-  }
-
   private static let flushSignalTag = 0x9E7F_1A5
   private static let ackSignalTag = 0x9E7F_1A6
 

package/js/sdk/artifacts.ts

@@ -51,7 +51,18 @@ export const ARTIFACT_CALLS_PER_MINUTE = 200;
 export const ARTIFACT_UPLOAD_DEADLINE_MS =
   ((ARTIFACT_MAX_FILES_PER_RUN * ARTIFACT_CALLS_PER_FILE) / ARTIFACT_CALLS_PER_MINUTE) * 60_000;
 export const ARTIFACT_REQUEST_TIMEOUT_MS = 15_000;
+// Counted by native from the moment it starts on the file (gzip + PUT), not from the call: the call may wait in the
+// native upload pool first.
 export const ARTIFACT_PUT_TIMEOUT_MS = 60_000;
+// Native ends its own upload at the PUT timeout; the JS side gives up on the call this much later, so a native call
+// that hangs (or a worker that never answers) frees its lane instead of holding it to the flush deadline.
+export const ARTIFACT_NATIVE_CALL_MARGIN_MS = 10_000;
+// Files in flight at once (lanes). A file costs a lane three round trips (announce, PUT, complete with the API's inline
+// conclusion): 1.84 s on the farm, so four lanes took 73 s for 159 files while the API instance stayed under half a CPU
+// (on Android the PUTs also ran one at a time). Each native module uploads on a pool of this many workers (ARTIFACT_UPLOAD_LANES in KeepSnappyModule.kt,
+// artifactUploadLanes in KeepSnappyModule.swift; test/artifacts.test.ts keeps them equal). The API's per-run bucket
+// (ARTIFACT_CALLS_BURST in apps/api artifacts/service.ts) holds a whole run, so the lanes never wait on a 429.
+export const ARTIFACT_UPLOAD_CONCURRENCY = 8;
 // One deadline per flush, started at the flush link (core.ts flushOnce) and shared by the lines push, the clock
 // report and the artifact upload (this file's ARTIFACT_UPLOAD_DEADLINE_MS is that deadline). The end report gets its
 // own request timeout after it, so `keepsnappy.flushed` is raised at most ARTIFACT_FLUSH_WORST_CASE_MS after the link.
@@ -154,6 +165,7 @@ const withoutToken = (entry: ArtifactEntry): Omit<ArtifactEntry, 'runToken'> =>
 
 // Gzips the file (named as written by writeText / cpuProfileDump), hashes the
 // gzip, PUTs it. status 0: no HTTP answer (network, timeout, missing file).
+// `timeoutMs` bounds gzip + PUT from the moment native starts on the file.
 export interface ArtifactUploadNative {
   artifactUpload(
     fileName: string,
@@ -189,8 +201,10 @@ export interface ArtifactUploaderDeps {
   backoffBaseMs?: number;
   requestTimeoutMs?: number;
   putTimeoutMs?: number;
-  // Files in flight at once: the upload must finish inside the driver's wait for the
-  // flush signal, and one file after the other (about 0.85 s each) took 115 s for 135.
+  // How long past the PUT timeout the JS side still waits for the native call; default ARTIFACT_NATIVE_CALL_MARGIN_MS.
+  nativeMarginMs?: number;
+  // Files in flight at once; default ARTIFACT_UPLOAD_CONCURRENCY. The upload must finish inside the driver's wait
+  // for the flush signal.
   concurrency?: number;
   // The whole upload stops here; the rest stays on the device as `failed` and goes up
   // at the next flush. Default: the time the API's per-run budget needs for a full run.
@@ -291,8 +305,9 @@ export const createArtifactUploader = (deps: ArtifactUploaderDeps) => {
   const backoffBase = deps.backoffBaseMs ?? 1000;
   const requestTimeoutMs = deps.requestTimeoutMs ?? ARTIFACT_REQUEST_TIMEOUT_MS;
   const putTimeoutMs = deps.putTimeoutMs ?? ARTIFACT_PUT_TIMEOUT_MS;
+  const nativeMarginMs = deps.nativeMarginMs ?? ARTIFACT_NATIVE_CALL_MARGIN_MS;
   const deadlineMs = deps.deadlineMs ?? ARTIFACT_UPLOAD_DEADLINE_MS;
-  const concurrency = Math.max(1, deps.concurrency ?? 4);
+  const concurrency = Math.max(1, deps.concurrency ?? ARTIFACT_UPLOAD_CONCURRENCY);
 
   // Rejects after `ms`: a hard bound for work that may ignore its abort signal (a hung fetch, a native PUT).
   const timeoutAfter = (ms: number) => {
@@ -405,12 +420,15 @@ export const createArtifactUploader = (deps: ArtifactUploaderDeps) => {
     if (!native) {
       return { ok: false, retry: false, stop: 'native upload unavailable', state: 'local', error: 'native upload unavailable' };
     }
-    const budget = Math.min(putTimeoutMs, deadline - deps.now());
+    const left = deadline - deps.now();
+    const budget = Math.min(putTimeoutMs, left);
     if (budget <= 0) {
       return { ok: false, retry: false, stop: 'deadline', state: 'failed', error: 'put deadline' };
     }
     let result: Awaited<ReturnType<ArtifactUploadNative['artifactUpload']>>;
-    const hard = timeoutAfter(budget);
+    // Native ends its own upload `budget` after it starts on the file. The pool has a worker per lane, so a call
+    // rarely waits before that; the margin covers that wait and the gzip, and the flush deadline still bounds it.
+    const hard = timeoutAfter(Math.min(left, budget + nativeMarginMs));
     try {
       result = await Promise.race([
         native.artifactUpload(entry.name, signed.url as string, signed.headers, budget),

package/js/sdk/causes.ts

@@ -927,6 +927,8 @@ export const resetCausesForTest = () => {
   taskCauses = null;
   renderStarted = false;
   latestTouch = null;
+  latestAction = 0;
+  newestActionT = -Infinity;
   viewCause.clear();
   socketCause.clear();
 };

package/js/sdk/core.ts

@@ -970,6 +970,16 @@ const cutStream = () => {
   perfLog(`stream ${JSON.stringify({ name: segment.name, commits: segment.commits, bytes: segment.json.length, fibersDropped: segment.fibersDropped, written: path !== null })}`);
 };
 
+// What a test file leaves in the process-wide run: the open stream segment and the files listed for it, the answers of
+// GC commands, the GC that ran since the last flush, and the close sample the next window would take as its open one.
+export const resetRunStateForTest = () => {
+  cutStream();
+  pendingStreamFiles.length = 0;
+  commandAnswers.clear();
+  gcRanSinceFlush = false;
+  lastClose = null;
+};
+
 const endBackground = (reason: string) => {
   for (const record of [...unclaimed.splice(0), ...recentCommits]) {
     routeToBackground(record);

package/js/sdk/fiber.ts

@@ -450,6 +450,10 @@ const authoredId = (value: unknown): string | null => {
   return s !== null && !GENERATED_ID.test(s) ? s : null;
 };
 
+// EXPO_PUBLIC_KEEPSNAPPY_TAP_TEXT=0 keeps what a screen shows out of tap names: only testID, accessibilityLabel and
+// component names are used. Read per call so the bundle-time value is inlined at the read.
+const tapTextAllowed = () => (process.env.EXPO_PUBLIC_KEEPSNAPPY_TAP_TEXT) !== '0';
+
 const textUnder = (root: Fiber): string | null => {
   const parts: string[] = [];
   const stack: Fiber[] = [root];
@@ -503,7 +507,7 @@ export interface TargetDescription {
   place: TargetPlace;
 }
 
-// testID -> accessibilityLabel -> text -> nearest named component -> tag.
+// testID -> accessibilityLabel -> text (unless switched off) -> nearest named component -> tag.
 // testID/label are searched from the touched view up to the first named
 // component above the actionable (onPress/responder) fiber.
 const legacyTarget = (tag: number): Omit<TargetDescription, 'legacyName' | 'legacySource' | 'place'> => {
@@ -562,7 +566,7 @@ const legacyTarget = (tag: number): Omit<TargetDescription, 'legacyName' | 'lega
     result.name = result.accessibilityLabel;
     result.source = 'accessibilityLabel';
   } else {
-    const text = textUnder(actionable ?? host);
+    const text = tapTextAllowed() ? textUnder(actionable ?? host) : null;
     if (text) {
       result.name = text;
       result.source = 'text';

package/js/sdk/screens.ts

@@ -618,6 +618,10 @@ const onWindowsEnded = (reason: string) => {
   pendingLink = null;
 };
 
+export const resetCurrentScreenForTest = () => {
+  current = null;
+};
+
 export const resetLaunchForTest = () => {
   launchVisitOpened = false;
   windowsEndedSinceStart = false;

package/metro.js

@@ -172,7 +172,17 @@ const resolveEntry = projectRoot => {
       return base + ext;
     }
   }
-  return null;
+  // A package path such as Expo Router's `expo-router/entry`, which Metro resolves through node_modules. require.resolve
+  // answers a real path; the transformer compares it with Metro's file names, which keep the project root as given.
+  try {
+    const resolved = require.resolve(main, { paths: [projectRoot] });
+    const realRoot = fs.realpathSync(projectRoot);
+    return resolved.startsWith(realRoot + path.sep)
+      ? path.join(projectRoot, path.relative(realRoot, resolved))
+      : resolved;
+  } catch {
+    return null;
+  }
 };
 
 function withKeepSnappy(input, { clientPackages = [] } = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keepsnappy/react-native",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "description": "KeepSnappy in-app SDK for React Native / Expo: zero-code measurement windows, React commit hook, native signposts and log file",
   "license": "UNLICENSED",
   "repository": {