@goliapkg/sentori-react-native 6.2.0 → 6.3.0

package/SentoriReactNative.podspec

@@ -10,15 +10,22 @@ Pod::Spec.new do |s|
   s.license        = 'TBD'
   s.author         = { 'Sentori' => 'support@sentori.golia.jp' }
   s.homepage       = 'https://sentori.golia.jp'
-  s.platforms      = { ios: '13.4', tvos: '13.4' }
+  # 13.4 was a claim nothing compiled. `SentoriPushNotifications`
+  # uses `UNNotificationPresentationOptions.banner` and `.list`, both
+  # iOS 14 — building the sources against the declared floor for the
+  # first time (as a Swift package, 2026-08-11) failed on exactly
+  # that. The floor now matches what the code needs.
+  s.platforms      = { ios: '14.0', tvos: '14.0' }
   s.swift_version  = '5.4'
   s.source         = { git: '' }
   s.static_framework = true
 
   s.dependency 'ExpoModulesCore'
 
+  # `ios/SentoriModule.swift` is the bridge; `ios/core/` is a mirror of
+  # `sdk/native/ios/Sources/Sentori`, written by
+  # `scripts/sync-native-core.mjs` and gated byte-for-byte. Edit the
+  # package, never the mirror — a pod cannot reach outside its own
+  # directory, which is the only reason a copy exists at all.
   s.source_files = 'ios/**/*.{h,m,mm,swift,hpp,cpp}'
-  # XCTest only links into test targets; including ios/Tests/** in the
-  # main pod target makes app builds fail with `no such module 'XCTest'`.
-  s.exclude_files = 'ios/Tests/**'
 end

package/android/build.gradle

@@ -18,7 +18,21 @@ android {
     sourceSets {
         main {
             manifest.srcFile 'src/main/AndroidManifest.xml'
-            java.srcDirs = ['src/main/java']
+            // `java` holds the bridge — `SentoriModule.kt`, the one
+            // file here that knows Expo exists. `java-core` is a
+            // generated mirror of `sdk/native/android`, written by
+            // `scripts/sync-native-core.mjs` and gated byte-for-byte.
+            // Two roots rather than one directory because the sync
+            // deletes its target before writing, and the bridge must
+            // not live somewhere that gets wiped.
+            java.srcDirs = ['src/main/java', 'src/main/java-core']
+        }
+        test {
+            // The Robolectric suites cover the core, so they moved
+            // with it. Mirrored back so `android-unit` keeps running
+            // them — dropping them here would have left the job green
+            // while testing strictly less.
+            java.srcDirs = ['src/test/java', 'src/test/java-core']
         }
     }
 
@@ -63,6 +77,12 @@ dependencies {
     // unresolved reference. Nothing noticed because nothing ran them —
     // the CI job that was supposed to had been failing for months on a
     // missing Gradle wrapper.
+    // The mirrored tests move with the code they cover, and one of
+    // them drives a real `RemoteMessage` through the messaging
+    // service. `compileOnly` above does not reach the test source
+    // set, so without this the mirror compiles and its tests do not —
+    // which is how this module went red while `sdk/native` was green.
+    testImplementation 'com.google.firebase:firebase-messaging:24.0.3'
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'org.robolectric:robolectric:4.13'
     testImplementation 'androidx.test:core:1.6.1'

package/android/src/main/java-core/com/sentori/Sentori.kt

@@ -0,0 +1,273 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/Sentori.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import android.content.Context
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+import kotlin.random.Random
+
+/**
+ * The surface a host app writes against.
+ *
+ *     Sentori.error(e)                what went wrong?
+ *     Sentori.warn("checkout.slow")   where did the user struggle?
+ *     Sentori.trace("cart.opened")    what happened here?
+ *     Sentori.assert("total", ok)     should this hold?
+ *     Sentori.probe("SEN-482")        is that bug back?
+ *
+ * Every one is synchronous, returns the event id it minted, and never
+ * throws — including before [start], where each is a no-op that still
+ * hands back an id. An app that mis-wires its token gets a silent SDK,
+ * not an exception on a path it did not know it had.
+ *
+ * Same semantics as the Swift and React Native surfaces, because the
+ * dashboard reading them cannot tell which one sent an event and
+ * should not have to.
+ */
+object Sentori {
+
+    // ── lifecycle ─────────────────────────────────────────────────
+
+    /**
+     * Configure and start. [context] is used for one thing: the
+     * directory events spill into when the network is gone. Pass the
+     * application context, not an Activity.
+     *
+     * Nothing here reaches the network; the first request happens when
+     * there is something to send.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun start(config: SentoriConfig, context: Context? = null) {
+        SentoriConfig.set(config)
+        SentoriDevice.bind(context)
+        SentoriTransport.start(context?.let { java.io.File(it.filesDir, "sentori") })
+
+        // Crash capture needs a Context for its storage, so an app
+        // that starts without one gets everything except this.
+        if (context != null) {
+            // The handler runs inside an uncaught-exception handler
+            // where almost nothing is safe, so it reads its release
+            // and environment from SharedPreferences rather than from
+            // a live object. Without this call every crash ships as
+            // `unknown` / `prod` — matching no release, so
+            // symbolicating against nothing.
+            SentoriCrashHandler.setConfig(
+                mapOf("release" to config.release, "environment" to config.environment)
+            )
+            SentoriCrashHandler.register(context)
+
+            // The crash that killed the last launch. Until now the
+            // handler wrote files into a directory nothing emptied —
+            // a crash reporter that captured crashes and never sent
+            // one.
+            SentoriPendingCrash.ship()
+        }
+    }
+
+    /**
+     * Identify the person using the app. Only a hash of [id] (or
+     * [email] when there is no id) travels; the raw values stay here.
+     *
+     * Order does not matter with push: a device that has registered
+     * updates itself when this changes, so signing in after
+     * registering makes the device reachable straight away. It said to
+     * call this first, which was advice for a defect rather than a
+     * design — most apps learn who the user is well after launch.
+     *
+     * [traits] are attributes a push campaign can select on: plan,
+     * cohort, org. They travel raw, unlike [id] and [email], so put
+     * nothing there that identifies the person.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun user(id: String?, email: String?, traits: Map<String, Any?>? = null) =
+        SentoriScope.setUser(id, email, traits)
+
+    /** Merge keys into the ambient context that rides every event. */
+    @JvmStatic
+    fun context(patch: Map<String, Any?>) = SentoriScope.patchContext(patch)
+
+    /**
+     * Record a signal for the last-sixty-seconds ring that ships with
+     * an error. Any [kind] is accepted; the dashboard reads `http` as
+     * `{ method, url, status, ms }` and `trace` as a quiet breadcrumb.
+     *
+     * This SDK deliberately does not install an OkHttp interceptor:
+     * watching the host's traffic is the host's decision, not ours to
+     * make silently.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun pushSignal(kind: String, data: Map<String, Any?>? = null) =
+        SentoriSignalRing.push(kind, data)
+
+    /**
+     * `Sentori.push.register(...)`, matching `sentori.push.register()`
+     * in the React Native SDK and `Sentori.push` in Swift.
+     */
+    @JvmStatic val push: SentoriPush get() = SentoriPush
+
+    // ── the verbs ─────────────────────────────────────────────────
+
+    /** Something went wrong. */
+    @JvmStatic
+    @JvmOverloads
+    fun error(err: Throwable, data: Map<String, Any?>? = null): String =
+        emit("error", null, describe(err), data, withSignals = true)
+
+    /** Something went wrong, described rather than thrown. */
+    @JvmStatic
+    @JvmOverloads
+    fun error(message: String, type: String = "Error", data: Map<String, Any?>? = null): String =
+        emit("error", null, mapOf("type" to type, "message" to message), data, withSignals = true)
+
+    /**
+     * The user struggled here. Not a crash — a place the product hurt,
+     * named by you.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun warn(name: String, data: Map<String, Any?>? = null): String =
+        emit("warn", name, null, data, withSignals = true)
+
+    /**
+     * This happened. Always lands in the signal ring; [quiet] keeps it
+     * out of the event stream, which is how a high-frequency
+     * breadcrumb stays affordable.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun trace(name: String, data: Map<String, Any?>? = null, quiet: Boolean = false): String {
+        val signal = mutableMapOf<String, Any?>("name" to name)
+        data?.let { signal.putAll(it) }
+        SentoriSignalRing.push("trace", signal)
+        if (quiet) return newEventId()
+        return emit("trace", name, null, data, withSignals = false)
+    }
+
+    /**
+     * This should hold. A passing assert never becomes an event — it
+     * increments a counter that rides the next batch, so a liveness
+     * check costs no request. Only failures are events.
+     *
+     * Unlike the language's own `assert`, this never stops the
+     * program. That difference is the point: a monitoring SDK that can
+     * halt the app it monitors has picked the wrong side of the
+     * bargain.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun assert(name: String, ok: Boolean, data: Map<String, Any?>? = null): String {
+        SentoriConfig.current?.let { SentoriTransport.countAssert(name, ok, it.release) }
+        if (ok) return newEventId()
+        return emit("assert", name, null, data, withSignals = true)
+    }
+
+    /**
+     * Is that bug back? A tripwire: reaching this call is the signal.
+     * It changes no control flow and returns no verdict.
+     */
+    @JvmStatic
+    @JvmOverloads
+    fun probe(ref: String, data: Map<String, Any?>? = null): String =
+        emit("probe", ref, null, data, withSignals = false)
+
+    // ── assembly ──────────────────────────────────────────────────
+
+    private fun emit(
+        kind: String,
+        name: String?,
+        error: Map<String, Any?>?,
+        data: Map<String, Any?>?,
+        withSignals: Boolean,
+    ): String {
+        val id = newEventId()
+        // Before init every verb is a no-op that still returns an id,
+        // so a call site does not change shape depending on whether
+        // the SDK came up.
+        val config = SentoriConfig.current ?: return id
+
+        val payload = mutableMapOf<String, Any?>()
+        error?.let { payload["error"] = it }
+        data?.let { payload["data"] = it }
+        SentoriScope.context?.let { payload["context"] = it }
+        if (withSignals) {
+            val signals = SentoriSignalRing.snapshot()
+            if (signals.isNotEmpty()) payload["signals"] = signals
+        }
+        payload["device"] = SentoriDevice.snapshot()
+
+        val event =
+            mutableMapOf<String, Any?>(
+                "id" to id,
+                "kind" to kind,
+                "occurredAt" to iso8601(Date()),
+                "platform" to "android",
+                "release" to config.release,
+                "environment" to config.environment,
+                "payload" to payload,
+            )
+        name?.let { event["name"] = it }
+        SentoriScope.userKey?.let { event["userKey"] = it }
+
+        SentoriTransport.enqueue(event)
+        return id
+    }
+
+    private fun describe(err: Throwable): Map<String, Any?> {
+        val frames =
+            err.stackTrace.take(50).map { f ->
+                mapOf(
+                    "function" to "${f.className}.${f.methodName}",
+                    "file" to (f.fileName ?: ""),
+                    "line" to f.lineNumber,
+                )
+            }
+        val out =
+            mutableMapOf<String, Any?>(
+                "type" to (err.javaClass.name),
+                "message" to (err.message ?: ""),
+                "stack" to frames,
+            )
+        err.cause?.let { if (it !== err) out["cause"] = describe(it) }
+        return out
+    }
+
+    private val isoFormat =
+        SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply {
+            timeZone = TimeZone.getTimeZone("UTC")
+        }
+
+    internal fun iso8601(date: Date): String = synchronized(isoFormat) { isoFormat.format(date) }
+
+    /**
+     * UUIDv7: 48 bits of milliseconds then random, so ids sort by
+     * creation time. The server keys events on them and the dashboard
+     * orders by them, so a v4 would scatter a session across the
+     * index.
+     */
+    internal fun newEventId(): String {
+        val bytes = ByteArray(16)
+        Random.nextBytes(bytes)
+        val ms = System.currentTimeMillis()
+        bytes[0] = ((ms shr 40) and 0xff).toByte()
+        bytes[1] = ((ms shr 32) and 0xff).toByte()
+        bytes[2] = ((ms shr 24) and 0xff).toByte()
+        bytes[3] = ((ms shr 16) and 0xff).toByte()
+        bytes[4] = ((ms shr 8) and 0xff).toByte()
+        bytes[5] = (ms and 0xff).toByte()
+        bytes[6] = ((bytes[6].toInt() and 0x0f) or 0x70).toByte()
+        bytes[8] = ((bytes[8].toInt() and 0x3f) or 0x80).toByte()
+
+        val hex = StringBuilder(32)
+        for (b in bytes) hex.append(String.format("%02x", b.toInt() and 0xff))
+        val h = hex.toString()
+        return "${h.substring(0, 8)}-${h.substring(8, 12)}-${h.substring(12, 16)}-" +
+            "${h.substring(16, 20)}-${h.substring(20, 32)}"
+    }
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriAnrWatchdog.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriAnrWatchdog.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.content.Context

package/android/src/main/java-core/com/sentori/SentoriAttachment.kt

@@ -0,0 +1,153 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriAttachment.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+
+/**
+ * Blobs that belong to an event: the screenshot taken as the app died,
+ * the view tree behind it.
+ *
+ * They upload *after* the event, never before. The server keys an
+ * attachment on an event id it must already know, so an upload that
+ * races the batch 404s — and it always wins that race, because the
+ * batch waits for a flush and the upload does not.
+ *
+ * The multipart body is built by hand. React Native learned why the
+ * expensive way: its `FormData` file part wants a `uri`, the `data:`
+ * form throws a bare network error on iOS, and every JS attachment
+ * died silently for a release. Doing it literally is both shorter and
+ * checkable.
+ *
+ * Mirrors `SentoriAttachment.swift` part for part.
+ */
+internal object SentoriAttachment {
+
+    /**
+     * The kinds the server's CHECK constraint accepts, from
+     * `handlers/sdk/events_attachments.rs`. Anything else is a 400,
+     * so it is dropped here with the round trip saved.
+     *
+     * Worth keeping honest: the first version of this list had three
+     * entries, and the crash handler's view tree — written on both
+     * platforms, kind `viewTree` — was not one of them. It would have
+     * been dropped on the way out by the very code meant to deliver
+     * it, silently, with the event arriving intact and the evidence
+     * missing.
+     */
+    val KNOWN =
+        setOf(
+            "logTail",
+            "replay",
+            "screens",
+            "screenshot",
+            "sessionTrail",
+            "stateSnapshot",
+            "viewTree",
+        )
+
+    /** `android` | `ios` | `js`, likewise CHECK-constrained. */
+    val KNOWN_SOURCES = setOf("android", "ios", "js")
+
+    /**
+     * Test seam: capture instead of sending.
+     *
+     * What is worth asserting is *what* would be uploaded and *when* —
+     * the kind, the event it is keyed on, the body, and that none of
+     * it moves before the batch lands. None of that is about TCP; the
+     * wire has its own gate in `android-live-ingest`.
+     */
+    internal var recorderForTests: ((String, String, String) -> Unit)? = null
+
+    private val worker = java.util.concurrent.Executors.newSingleThreadExecutor { r ->
+        Thread(r, "sentori-attachment").apply { isDaemon = true }
+    }
+
+    /**
+     * Upload one blob against an event the server already has.
+     *
+     * Fire and forget: nothing here reaches the caller, and a failure
+     * costs the attachment rather than the crash report it belongs to.
+     */
+    fun upload(
+        eventId: String,
+        kind: String,
+        base64: String,
+        mediaType: String,
+        source: String = "android",
+        completion: ((Boolean) -> Unit)? = null,
+    ) {
+        val config = SentoriConfig.current
+        if (config == null || kind !in KNOWN || source !in KNOWN_SOURCES) {
+            completion?.invoke(false)
+            return
+        }
+
+        val boundary = "----sentori-$eventId"
+        val body = multipartBody(boundary, kind, mediaType, base64, source)
+
+        recorderForTests?.let {
+            it(eventId, kind, body)
+            completion?.invoke(true)
+            return
+        }
+
+        worker.execute {
+            var conn: HttpURLConnection? = null
+            var ok = false
+            try {
+                val url =
+                    "${config.ingestUrl}/v1/events/" +
+                        URLEncoder.encode(eventId, "UTF-8") +
+                        "/attachments/" +
+                        URLEncoder.encode(kind, "UTF-8")
+                conn = URL(url).openConnection() as HttpURLConnection
+                conn.requestMethod = "POST"
+                conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=$boundary")
+                conn.setRequestProperty("Authorization", "Bearer ${config.token}")
+                conn.setRequestProperty("Sentori-Sdk", "kotlin/${SentoriVersion.CURRENT}")
+                conn.connectTimeout = 15_000
+                conn.readTimeout = 30_000
+                conn.doOutput = true
+                conn.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+                ok = conn.responseCode in 200..299
+            } catch (_: Throwable) {
+                // An attachment that will not go is an attachment lost,
+                // and never the host app's problem.
+            } finally {
+                conn?.disconnect()
+                completion?.invoke(ok)
+            }
+        }
+    }
+
+    /**
+     * The multipart body, visible so a test can read what would go on
+     * the wire. Building it correctly is the whole job here, and the
+     * failure mode is a 2xx that stored the wrong bytes.
+     */
+    internal fun multipartBody(
+        boundary: String,
+        kind: String,
+        mediaType: String,
+        base64: String,
+        source: String,
+    ): String =
+        buildString {
+            append("--$boundary\r\n")
+            append("Content-Disposition: form-data; name=\"file\"; filename=\"$kind.bin\"\r\n")
+            append("Content-Type: $mediaType\r\n")
+            // The server decodes when told to. Without this header it
+            // stores the base64 text as the image, which renders as
+            // nothing and looks like a capture problem.
+            append("Content-Transfer-Encoding: base64\r\n")
+            append("\r\n$base64\r\n")
+            append("--$boundary\r\n")
+            append("Content-Disposition: form-data; name=\"source\"\r\n")
+            append("\r\n$source\r\n")
+            append("--$boundary--\r\n")
+        }
+}

package/android/src/main/java-core/com/sentori/SentoriConfig.kt

@@ -0,0 +1,61 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriConfig.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Set once by [Sentori.start]; everything else reads it and treats
+ * absence as "not initialised, so every verb is a no-op".
+ *
+ * That default is the failure-isolation half of the client zero-cost
+ * rule: an app that mis-wires its token gets a silent SDK, never an
+ * exception on a path it did not know it had.
+ */
+class SentoriConfig
+@JvmOverloads
+constructor(
+    val token: String,
+    ingestUrl: String,
+    val release: String,
+    val environment: String,
+    /**
+     * The integrator's own health endpoint, carried on batches and
+     * probed server-side. The app never pings it — a monitoring SDK
+     * that adds traffic to the thing it monitors has picked the wrong
+     * side of the bargain.
+     */
+    val backendHealthUrl: String? = null,
+) {
+    /**
+     * A trailing slash here becomes `//v1/events:batch`, which some
+     * proxies answer and some 404.
+     */
+    val ingestUrl: String = ingestUrl.trimEnd('/')
+
+    companion object {
+        private val ref = AtomicReference<SentoriConfig?>(null)
+
+        @JvmStatic val current: SentoriConfig? get() = ref.get()
+
+        @JvmStatic val isInitialised: Boolean get() = ref.get() != null
+
+        internal fun set(config: SentoriConfig?) = ref.set(config)
+
+        internal fun resetForTests() = ref.set(null)
+    }
+}
+
+/**
+ * Reported in the `Sentori-Sdk` header so a server-side problem can be
+ * attributed to a client version.
+ *
+ * Mirrors the constant in `sdk/react-native/src/transport.ts` and the
+ * Swift one, and is written by `scripts/sync-sdk-version.mjs` — a
+ * version string nothing writes goes stale, and only ever in the
+ * direction of a lie.
+ */
+object SentoriVersion {
+    const val CURRENT = "1.7.1"
+}

package/android/src/main/{java → java-core}/com/sentori/SentoriCrashHandler.kt

@@ -1,3 +1,6 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriCrashHandler.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
 package com.sentori
 
 import android.content.Context
@@ -193,6 +196,25 @@ object SentoriCrashHandler {
         }
     }
 
+    /**
+     * Test-only seam that writes a crash file verbatim.
+     *
+     * `persistForTesting(throwable)` goes through `write`, which
+     * composes the file from a live throwable and a live window —
+     * neither of which a Robolectric test can arrange. Delivery tests
+     * need to state the file they are about to deliver, particularly
+     * the pre-death attachments, which only exist when there was a
+     * window to capture.
+     */
+    internal fun persistRawForTesting(event: JSONObject) {
+        val dir = pendingDir() ?: return
+        try {
+            File(dir, "${uuidLower()}.json").writeText(event.toString())
+        } catch (_: Throwable) {
+            // best-effort
+        }
+    }
+
     private fun attachPending(event: JSONObject) {
         val snap = try {
             SentoriScreenshotCapture.captureKeyWindow()

package/android/src/main/java-core/com/sentori/SentoriDevice.kt

@@ -0,0 +1,61 @@
+// GENERATED MIRROR — do not edit.
+// Source of truth: sdk/native/android/src/main/java/com/sentori/SentoriDevice.kt
+// Run `node scripts/sync-native-core.mjs` after editing it.
+package com.sentori
+
+import android.content.Context
+import android.os.Build
+
+/**
+ * What the device is, as `payload.device` on every event.
+ *
+ * Everything here is read once and cached: this runs on the calling
+ * thread inside every verb, and a verb that asks the window manager
+ * for a fresh value each time is not the O(1) the contract promises.
+ */
+object SentoriDevice {
+
+    private val lock = Any()
+    private var screen: Map<String, Any?>? = null
+
+    /**
+     * Optional. Without a [Context] the snapshot omits the screen and
+     * carries everything else — an event with a thinner device beats
+     * no event, and a host that starts the SDK before it has a context
+     * is making a reasonable choice.
+     */
+    @JvmStatic
+    fun bind(context: Context?) {
+        val ctx = context ?: return
+        synchronized(lock) {
+            val m = ctx.resources.displayMetrics
+            screen =
+                mapOf(
+                    "width" to (m.widthPixels / m.density),
+                    "height" to (m.heightPixels / m.density),
+                    "scale" to m.density,
+                )
+        }
+    }
+
+    @JvmStatic
+    fun snapshot(): Map<String, Any?> {
+        val out =
+            mutableMapOf<String, Any?>(
+                "os" to "android",
+                "osVersion" to Build.VERSION.RELEASE,
+                // The hardware identifier, not a marketing name.
+                // Mapping it would need a table that goes stale with
+                // every launch; the dashboard does that lookup
+                // server-side where it can be updated without a client
+                // release.
+                "model" to "${Build.MANUFACTURER} ${Build.MODEL}",
+            )
+        synchronized(lock) { screen }?.let { out["screen"] = it }
+        return out
+    }
+
+    internal fun resetForTests() {
+        synchronized(lock) { screen = null }
+    }
+}