@keepsnappy/react-native 0.1.0-alpha.16 → 0.1.0-alpha.18

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/babel-transformer.js

@@ -68,20 +68,27 @@ module.exports = {
         : args.src;
       args = { ...args, src: inlineEnv(src) };
     }
+    const root = args.options?.projectRoot ?? projectRoot ?? process.cwd();
+    // A client file built without its stamps keys its components to an ancestor's: never silently.
+    const skipped = error => console.warn(`KeepSnappy: component stamps skipped for ${path.relative(root, file)}: ${String(error)}`);
     let stamps;
     try {
       stamps = require('./component-stamps.js').instrumentation(
-        original.src, file, args.options?.projectRoot ?? projectRoot ?? process.cwd(), clientPackages, file === entryFile ? 1 : 0,
+        original.src, file, root, clientPackages, file === entryFile ? 1 : 0,
       );
-    } catch { return upstream.transform(args); }
+    } catch (error) { skipped(error); return upstream.transform(args); }
     if (!stamps) return upstream.transform(args);
     const complete = result => { stamps.complete(); return result; };
-    const passthrough = () => { stamps.complete(true); return upstream.transform(args); };
+    const passthrough = error => {
+      skipped(error);
+      stamps.complete(true);
+      return upstream.transform(args);
+    };
     try {
       const result = upstream.transform({ ...args, plugins: [stamps.plugin, ...(args.plugins ?? [])] });
       return result && typeof result.then === 'function'
         ? result.then(complete, passthrough) : complete(result);
-    } catch { return passthrough(); }
+    } catch (error) { return passthrough(error); }
   },
   getCacheKey(...args) {
     const base =

package/js/component-stamps.js

@@ -119,6 +119,15 @@ const anonymousRender = (node, t) => {
     && !node.id && !node.async && !node.generator && returnsJSX(node.body, t);
 };
 
+// A plugin that ran first (React Compiler listed in the app's babel.config.js) may put back regenerated nodes without
+// `loc`; the line then comes from the declaration in the source.
+const declarationLine = (src, id, statement, lineOffset) => {
+  const line = id.loc?.start?.line ?? statement.loc?.start?.line;
+  if (typeof line === 'number') return Math.max(1, line - lineOffset);
+  const match = new RegExp(`^[ \\t]*(?:export[ \\t]+(?:default[ \\t]+)?)?(?:async[ \\t]+)?(?:function\\*?|class|const)[ \\t]+${id.name}\\b`, 'm').exec(src);
+  return match ? src.slice(0, match.index).split('\n').length : 1;
+};
+
 function instrumentation(src, filename, projectRoot, clientPackages, lineOffset = 0) {
   const client = clientFile(filename, projectRoot, clientPackages);
   if (!client) return null;
@@ -166,13 +175,19 @@ function instrumentation(src, filename, projectRoot, clientPackages, lineOffset
           const stamps = [];
           for (const id of found) {
             const componentName = id === defaultId ? 'default' : id.name;
-            const key = componentKey(componentName, client.file);
-            components.push({ key, name: componentName, file: client.file, line: Math.max(1, id.loc.start.line - lineOffset) });
-            const name = () => t.identifier(id.name);
-            const typeIs = value => t.binaryExpression('===', t.unaryExpression('typeof', name()), t.stringLiteral(value));
-            stamps.push(t.ifStatement(t.logicalExpression('||', typeIs('function'), t.logicalExpression('&&',
-              t.binaryExpression('!==', name(), t.nullLiteral()), typeIs('object'))),
-            t.expressionStatement(t.assignmentExpression('=', t.memberExpression(name(), t.identifier('__ks')), t.stringLiteral(key)))));
+            // One declaration that cannot be stamped must not cost the file its other stamps.
+            try {
+              const key = componentKey(componentName, client.file);
+              const line = declarationLine(src, id, statement.node, lineOffset);
+              const name = () => t.identifier(id.name);
+              const typeIs = value => t.binaryExpression('===', t.unaryExpression('typeof', name()), t.stringLiteral(value));
+              stamps.push(t.ifStatement(t.logicalExpression('||', typeIs('function'), t.logicalExpression('&&',
+                t.binaryExpression('!==', name(), t.nullLiteral()), typeIs('object'))),
+              t.expressionStatement(t.assignmentExpression('=', t.memberExpression(name(), t.identifier('__ks')), t.stringLiteral(key)))));
+              components.push({ key, name: componentName, file: client.file, line });
+            } catch (error) {
+              console.warn(`KeepSnappy: could not stamp ${componentName} in ${client.file}: ${String(error)}`);
+            }
           }
           if (stamps.length) statement.insertAfter(stamps);
         }

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

@@ -473,8 +473,10 @@ interface OpenSampleState {
 // - so does a window that starts within OPEN_SAMPLE_TOLERANCE_MS of the close sample (restarted key);
 // - a window detected long after its t0 (a screen window opened by a press, seen after the new screen rendered) gets
 //   none: its bound is the press's open sample;
-// - else the sampler is asked to sample on its own thread.
-const openSampleFor = (id: number, t0: number): OpenSampleState => {
+// - else the sampler is asked to sample on its own thread. A press always is, however late its touch reached JS: with
+//   no window before it (after a GC command, the background or the flush) the sample before the touch can be seconds
+//   old, so its own sample, a negative lead past t0, is the closer bound.
+const openSampleFor = (id: number, t0: number, press: boolean): OpenSampleState => {
   const none = { openRecord: null, openPending: null };
   if (samplerState.mode === 'off') {
     return none;
@@ -487,7 +489,7 @@ const openSampleFor = (id: number, t0: number): OpenSampleState => {
   ) {
     return { openRecord: lastClose.record, openPending: null };
   }
-  if (now() - samplerState.offsetMs - t0Native > OPEN_SAMPLE_TOLERANCE_MS) {
+  if (!press && now() - samplerState.offsetMs - t0Native > OPEN_SAMPLE_TOLERANCE_MS) {
     return none;
   }
   const reason = `window-start:${id}`;
@@ -938,7 +940,14 @@ const routeToBackground = (record: CommitRecord) => {
 
 // Segments written and not yet listed for upload (listed at the next flush).
 const pendingStreamFiles: WrittenFile[] = [];
-// A segment is cut at this many commits even between flushes, so a long stretch outside a run stays bounded.
+// What the run lost since the last flush, which reports it. Commit-stream segments that failed to write are missing data
+// (the backend splits work by cause from them). Kept React exports dropped at the run cap or not written, and stream fibers
+// past a segment's cap, leave every measured value complete: counted notes only.
+const runLosses = { stream: 0, exportsCapped: 0, exportsUnwritten: 0, streamFibersDropped: 0 };
+export const setStreamFiberCapForTest = (fibers: number) => commitStream.setMaxFibers(fibers);
+// A segment is cut at this many commits even between flushes, so a long stretch outside a run stays bounded. In a run
+// the cut waits while a window is open (no file I/O inside a measured window, REQ-MEAS-23): every window ends at the
+// flush, which cuts it, and a segment past its fiber cap keeps only the commits' facts.
 const MAX_SEGMENT_COMMITS = 5000;
 
 const cutStream = () => {
@@ -954,10 +963,23 @@ const cutStream = () => {
   }
   if (path) {
     pendingStreamFiles.push({ name: segment.name, windows: [], bytes: segment.json.length });
+  } else if (inRun()) {
+    runLosses.stream++;
   }
+  if (inRun()) runLosses.streamFibersDropped += segment.fibersDropped;
   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);
@@ -998,7 +1020,7 @@ const start = (name: string, options: StartOptions = {}) => {
   const statsStart = readHermesStats();
   const id = nextWindowId++;
   const startT = options.at ?? now();
-  const openSample = openSampleFor(id, startT);
+  const openSample = openSampleFor(id, startT, options.kind === 'press');
   const window: MarkerWindow = {
     id,
     key,
@@ -1301,7 +1323,7 @@ const onCommitFiberRoot = (rendererId: number, root: FiberRoot) => {
   // Work no open window judges is the background of its source: pushes, and loops of earlier actions or of the launch.
   record.background = record.judged ? null : backgroundSource(causes);
   commitStream.noteCommit({ seq, t: t0, renderMs, causes, fibers: exported?.fibers ?? null, updaters: profile?.updaters ?? null });
-  if (commitStream.size() >= MAX_SEGMENT_COMMITS) {
+  if (commitStream.size() >= MAX_SEGMENT_COMMITS && !(inRun() && openWindows.size > 0)) {
     cutStream();
   }
   recordCommit(record);
@@ -1525,7 +1547,12 @@ interface PendingExport {
 }
 
 // React exports held until flush (inside a run), capped like a window's.
-const MAX_PENDING_EXPORT_FIBERS = 400000;
+let maxPendingExportFibers = 400000;
+export const setPendingExportCapForTest = (fibers: number) => {
+  const previous = maxPendingExportFibers;
+  maxPendingExportFibers = fibers;
+  return previous;
+};
 const pendingExports: PendingExport[] = [];
 let pendingExportFibers = 0;
 
@@ -1546,7 +1573,8 @@ const writeReactExport = (window: MarkerWindow) => {
     truncated: window.exportTruncated,
   };
   if (inRun()) {
-    if (pendingExportFibers + window.exportFibers > MAX_PENDING_EXPORT_FIBERS) {
+    if (pendingExportFibers + window.exportFibers > maxPendingExportFibers) {
+      if (settings.diag || budgetBreaks.has(window.id)) runLosses.exportsCapped++;
       return { ...base, deferred: true, dropped: true };
     }
     pendingExports.push({
@@ -1623,6 +1651,7 @@ const writeDeferredFiles = (): ArtifactEntry[] => {
     } catch (error) {
       result = { error: String(error) };
     }
+    if (!result.path && (settings.diag || budgetBreaks.has(pending.window))) runLosses.exportsUnwritten++;
     perfLog(
       `rexport ${JSON.stringify({ name: pending.name, commits: pending.commits.length, fibers: pending.fibers, ...result })}`,
     );
@@ -2127,6 +2156,16 @@ const flushOnce = async (ack: string | undefined) => {
   } catch (error) {
     perfLog(`artifacts failed ${String(error)}`);
   }
+  if (runToken !== null) {
+    if (runLosses.stream > 0) {
+      if (status === 'ok') status = 'error';
+      detail += ` lost stream=${runLosses.stream}`;
+    }
+    if (runLosses.exportsCapped > 0) detail += ` exports capped=${runLosses.exportsCapped}`;
+    if (runLosses.exportsUnwritten > 0) detail += ` exports unwritten=${runLosses.exportsUnwritten}`;
+    if (runLosses.streamFibersDropped > 0) detail += ` stream fibersDropped=${runLosses.streamFibersDropped}`;
+  }
+  Object.assign(runLosses, { stream: 0, exportsCapped: 0, exportsUnwritten: 0, streamFibersDropped: 0 });
   try {
     await sendEarlierArtifacts(deadline);
   } catch (error) {

package/js/sdk/fiber.ts

@@ -230,9 +230,11 @@ export const noteMounted = (fiber: Fiber) => {
   const props = propsOf(fiber);
   if (props && props.route !== undefined) {
     noteRoute(fiber, props);
+    // React Navigation core's SceneView: the route's `screen` config and `clearOptions`. Expo Router 58's fork no
+    // longer passes `getState`, so that prop does not mark it. Headers and layouts get `route` without these.
     const route = props.route as { key?: unknown } | null;
     if (typeof route?.key === 'string' &&
-      typeof props.getState === 'function' &&
+      props.screen !== null && typeof props.screen === 'object' &&
       typeof props.clearOptions === 'function') {
       scenes.set(route.key, fiber);
     }
@@ -448,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];
@@ -501,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'> => {
@@ -560,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';
@@ -582,9 +588,11 @@ export interface TargetPlace {
   manySiblings?: number;
 }
 
+// A scroll view's own responder handlers (RN sets them on RCTScrollView) serve the scroll gesture, so a scroll view is
+// never the tap's region: the pressables inside it are.
 const actionableFiber = (f: Fiber) => {
   const props = propsOf(f);
-  return props !== null && isActionable(props);
+  return props !== null && isActionable(props) && !isScrollHost(f);
 };
 const isListCell = (f: Fiber) => {
   if (!isComponentTag(f.tag) || clientKeyOf(f) !== null) return false;
@@ -594,6 +602,69 @@ const isListCell = (f: Fiber) => {
     (typeof p.getRenderedItem === 'function' && 'itemKey' in p));
 };
 
+// React elements a component received in its props (children or any other prop), arrays included, by their props
+// object: the fiber React creates from an element keeps that object as its props.
+// Props objects do not change after their render, so the result is kept per object.
+const MAX_PASSED_ELEMENTS = 64;
+const NO_ELEMENTS: ReadonlySet<unknown> = new Set();
+const passedByProps = new WeakMap<object, ReadonlySet<unknown>>();
+const passedElementProps = (props: Props): ReadonlySet<unknown> => {
+  const known = passedByProps.get(props);
+  if (known) return known;
+  const found = new Set<unknown>();
+  try {
+    const stack: unknown[] = Object.values(props);
+    let seen = 0;
+    while (stack.length > 0 && seen++ < MAX_PASSED_ELEMENTS) {
+      const value = stack.pop();
+      if (Array.isArray(value)) {
+        stack.push(...value.slice(0, MAX_PASSED_ELEMENTS));
+      } else if (value !== null && typeof value === 'object' && '$$typeof' in value && 'props' in value) {
+        found.add((value as { props: unknown }).props);
+      }
+    }
+  } catch {
+    // A prop that throws on read (a revoked Proxy) carries no element we can match.
+  }
+  const result = found.size === 0 ? NO_ELEMENTS : found;
+  passedByProps.set(props, result);
+  return result;
+};
+
+// A client component between the target and the component that placed it passes the press through: it received a
+// press handler from its owner (a button wrapper forwarding `onPress`), or it renders an element it received in its
+// props around the target (a layout or animation wrapper given `children`). Neither tells two buttons apart.
+const passesThrough = (f: Fiber, path: readonly Fiber[]) => {
+  const props = propsOf(f);
+  if (!props) return false;
+  if (isActionable(props)) return true;
+  const passed = passedElementProps(props);
+  if (passed.size === 0) return false;
+  return path.some(p => passed.has(p.memoizedProps) || (p.alternate !== null && passed.has(p.alternate.memoizedProps)));
+};
+
+// The parent of a place: the first client component above the target that does not pass the press through, else the
+// nearest client component above it.
+const placeParentOf = (target: Fiber): Fiber | null => {
+  let nearest: Fiber | null = null;
+  const path: Fiber[] = [target];
+  for (let f = target.return, n = 0; f && n < MAX_UP * 2; f = f.return, n++) {
+    if (clientFiber(f)) {
+      nearest ??= f;
+      if (!passesThrough(f, path)) return f;
+    }
+    path.push(f);
+  }
+  return nearest;
+};
+
+// A client component that can pass a press through for something below it; any other client component is the
+// parent of every target under it.
+const mayPassThrough = (f: Fiber) => {
+  const props = propsOf(f);
+  return props !== null && (isActionable(props) || passedElementProps(props).size > 0);
+};
+
 const occurrenceOf = (
   parent: Fiber,
   target: Fiber,
@@ -611,13 +682,19 @@ const occurrenceOf = (
   const stack: { f: Fiber; inside: boolean }[] = root.child ? [{ f: root.child, inside: false }] : [];
   let count = 0;
   let index = 0;
+  const isParent = (f: Fiber | null) => f !== null && (f === root || f === root.alternate);
   while (stack.length && visited < 1000) {
     const { f, inside } = stack.pop()!;
     visited++;
     if (f.sibling) stack.push({ f: f.sibling, inside });
     if (isListCell(f)) continue;
     const client = clientFiber(f);
-    if (client && (inside || clientKeyOf(f) !== key)) continue;
+    if (client && inside) continue;
+    if (client && clientKeyOf(f) !== key) {
+      if (mayPassThrough(f) && f.child) stack.push({ f: f.child, inside: false });
+      continue;
+    }
+    if (client && !isParent(placeParentOf(f))) continue;
     const inTarget = inside || client;
     if (inTarget && ((scroll && client) || (!scroll && actionableFiber(f)))) {
       count++;
@@ -649,10 +726,7 @@ const placeOf = (host: Fiber | null, scroll: boolean, screen: ScreenKeyResolutio
     if (!scroll && actionableFiber(f)) region = f;
     if (clientFiber(f)) { target = f; break; }
   }
-  let parent: Fiber | null = null;
-  for (let f = target?.return ?? null, n = 0; f && n < MAX_UP * 2; f = f.return, n++) {
-    if (clientFiber(f)) { parent = f; break; }
-  }
+  const parent = target ? placeParentOf(target) : null;
   return {
     screen: screen.screen,
     parent: parent ? clientKeyOf(parent) : null,

package/js/sdk/interactions.ts

@@ -270,6 +270,19 @@ const finishPress = (press: ActivePress, reason: string, at?: number) => {
   }
 };
 
+// A drag is named after its scroll view (REQ-MEAS-10). Returns whether the gesture is a drag.
+const classify = (press: ActivePress) => {
+  const drag = press.maxMovePt >= DRAG_SLOP_PT || press.scrolled || press.takenByScroll;
+  press.kind = drag ? 'drag' : 'press';
+  if (drag) {
+    const axis = dragAxis(press);
+    const candidate = selectScrollHost(press.scrollHosts, axis);
+    press.container = candidate ? nameScrollContainer(candidate, press.screen) : null;
+    markers.rename(press.key, dragName(press), `drag:${press.container?.legacyName ?? press.target.legacyName}`);
+  }
+  return drag;
+};
+
 const onTouchStart = (ne: Record<string, unknown>) => {
   const touches = ne.touches;
   if (Array.isArray(touches) && touches.length > 1) {
@@ -326,6 +339,11 @@ const onTouchStart = (ne: Record<string, unknown>) => {
     legacyName: `press:${target.legacyName}`,
     at: touchStartT,
     details: details(press),
+    // A touch whose touchEnd never reached JS (its view unmounted, the app left the foreground) is classified by how
+    // far it moved, so a swipe stays a drag on its list.
+    beforeEnd: () => {
+      if (press.kind === null) classify(press);
+    },
   });
 };
 
@@ -420,14 +438,7 @@ const onTouchEnd = (ne: Record<string, unknown>, cancelled: boolean) => {
   // A scroll view cancels the touch when it takes the gesture. On a list still moving from a fling it does so at once,
   // before the finger passes the slop, so the move alone would call a fling a press on the row under the finger.
   press.takenByScroll = cancelled && press.scrollHosts.length > 0;
-  const drag = press.maxMovePt >= DRAG_SLOP_PT || press.scrolled || press.takenByScroll;
-  press.kind = drag ? 'drag' : 'press';
-  if (drag) {
-    const axis = dragAxis(press);
-    const candidate = selectScrollHost(press.scrollHosts, axis);
-    press.container = candidate ? nameScrollContainer(candidate, press.screen) : null;
-    const name = dragName(press);
-    markers.rename(press.key, name, `drag:${press.container?.legacyName ?? press.target.legacyName}`);
+  if (classify(press)) {
     return;
   }
   if (cancelled) {

package/js/sdk/push.ts

@@ -115,6 +115,8 @@ const serverClock = async (res: { json?: () => Promise<unknown> }, bound: Promis
 interface Item {
   line: string;
   bytes: number;
+  // The line's size inside the request body: a JSON string (escaped) plus its comma.
+  wire: number;
   token: string | null;
   // The process that recorded the line (its bootId) and its sequence there.
   origin: string;
@@ -127,7 +129,7 @@ interface Batch {
   id: string;
   items: Item[];
   token: string | null;
-  bytes: number;
+  wire: number;
 }
 
 interface SpoolAdd {
@@ -211,6 +213,8 @@ export const pendingFromSpool = (content: string | null): PendingLine[] =>
   readSpool(content).pending;
 
 // Retrying cannot fix these; the batch is dropped instead of blocking the queue.
+const wireBytes = (line: string) => utf8Length(JSON.stringify(line)) + 1;
+
 const isPermanent = (status: number) =>
   status >= 400 && status < 500 && status !== 408 && status !== 429;
 
@@ -261,6 +265,11 @@ export const createPushClient = (deps: PushDeps) => {
   let journalRecords = 0;
   // Lines dropped before delivery, by this process and (from the note) earlier ones.
   let undelivered = 0;
+  // Lines of a run dropped before delivery (queue cap, line over the batch limit), by run token, until its next flush.
+  const droppedOfRun = new Map<string, number>();
+  const noteDropped = (token: string | null) => {
+    if (token !== null) droppedOfRun.set(token, (droppedOfRun.get(token) ?? 0) + 1);
+  };
   // Round trips not reported yet, each with the run token it was measured under.
   let clockPending: { token: string; sample: ClockSample }[] = [];
   const clockOf = (token: string | null) =>
@@ -424,6 +433,7 @@ export const createPushClient = (deps: PushDeps) => {
       }
     }
     undelivered += dropped.length;
+    for (const item of dropped) noteDropped(item.token);
     return dropped;
   };
 
@@ -432,12 +442,14 @@ export const createPushClient = (deps: PushDeps) => {
     if (bytes > maxBatchBytes) {
       stats.dropped++;
       undelivered++;
+      noteDropped(deps.getRunToken());
       stats.lastError = `line of ${bytes} bytes exceeds batch limit`;
       return;
     }
     const item: Item = {
       line,
       bytes,
+      wire: wireBytes(line),
       token: deps.getRunToken(),
       origin: bootId,
       seq: nextSeq++,
@@ -486,11 +498,13 @@ export const createPushClient = (deps: PushDeps) => {
       if (bytes > maxBatchBytes) {
         stats.resumeDropped++;
         undelivered++;
+        noteDropped(record.t);
         continue;
       }
       earlier.push({
         line: record.l,
         bytes,
+        wire: wireBytes(record.l),
         token: record.t,
         origin: record.o,
         seq: record.s,
@@ -528,16 +542,16 @@ export const createPushClient = (deps: PushDeps) => {
     }
     const first = queue[0] as Item;
     const items: Item[] = [];
-    let bytes = 0;
+    let wire = 0;
     if (first.batch !== undefined) {
       // Already sent once (by a killed process): resend exactly that batch.
       while (queue.length > 0 && queue[0]?.batch === first.batch) {
         const next = queue.shift() as Item;
         queuedBytes -= next.bytes;
         items.push(next);
-        bytes += next.bytes;
+        wire += next.wire;
       }
-      return { id: first.batch, items, token: first.token, bytes };
+      return { id: first.batch, items, token: first.token, wire };
     }
     while (queue.length > 0 && items.length < maxBatchItems) {
       const next = queue[0];
@@ -546,16 +560,16 @@ export const createPushClient = (deps: PushDeps) => {
         next.batch !== undefined ||
         next.token !== first.token ||
         next.origin !== first.origin ||
-        (items.length > 0 && bytes + next.bytes > maxBatchBytes)
+        (items.length > 0 && wire + next.wire > maxBatchBytes)
       ) {
         break;
       }
       queue.shift();
       queuedBytes -= next.bytes;
       items.push(next);
-      bytes += next.bytes;
+      wire += next.wire;
     }
-    return { id: '', items, token: first.token, bytes };
+    return { id: '', items, token: first.token, wire };
   };
 
   let inflight: Promise<void> | null = null;
@@ -601,29 +615,48 @@ export const createPushClient = (deps: PushDeps) => {
           bound.clear();
         }
       }
+      const runToken = batch.token;
+      const reported = clockOf(runToken);
+      const sentDevice = device;
+      const bodyOf = (id: string) => JSON.stringify({
+        batch_id: id,
+        device: sentDevice,
+        items: batch.items.map(item => item.line),
+        ...(runToken ? { run_token: runToken } : {}),
+        ...(reported.length ? { clock: reported } : {}),
+      });
+      // Names exactly these lines (process, first and last sequence, count),
+      // so a different set of lines is always a different batch.
+      const idOf = () => {
+        const first = batch.items[0] as Item;
+        const last = batch.items[batch.items.length - 1] as Item;
+        return `${sentDevice.install_id}-${first.origin}-${first.seq}-${last.seq}-${batch.items.length}`;
+      };
+      let body = bodyOf(batch.id || idOf());
       if (!batch.id) {
-        // Names exactly these lines (process, first and last sequence, count),
-        // so a different set of lines is always a different batch. It is
-        // journalled before the first send: a later process that resends after
+        // The cap is on the body as sent (escaped lines, device, clock samples): lines over it go back to the queue
+        // front for the next batch. A lone line still goes; a line alone over the cap was dropped at enqueue.
+        for (let over = utf8Length(body) - maxBatchBytes; over > 0 && batch.items.length > 1; over = utf8Length(body) - maxBatchBytes) {
+          const back: Item[] = [];
+          for (let freed = 0; freed < over && batch.items.length > 1;) {
+            const item = batch.items.pop() as Item;
+            freed += item.wire;
+            back.unshift(item);
+          }
+          queue.unshift(...back);
+          for (const item of back) queuedBytes += item.bytes;
+          body = bodyOf(idOf());
+        }
+        // Journalled before the first send: a later process that resends after
         // a kill sends the same lines under the same id, and the server's
         // replay check can only ever drop lines it already has.
+        batch.id = idOf();
         const first = batch.items[0] as Item;
-        const last = batch.items[batch.items.length - 1] as Item;
-        batch.id = `${device.install_id}-${first.origin}-${first.seq}-${last.seq}-${batch.items.length}`;
         for (const item of batch.items) {
           item.batch = batch.id;
         }
         journal({ b: batch.id, o: first.origin, s: batch.items.map(item => item.seq) });
       }
-      const runToken = batch.token;
-      const reported = clockOf(runToken);
-      const body = JSON.stringify({
-        batch_id: batch.id,
-        device,
-        items: batch.items.map(item => item.line),
-        ...(runToken ? { run_token: runToken } : {}),
-        ...(reported.length ? { clock: reported } : {}),
-      });
       const headers: Record<string, string> = {
         'content-type': 'application/json',
         'x-keepsnappy-key': deps.key,
@@ -804,16 +837,23 @@ export const createPushClient = (deps: PushDeps) => {
         await sendClock(deadline);
       }
       const refused = refusedRunBatches - refusedBefore;
-      const ok = sentAll && refused === 0;
+      // A run that lost lines before they were sent is missing windows, whatever went up after.
+      const token = deps.getRunToken();
+      const lost = token === null ? 0 : (droppedOfRun.get(token) ?? 0);
+      if (token !== null) droppedOfRun.delete(token);
+      const ok = sentAll && refused === 0 && lost === 0;
+      const error = ok
+        ? null
+        : !sentAll
+          ? (stats.lastError ?? 'flush deadline')
+          : refused > 0
+            ? `rejected ${lastRefusedStatus}: ${refused} ${refused === 1 ? 'batch' : 'batches'} of the run dropped`
+            : 'lines of the run dropped before sending';
       return {
         ok,
         batches: stats.batchesSent - sentBefore,
         lines: stats.linesSent - linesBefore,
-        error: ok
-          ? null
-          : !sentAll
-            ? (stats.lastError ?? 'flush deadline')
-            : `rejected ${lastRefusedStatus}: ${refused} ${refused === 1 ? 'batch' : 'batches'} of the run dropped`,
+        error: error !== null && lost > 0 ? `${error} dropped=${lost}` : error,
       };
     } finally {
       flushLimit = null;

package/js/sdk/sampler.ts

@@ -132,7 +132,7 @@ export const estimateOffset = (before: number, native: number, after: number) =>
 // late after its t0 a window can start and still take one. It gates only screen windows (a screen window opened by a
 // press is detected after the new screen rendered and takes the press's open sample, taken the touch delivery delay
 // past the press's t0) and the reuse of a close sample for a restarted key. Press windows do not depend on it: they
-// take the previous window's close sample by contiguity. Evidence for 50: idle lab event timing of 4.9-19.1 ms
+// take the previous window's close sample by contiguity, else a sample of their own however late it is. Evidence for 50: idle lab event timing of 4.9-19.1 ms
 // (packages/derive/test/fixtures/p37-*.log); no loaded-device data. Measure the touchstart delivery delay p99 per
 // device from farm data (docs/log/followups.md).
 export const OPEN_SAMPLE_TOLERANCE_MS = 50;

package/js/sdk/screens.ts

@@ -66,7 +66,8 @@ interface Visit {
   visit: number;
   screenKey: string | null;
   legacyName: string;
-  pendingCommits: number;
+  // The screen component is not known yet: its scene has not mounted, or it is suspended.
+  pending: boolean;
   resolution: ScreenRouteResolution;
   lazyBoundary: Fiber | null;
   t0: number;
@@ -254,7 +255,7 @@ const endVisit = (reason: string, at?: number) => {
   if (!visit || visit.endedAt !== null) {
     return;
   }
-  if (visit.pendingCommits > 0) resolveVisit(visit, true);
+  if (visit.pending) resolveVisit(visit, true);
   const t = Math.max(visit.t0, at ?? now());
   visit.endedAt = t;
   stats.ends[reason] = (stats.ends[reason] ?? 0) + 1;
@@ -269,7 +270,9 @@ const endVisit = (reason: string, at?: number) => {
 // state event.
 const chooseStart = (snapshot: NavSnapshot, floor: number) => {
   const inSpan = (t: number) => t >= floor && t <= snapshot.stateT;
-  const presses = pressesSinceVisit.filter(p => inSpan(p.t0));
+  // Touches delivered since the previous visit opened, whatever their finger time: a finger that landed while the
+  // previous screen was mounting reaches JS after its state was read.
+  const presses = pressesSinceVisit.filter(p => p.t0 >= windowsEndedAt && p.t0 <= snapshot.stateT);
   const link = pendingLink && inSpan(pendingLink.t) ? pendingLink : null;
   const action = snapshot.action && inSpan(snapshot.action.t) ? snapshot.action : null;
   const touchStart = (p: Press) => ({
@@ -357,7 +360,7 @@ const resolveVisit = (visit: Visit, final = false) => {
   if (resolved.screenPending && !final) return;
   moveScreenCounter(visit, resolved.screen);
   visit.name = buildPlaceId({ kind: 'screen', screen: resolved.screen, visit: visit.visit });
-  visit.pendingCommits = 0;
+  visit.pending = false;
   markers.rename(visit.key, visit.name, visit.legacyName);
 };
 
@@ -380,7 +383,7 @@ const extend = (visit: Visit, chain: RoutePart[], chainKey: string) => {
       visit.screenKey = null;
     }
     visit.name = visit.legacyName;
-    visit.pendingCommits = 3;
+    visit.pending = true;
     markers.rename(visit.key, visit.name, visit.legacyName);
   } else resolveVisit(visit);
   stats.extended++;
@@ -447,7 +450,7 @@ const onSnapshot = (snapshot: NavSnapshot, nameSource: NameSource) => {
     visit: n,
     legacyName: nameOf(chainKey, n),
     screenKey: null,
-    pendingCommits: 3,
+    pending: true,
     resolution: resolved,
     lazyBoundary: resolved.suspended ?? null,
     t0: start.t0,
@@ -465,7 +468,7 @@ const onSnapshot = (snapshot: NavSnapshot, nameSource: NameSource) => {
   if (!resolved.screenPending) {
     moveScreenCounter(visit, resolved.screen);
     visit.name = buildPlaceId({ kind: 'screen', screen: resolved.screen, visit: visit.visit });
-    visit.pendingCommits = 0;
+    visit.pending = false;
   }
   current = visit;
   pressesSinceVisit = [];
@@ -481,7 +484,7 @@ const onSnapshot = (snapshot: NavSnapshot, nameSource: NameSource) => {
     kind: 'screen',
     legacyName: visit.legacyName,
     beforeEnd: () => {
-      if (visit.pendingCommits > 0) resolveVisit(visit, true);
+      if (visit.pending) resolveVisit(visit, true);
       visit.lazyBoundary = null;
       visit.resolution = { screen: visit.screenKey ?? visit.resolution.screen };
     },
@@ -526,12 +529,14 @@ export const noteAppLink = (url: string, via: string) => {
   }
 };
 
+// Every touch delivered while a visit is open is an action after the one that opened it, even when its finger landed
+// before the SDK read the navigation state (the JS thread was busy with the mount): order decides, not the clocks.
 const onPress = (t0: number) => {
   const press = lastPressStart();
   if (press) {
     pressesSinceVisit.push(press);
   }
-  if (current && current.endedAt === null && t0 > current.openedAt) {
+  if (current && current.endedAt === null) {
     endVisit('next-action', t0);
   }
 };
@@ -613,6 +618,10 @@ const onWindowsEnded = (reason: string) => {
   pendingLink = null;
 };
 
+export const resetCurrentScreenForTest = () => {
+  current = null;
+};
+
 export const resetLaunchForTest = () => {
   launchVisitOpened = false;
   windowsEndedSinceStart = false;
@@ -628,7 +637,7 @@ export const installScreens = () => {
   installed = true;
   setScreenKeyProvider(() => current ? {
     screen: current.screenKey ?? current.resolution.screen,
-    ...(current.pendingCommits > 0 || current.lazyBoundary ? { screenPending: true } : {}),
+    ...(current.pending || current.lazyBoundary ? { screenPending: true } : {}),
   } : { screen: '(no screen)' });
   setRetainFloor(screenRetainFloor);
   onWindowsEnd(onWindowsEnded);
@@ -641,11 +650,12 @@ export const installScreens = () => {
   onAfterCommit(() => {
     const visit = current;
     if (visit && isWindowOpen(visit.key)) {
-      if (visit.pendingCommits > 0) {
+      // A pending visit is resolved when its scene mounts, however many commits come first; it falls back to the route
+      // name only when it ends.
+      if (visit.pending && !visit.lazyBoundary) {
         visit.resolution = screenResolution(visit.chain);
         visit.lazyBoundary = visit.resolution.suspended ?? null;
-        visit.pendingCommits--;
-        resolveVisit(visit, visit.pendingCommits === 0);
+        resolveVisit(visit);
       } else if (visit.lazyBoundary) {
         const boundary = currentFiber(visit.lazyBoundary);
         if (!boundary || boundary.memoizedState == null) {

package/js/sdk/stream.ts

@@ -39,6 +39,12 @@ export const createStream = (processId: string, maxFibers = MAX_SEGMENT_FIBERS)
     /** The segment the next commit goes into: windows name it so the backend can tell a stream is complete. */
     seq: () => seq,
     size: () => commits.length,
+    /** Sets the fiber cap of the segments from now on; returns the previous cap. */
+    setMaxFibers(n: number) {
+      const previous = maxFibers;
+      maxFibers = n;
+      return previous;
+    },
     noteRoot(root: CauseRoot) {
       roots.push(root);
     },

package/package.json

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