@dvai-bridge/android-shared-core 4.0.0

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/pairing/Pairing.kt

@@ -0,0 +1,58 @@
+package co.deepvoiceai.bridge.shared.core.pairing
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Phase 3 — pairing types (Kotlin mirror of `Pairing` /
+ * `HandshakeRequest` / `HandshakeResponse` from
+ * `@dvai-bridge/core/src/pairing/types.ts`).
+ *
+ * A "pairing" is an authenticated trust relationship between two
+ * devices established once via the handshake flow, then reused for
+ * all subsequent offload requests via HMAC-signed headers.
+ *
+ * Pairings expire after [PairingPolicy] TTL (default 30 days) of
+ * inactivity.
+ */
+@Serializable
+data class Pairing(
+    /** Stable per-install device ID of the peer. */
+    val peerDeviceId: String,
+    /** Friendly name for the user UI (revoke / re-pair). */
+    val peerDeviceName: String,
+    /** Shared 256-bit pairing key (base64-url encoded). Used for HMAC. */
+    val pairingKey: String,
+    /** When the pairing was first established. */
+    val pairedAt: Long,
+    /** Last time this pairing was used for an offload request. */
+    val lastUsedAt: Long,
+    /** Pairing source — informational. */
+    val via: PairingSource,
+)
+
+@Serializable
+enum class PairingSource {
+    @kotlinx.serialization.SerialName("lan-handshake")
+    LAN_HANDSHAKE,
+    @kotlinx.serialization.SerialName("rendezvous-qr")
+    RENDEZVOUS_QR,
+}
+
+@Serializable
+data class HandshakeRequest(
+    val originDeviceId: String,
+    val originDeviceName: String,
+    val originVersion: String,
+    /** Initiator-side ephemeral nonce — included in the HMAC challenge. */
+    val nonce: String,
+)
+
+@Serializable
+data class HandshakeResponse(
+    /** Approved? */
+    val approved: Boolean,
+    /** If approved, the shared pairing key (base64-url). */
+    val pairingKey: String? = null,
+    /** If denied, the reason for the diagnostic. */
+    val reason: String? = null,
+)

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/pairing/PairingHandshake.kt

@@ -0,0 +1,126 @@
+package co.deepvoiceai.bridge.shared.core.pairing
+
+import java.security.MessageDigest
+import java.security.SecureRandom
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
+
+/**
+ * LAN-pairing handshake helpers (Kotlin mirror of
+ * `@dvai-bridge/core/src/pairing/handshake.ts`).
+ *
+ * The first time Device A wants to offload to Device B over the LAN,
+ * A POSTs `/v1/dvai/handshake` to B with its identity + a nonce. B
+ * surfaces a UI prompt to the user; on approve, B generates a 256-bit
+ * pairing key and returns it. From then on, A includes
+ * `X-DVAI-Pairing: HMAC-SHA256(pairingKey, body)` on every offload
+ * request to B.
+ *
+ * All keys + signatures use base64-url encoding, no padding.
+ *
+ * Implementation note: HMAC is via `javax.crypto.Mac` — we don't pull
+ * in BouncyCastle since AndroidKeyStore + the platform Mac provider
+ * already cover SHA-256 on every supported API level (24+).
+ */
+object PairingHandshake {
+    /** Generate a fresh 256-bit pairing key (base64-url encoded). */
+    fun generatePairingKey(): String {
+        val bytes = ByteArray(32)
+        SecureRandom().nextBytes(bytes)
+        return base64UrlEncode(bytes)
+    }
+
+    /** Generate a fresh 128-bit nonce for a handshake request. */
+    fun generateNonce(): String {
+        val bytes = ByteArray(16)
+        SecureRandom().nextBytes(bytes)
+        return base64UrlEncode(bytes)
+    }
+
+    /**
+     * HMAC-SHA256(key, message). Used to sign offload requests so the
+     * peer can verify they came from a paired device.
+     */
+    fun signHmac(pairingKey: String, message: String): String {
+        val keyBytes = decodeBase64UrlBytes(pairingKey)
+        val mac = Mac.getInstance("HmacSHA256")
+        mac.init(SecretKeySpec(keyBytes, "HmacSHA256"))
+        val sig = mac.doFinal(message.toByteArray(Charsets.UTF_8))
+        return base64UrlEncode(sig)
+    }
+
+    /** Verify an HMAC. Returns true on match (constant-time-ish). */
+    fun verifyHmac(pairingKey: String, message: String, signature: String): Boolean {
+        val expected = signHmac(pairingKey, message)
+        return constantTimeEquals(expected, signature)
+    }
+
+    /**
+     * Compose the canonical message that gets HMAC-signed for a
+     * peer-to-peer offload request. The peer recomputes the same
+     * string and verifies.
+     *
+     * Format: `${nonce}\n${method}\n${path}\n${bodyHash}` — bodyHash
+     * is the hex-encoded SHA-256 of the request body bytes (or 64
+     * zero-bytes for a missing body). Method is uppercased for
+     * canonicalization.
+     */
+    fun composeSignedMessage(
+        nonce: String,
+        method: String,
+        path: String,
+        body: String?,
+    ): String {
+        val bodyHash = if (body != null) sha256Hex(body) else "0".repeat(64)
+        return "$nonce\n${method.uppercase()}\n$path\n$bodyHash"
+    }
+
+    private fun sha256Hex(input: String): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        val bytes = digest.digest(input.toByteArray(Charsets.UTF_8))
+        val sb = StringBuilder(bytes.size * 2)
+        for (b in bytes) {
+            val v = b.toInt() and 0xff
+            sb.append(HEX[v shr 4]).append(HEX[v and 0x0f])
+        }
+        return sb.toString()
+    }
+
+    private val HEX = "0123456789abcdef".toCharArray()
+
+    internal fun base64UrlEncode(bytes: ByteArray): String {
+        val sb = StringBuilder()
+        val b64 = java.util.Base64.getEncoder().encodeToString(bytes)
+        for (c in b64) {
+            when (c) {
+                '+' -> sb.append('-')
+                '/' -> sb.append('_')
+                '=' -> Unit
+                else -> sb.append(c)
+            }
+        }
+        return sb.toString()
+    }
+
+    internal fun decodeBase64UrlBytes(s: String): ByteArray {
+        val sb = StringBuilder(s.length + 4)
+        for (c in s) {
+            when (c) {
+                '-' -> sb.append('+')
+                '_' -> sb.append('/')
+                else -> sb.append(c)
+            }
+        }
+        while (sb.length % 4 != 0) sb.append('=')
+        return java.util.Base64.getDecoder().decode(sb.toString())
+    }
+
+    private fun constantTimeEquals(a: String, b: String): Boolean {
+        if (a.length != b.length) return false
+        var diff = 0
+        for (i in a.indices) {
+            diff = diff or (a[i].code xor b[i].code)
+        }
+        return diff == 0
+    }
+}

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/pairing/PairingPolicy.kt

@@ -0,0 +1,145 @@
+package co.deepvoiceai.bridge.shared.core.pairing
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.withTimeoutOrNull
+
+/**
+ * A single pending pairing request surfaced to the host UI. Compose
+ * UIs collect these from [PairingPolicy.requests] and call either
+ * [respond] or — equivalently — fall through to the default-deny
+ * behaviour by ignoring the request until [PairingPolicy.approveOrFetch]
+ * times out.
+ */
+class PairingRequest internal constructor(
+    val peerDeviceId: String,
+    val peerDeviceName: String,
+    val via: PairingSource,
+    private val response: CompletableDeferred<Boolean>,
+) {
+    /** Approve / deny. Idempotent — a second call is a no-op. */
+    fun respond(approved: Boolean) {
+        response.complete(approved)
+    }
+
+    /** True once the host UI has decided. */
+    val isResolved: Boolean get() = response.isCompleted
+}
+
+/**
+ * Pairing decision flow (Kotlin mirror of `PairingPolicy` from
+ * `@dvai-bridge/core/src/pairing/policy.ts`).
+ *
+ * Coordinates the host-app UI (via [requests] `SharedFlow`) with the
+ * persistent [PairingStore].
+ *
+ * Default behaviour with no UI subscriber: deny incoming pairings
+ * after [requestTimeoutMs]. That's the safe fallback — apps that
+ * haven't wired UI shouldn't accidentally accept random LAN devices.
+ */
+class PairingPolicy(
+    private val store: PairingStore,
+    /** Pairing TTL in days. Default 30. */
+    private val expireAfterDays: Int = 30,
+    /** Default-deny timeout when no UI subscriber answers. Default 60s. */
+    private val requestTimeoutMs: Long = 60_000L,
+) {
+    // replay = 0 + buffer = 16: a request is dropped if no UI subscriber
+    // is listening + the buffer is full. We rely on the suspendable
+    // `approveOrFetch` to time out (default-deny) in that case rather
+    // than replaying — a late subscriber should NOT auto-approve a
+    // pairing request the user never saw a UI prompt for.
+    private val _requests = MutableSharedFlow<PairingRequest>(
+        replay = 0,
+        extraBufferCapacity = 16,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+
+    /** Hot stream of incoming pairing requests for the host UI to collect. */
+    val requests: SharedFlow<PairingRequest> = _requests.asSharedFlow()
+
+    /**
+     * Get an existing pairing, applying TTL expiry. Returns null if
+     * the pairing is missing or expired (auto-cleans expired entries).
+     */
+    fun getActive(peerDeviceId: String): Pairing? {
+        val existing = store.get(peerDeviceId) ?: return null
+        val ttlMs = expireAfterDays.toLong() * 24L * 60L * 60L * 1000L
+        if (System.currentTimeMillis() - existing.lastUsedAt > ttlMs) {
+            store.remove(peerDeviceId)
+            return null
+        }
+        return existing
+    }
+
+    /**
+     * Process an incoming pairing request. If we already have an
+     * active pairing for this peer, reuse it (and bump lastUsedAt).
+     * Otherwise emit a [PairingRequest] on [requests] and wait up to
+     * [requestTimeoutMs] for the UI to respond.
+     *
+     * Returns the resulting pairing on approval; throws
+     * [PairingDeniedException] otherwise.
+     */
+    suspend fun approveOrFetch(
+        peerDeviceId: String,
+        peerDeviceName: String,
+        via: PairingSource,
+    ): Pairing {
+        val existing = getActive(peerDeviceId)
+        if (existing != null) {
+            val touched = existing.copy(lastUsedAt = System.currentTimeMillis())
+            store.set(touched)
+            return touched
+        }
+
+        val deferred = CompletableDeferred<Boolean>()
+        val req = PairingRequest(peerDeviceId, peerDeviceName, via, deferred)
+        // tryEmit returns false if the buffer is full + no subscriber;
+        // in that case treat it the same as "no UI listening" — deny.
+        val emitted = _requests.tryEmit(req)
+        if (!emitted) {
+            throw PairingDeniedException(
+                peerDeviceId,
+                peerDeviceName,
+                "no UI subscriber for pairing requests",
+            )
+        }
+        val approved = withTimeoutOrNull(requestTimeoutMs) { deferred.await() } ?: false
+        if (!approved) {
+            throw PairingDeniedException(peerDeviceId, peerDeviceName, "denied or timed out")
+        }
+        val now = System.currentTimeMillis()
+        val fresh = Pairing(
+            peerDeviceId = peerDeviceId,
+            peerDeviceName = peerDeviceName,
+            pairingKey = PairingHandshake.generatePairingKey(),
+            pairedAt = now,
+            lastUsedAt = now,
+            via = via,
+        )
+        store.set(fresh)
+        return fresh
+    }
+
+    /** Mark a pairing as used (bumps lastUsedAt). */
+    fun touch(peerDeviceId: String) {
+        val existing = store.get(peerDeviceId) ?: return
+        store.set(existing.copy(lastUsedAt = System.currentTimeMillis()))
+    }
+
+    /** Forget a pairing — host UI surfaces this as "revoke". */
+    fun revoke(peerDeviceId: String) {
+        store.remove(peerDeviceId)
+    }
+}
+
+/** Thrown by [PairingPolicy.approveOrFetch] when the user denies / times out. */
+class PairingDeniedException(
+    val peerDeviceId: String,
+    val peerDeviceName: String,
+    reason: String,
+) : Exception("[DVAI/pairing] denied: $peerDeviceName ($peerDeviceId): $reason")

package/android/src/main/java/co/deepvoiceai/bridge/shared/core/pairing/PairingStore.kt

@@ -0,0 +1,76 @@
+package co.deepvoiceai.bridge.shared.core.pairing
+
+import android.content.Context
+import java.io.File
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+
+/**
+ * Persistent pairing store (Kotlin mirror of `NodeFsPairingStore`
+ * from `@dvai-bridge/core/src/pairing/store.ts`). Backed by
+ * a single JSON file under
+ * `applicationContext.cacheDir/dvai-bridge/pairings.json`.
+ */
+class PairingStore(context: Context) {
+    private val cacheRoot: File =
+        File(context.applicationContext.cacheDir, "dvai-bridge").also {
+            if (!it.exists()) it.mkdirs()
+        }
+    private val file: File = File(cacheRoot, "pairings.json")
+    private val json = Json { ignoreUnknownKeys = true; prettyPrint = true }
+    private val lock = Any()
+
+    @Serializable
+    private data class Persisted(val pairings: Map<String, Pairing> = emptyMap())
+
+    private fun load(): MutableMap<String, Pairing> = synchronized(lock) {
+        if (!file.exists()) return mutableMapOf()
+        return try {
+            val raw = file.readText(Charsets.UTF_8)
+            val parsed = json.decodeFromString(Persisted.serializer(), raw)
+            parsed.pairings.toMutableMap()
+        } catch (_: Throwable) {
+            mutableMapOf()
+        }
+    }
+
+    private fun save(map: Map<String, Pairing>) = synchronized(lock) {
+        try {
+            file.writeText(
+                json.encodeToString(Persisted.serializer(), Persisted(map)),
+                Charsets.UTF_8,
+            )
+        } catch (_: Throwable) {
+            // best-effort
+        }
+    }
+
+    fun get(peerDeviceId: String): Pairing? = load()[peerDeviceId]
+
+    fun set(p: Pairing) {
+        synchronized(lock) {
+            val map = load()
+            map[p.peerDeviceId] = p
+            save(map)
+        }
+    }
+
+    fun list(): List<Pairing> = load().values.toList()
+
+    fun remove(peerDeviceId: String) {
+        synchronized(lock) {
+            val map = load()
+            map.remove(peerDeviceId)
+            save(map)
+        }
+    }
+
+    fun clear() {
+        synchronized(lock) {
+            if (file.exists()) file.delete()
+        }
+    }
+
+    /** Path on disk — exposed for diagnostics + tests. */
+    fun storePath(): String = file.absolutePath
+}

package/android/src/test/java/co/deepvoiceai/bridge/shared/core/HandlerDispatchTest.kt

@@ -0,0 +1,74 @@
+package co.deepvoiceai.bridge.shared.core
+
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.server.routing.*
+import io.ktor.server.testing.*
+import kotlinx.serialization.json.*
+import org.junit.Assert.*
+import org.junit.Test
+
+class HandlerDispatchTest {
+    private val ctx = HandlerContext(modelId = "test-model", backendName = "shared")
+
+    private class FakeHandlers : DvaiHandlers {
+        override suspend fun handleChatCompletion(body: JsonObject, ctx: HandlerContext): HandlerResponse =
+            HandlerResponse.Json(200, buildJsonObject {
+                put("id", "chatcmpl-fake")
+                put("object", "chat.completion")
+            })
+
+        override suspend fun handleCompletion(body: JsonObject, ctx: HandlerContext): HandlerResponse =
+            HandlerResponse.Json(200, buildJsonObject { put("object", "text_completion") })
+
+        override suspend fun handleEmbeddings(body: JsonObject, ctx: HandlerContext): HandlerResponse =
+            HandlerResponse.Json(200, buildJsonObject { put("object", "list") })
+
+        override suspend fun handleModels(ctx: HandlerContext): HandlerResponse =
+            HandlerResponse.Json(200, buildJsonObject {
+                put("object", "list")
+                putJsonArray("data") {
+                    addJsonObject { put("id", ctx.modelId) }
+                }
+            })
+    }
+
+    @Test
+    fun `OPTIONS preflight returns 204 with PNA header`() = testApplication {
+        application {
+            routing {
+                installDispatchRoutes(FakeHandlers(), ctx, CorsConfig.Wildcard)
+            }
+        }
+        val response = client.options("/v1/chat/completions")
+        assertEquals(HttpStatusCode.NoContent, response.status)
+        assertEquals("true", response.headers["Access-Control-Allow-Private-Network"])
+        assertEquals("*", response.headers["Access-Control-Allow-Origin"])
+    }
+
+    @Test
+    fun `unknown path returns 404`() = testApplication {
+        application {
+            routing {
+                installDispatchRoutes(FakeHandlers(), ctx, CorsConfig.Wildcard)
+            }
+        }
+        val response = client.get("/v1/unknown")
+        assertEquals(HttpStatusCode.NotFound, response.status)
+    }
+
+    @Test
+    fun `GET v1 models returns canned`() = testApplication {
+        application {
+            routing {
+                installDispatchRoutes(FakeHandlers(), ctx, CorsConfig.Wildcard)
+            }
+        }
+        val response = client.get("/v1/models")
+        assertEquals(HttpStatusCode.OK, response.status)
+        val text = response.bodyAsText()
+        val json = Json.parseToJsonElement(text) as JsonObject
+        assertEquals("list", json["object"]!!.jsonPrimitive.content)
+    }
+}

package/android/src/test/java/co/deepvoiceai/bridge/shared/core/HttpServerTest.kt

@@ -0,0 +1,65 @@
+package co.deepvoiceai.bridge.shared.core
+
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Test
+
+class HttpServerTest {
+    private val servers = mutableListOf<HttpServer>()
+
+    @After
+    fun tearDown() = runBlocking {
+        servers.forEach { runCatching { it.stop() } }
+        servers.clear()
+    }
+
+    @Test
+    fun `bind base port when free`() = runBlocking {
+        val server = HttpServer().also { servers.add(it) }
+        val port = server.tryBind(basePort = 39101, maxAttempts = 4, host = "127.0.0.1")
+        assertEquals(39101, port)
+    }
+
+    @Test
+    fun `falls back to next port on conflict`() = runBlocking {
+        val blocker = HttpServer().also { servers.add(it) }
+        blocker.tryBind(basePort = 39110, maxAttempts = 1, host = "127.0.0.1")
+
+        val server = HttpServer().also { servers.add(it) }
+        val port = server.tryBind(basePort = 39110, maxAttempts = 4, host = "127.0.0.1")
+        assertEquals(39111, port)
+    }
+
+    @Test
+    fun `stop is idempotent`() = runBlocking {
+        val server = HttpServer().also { servers.add(it) }
+        // Stop before start — should not throw
+        server.stop()
+        server.tryBind(basePort = 39120, maxAttempts = 1, host = "127.0.0.1")
+        server.stop()
+        // Double-stop — should not throw
+        server.stop()
+    }
+
+    @Test
+    fun `throws actionable error when all ports blocked`() = runBlocking {
+        @Suppress("UNUSED_VARIABLE")
+        val blockers = (0 until 3).map { i ->
+            HttpServer().also {
+                servers.add(it)
+                it.tryBind(basePort = 39130 + i, maxAttempts = 1, host = "127.0.0.1")
+            }
+        }
+        val server = HttpServer().also { servers.add(it) }
+        try {
+            server.tryBind(basePort = 39130, maxAttempts = 3, host = "127.0.0.1")
+            fail("Expected exception")
+        } catch (e: IllegalStateException) {
+            assertTrue(
+                "Error should name the tried range: ${e.message}",
+                e.message?.contains("39130..39132") == true,
+            )
+        }
+    }
+}

package/android/src/test/java/co/deepvoiceai/bridge/shared/core/capability/CapabilityCacheTest.kt

@@ -0,0 +1,107 @@
+package co.deepvoiceai.bridge.shared.core.capability
+
+import androidx.test.core.app.ApplicationProvider
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Unit tests for the JSON-on-disk [CapabilityCache] adapter. Uses
+ * Robolectric for `Context.cacheDir` — same approach the existing
+ * shared-core HTTP tests use for context-dependent code.
+ */
+@RunWith(RobolectricTestRunner::class)
+class CapabilityCacheTest {
+
+    private val ctx = ApplicationProvider.getApplicationContext<android.content.Context>()
+    private val cache = CapabilityCache(ctx)
+
+    @After
+    fun cleanup() {
+        cache.clear()
+    }
+
+    @Test
+    fun `empty cache returns null on get`() {
+        cache.clear()
+        val score = cache.get(CapabilityCacheKey("model-x", "3.0.0"))
+        assertNull(score)
+    }
+
+    @Test
+    fun `set then get round-trips`() {
+        val score = CapabilityScore(
+            modelId = "qwen-1.5b",
+            deviceId = "test-device",
+            libraryVersion = "3.0.0",
+            tokPerSec = 28.4,
+            source = ScoreSource.PROBE,
+            measuredAt = 1_700_000_000_000L,
+        )
+        cache.set(score)
+        val got = cache.get(CapabilityCacheKey("qwen-1.5b", "3.0.0"))
+        assertNotNull(got)
+        assertEquals(28.4, got!!.tokPerSec, 0.0001)
+        assertEquals("test-device", got.deviceId)
+        assertEquals(ScoreSource.PROBE, got.source)
+    }
+
+    @Test
+    fun `library version is part of the key`() {
+        val s1 = CapabilityScore("m", "d", "3.0.0", 10.0, ScoreSource.HEURISTIC, 1L)
+        val s2 = CapabilityScore("m", "d", "3.1.0", 20.0, ScoreSource.HEURISTIC, 2L)
+        cache.set(s1)
+        cache.set(s2)
+        assertEquals(10.0, cache.get(CapabilityCacheKey("m", "3.0.0"))!!.tokPerSec, 0.0001)
+        assertEquals(20.0, cache.get(CapabilityCacheKey("m", "3.1.0"))!!.tokPerSec, 0.0001)
+    }
+
+    @Test
+    fun `list returns all entries`() {
+        cache.set(CapabilityScore("a", "d", "3.0.0", 1.0, ScoreSource.PROBE, 1L))
+        cache.set(CapabilityScore("b", "d", "3.0.0", 2.0, ScoreSource.PROBE, 2L))
+        val all = cache.list()
+        assertEquals(2, all.size)
+    }
+
+    @Test
+    fun `clear empties the cache`() {
+        cache.set(CapabilityScore("x", "d", "3.0.0", 99.0, ScoreSource.HEURISTIC, 0L))
+        assertNotNull(cache.get(CapabilityCacheKey("x", "3.0.0")))
+        cache.clear()
+        assertNull(cache.get(CapabilityCacheKey("x", "3.0.0")))
+    }
+
+    @Test
+    fun `cachePath is under cacheDir`() {
+        val p = cache.cachePath()
+        assertTrue("expected dvai-bridge segment in $p", p.contains("dvai-bridge"))
+        assertTrue("expected capability.json in $p", p.endsWith("capability.json"))
+    }
+
+    @Test
+    fun `DeviceID generate produces base64-url string`() {
+        val id = DeviceID.generate()
+        assertTrue("got: $id", id.matches(Regex("^[A-Za-z0-9_-]+$")))
+        assertTrue("expected length >= 20, got ${id.length}", id.length >= 20)
+    }
+
+    @Test
+    fun `DeviceID get is stable across calls`() {
+        val a = DeviceID.get(ctx)
+        val b = DeviceID.get(ctx)
+        assertEquals(a, b)
+    }
+
+    @Test
+    fun `DeviceID reset produces a fresh id`() {
+        val a = DeviceID.get(ctx)
+        val b = DeviceID.reset(ctx)
+        assertTrue("reset should be different from current — got $a == $b", a != b)
+    }
+}