pakstr 1.0.0 → 1.0.1

package/android-template/app/src/main/java/com/pakstr/app/signer/AmberRequestChannel.kt

@@ -0,0 +1,156 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withTimeout
+import java.util.UUID
+
+/**
+ * Matches NIP-55 activity results to the request that launched them.
+ *
+ * One ActivityResultLauncher delivers every result through the same
+ * callback, so one channel serves the launcher and at most one signer
+ * activity is outstanding at a time. Each launch carries an `id` extra.
+ *
+ * Every launch yields exactly one result. A request abandoned by its caller
+ * (timeout, cancellation, closed session) therefore keeps its slot until its
+ * result arrives, and a result echoing a different id means the matching one
+ * can never follow: the outstanding request fails without receiving that
+ * result's data and the slot is released.
+ */
+internal class AmberRequestChannel(
+    private val timeoutMillis: Long = DEFAULT_TIMEOUT_MILLIS,
+    private val newRequestId: () -> String = { UUID.randomUUID().toString() }
+) {
+    private val mutex = Mutex()
+    private val lock = Any()
+    private var outstanding: Outstanding? = null // guarded by lock
+
+    private class Outstanding(val id: String) {
+        val result = CompletableDeferred<String>()
+    }
+
+    /** Opens a request session for one AmberSigner instance. */
+    fun openSession(): Session = Session()
+
+    /**
+     * Resolves the outstanding request with [outcome]. A [requestId] of null
+     * (signers that do not echo ids, cancelled activities) matches the
+     * outstanding request. Returns false if the result was not delivered.
+     */
+    fun deliver(requestId: String?, outcome: Result<String>): Boolean {
+        val current = synchronized(lock) {
+            outstanding.also { outstanding = null }
+        } ?: return false
+        if (requestId != null && requestId != current.id) {
+            current.result.completeExceptionally(AmberResponseMismatchException())
+            return false
+        }
+        outcome.fold(current.result::complete, current.result::completeExceptionally)
+        return true
+    }
+
+    private suspend fun exchange(
+        session: Session,
+        start: (requestId: String) -> Unit
+    ): String = mutex.withLock {
+        // Wait out an abandoned launch so its result cannot resolve this one.
+        synchronized(lock) { outstanding }?.result?.join()
+
+        val current = Outstanding(newRequestId())
+        // Holding the session lock makes close() and launch mutually exclusive.
+        synchronized(session) {
+            if (session.closed) throw closedException()
+            synchronized(lock) { outstanding = current }
+            try {
+                start(current.id)
+            } catch (error: Throwable) {
+                synchronized(lock) {
+                    if (outstanding === current) outstanding = null
+                }
+                throw error
+            }
+        }
+        current.result.await()
+    }
+
+    inner class Session internal constructor() {
+        internal var closed = false // guarded by this
+        private val waiters = mutableSetOf<CompletableDeferred<String>>()
+
+        /**
+         * Runs [block] under the request timeout, failing with
+         * [AmberRequestTimeoutException] instead of a cancellation so callers
+         * still get an error response.
+         */
+        suspend fun <T> withRequestTimeout(block: suspend () -> T): T {
+            return try {
+                withTimeout(timeoutMillis) { block() }
+            } catch (_: TimeoutCancellationException) {
+                throw AmberRequestTimeoutException()
+            }
+        }
+
+        /**
+         * Waits for the signer to be free, calls [start] with the request id
+         * and suspends until the matching result is delivered. If [start]
+         * throws, nothing is outstanding and the exception propagates.
+         */
+        suspend fun request(start: (requestId: String) -> Unit): String = coroutineScope {
+            val waiter = CompletableDeferred<String>()
+            synchronized(this@Session) {
+                if (closed) throw closedException()
+                waiters += waiter
+            }
+            val worker = launch {
+                try {
+                    waiter.complete(exchange(this@Session, start))
+                } catch (error: Throwable) {
+                    waiter.completeExceptionally(error)
+                }
+            }
+            try {
+                waiter.await()
+            } finally {
+                worker.cancel()
+                synchronized(this@Session) { waiters -= waiter }
+            }
+        }
+
+        /**
+         * Fails this session's waiting and queued requests and rejects new
+         * ones. A launch already in flight keeps the slot until its result.
+         */
+        fun close() {
+            val pending = synchronized(this) {
+                closed = true
+                waiters.toList()
+            }
+            pending.forEach { it.completeExceptionally(closedException()) }
+        }
+    }
+
+    private fun closedException() =
+        SignerUnavailableException("Amber signer was closed")
+
+    companion object {
+        const val DEFAULT_TIMEOUT_MILLIS = 30_000L
+    }
+}
+
+class AmberRequestTimeoutException : Exception(
+    "Amber request timed out"
+)
+
+class AmberRequestRejectedException : Exception(
+    "Amber request was rejected"
+)
+
+class AmberResponseMismatchException : Exception(
+    "Amber returned a response for a different request"
+)

package/android-template/app/src/main/java/com/pakstr/app/signer/AmberSigner.kt

@@ -7,12 +7,10 @@ import android.net.Uri
 import androidx.activity.result.ActivityResult
 import androidx.activity.result.ActivityResultLauncher
 import com.pakstr.app.crypto.NostrEventVerifier
-import com.pakstr.app.debug.AppDebugLogger
 import com.pakstr.app.signer.interfaces.NostrSigner
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.json.JSONObject
-import kotlin.coroutines.resume
 
 /**
  * NIP-07 signer implementation using Amber as an external signer.
@@ -31,170 +29,86 @@ import kotlin.coroutines.resume
  *      After receiving the signature, the event ID is generated and the
  *      signature is locally verified before returning the signed event.
  *
- * The class uses suspendCancellableCoroutine to bridge the asynchronous
- * Android Activity Result API with Kotlin coroutines.
+ * Concurrent requests are serialized and matched to their activity results
+ * by [AmberRequestChannel].
  */
-class AmberSigner(
-    private val launcher: ActivityResultLauncher<Intent>
+class AmberSigner internal constructor(
+    private val launcher: ActivityResultLauncher<Intent>,
+    private val channel: AmberRequestChannel
 ) : NostrSigner {
 
-    // Stores the current pending signer request.
-    // Android intents return results asynchronously, so the callback is used
-    // to resume the suspended coroutine when Amber responds.
-    private var pendingCallback: ((String) -> Unit)? = null
-    private var cachedPubkey: String? = null
-    override suspend fun getPublicKey(): String {
-
-        cachedPubkey?.let {
-
-            return it
-
-        }
-
-        return withTimeout(30_000) {
-
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { pubkey ->
-
-                    cachedPubkey = pubkey
-
-                    if (continuation.isActive) {
-
-                        continuation.resume(pubkey)
-
-                    }
-
-                }
-
-                val intent = Intent(
-
-                    Intent.ACTION_VIEW
-
-                ).apply {
-
-                    data = Uri.parse(
-
-                        "nostrsigner:?type=get_public_key"
-
-                    )
-
-                    putExtra(
-
-                        "type",
-
-                        "get_public_key"
+    constructor(
+        launcher: ActivityResultLauncher<Intent>
+    ) : this(launcher, AmberRequestChannel())
 
-                    )
-
-                }
-
-                try {
+    private val session = channel.openSession()
 
-                    launcher.launch(intent)
+    private val pubkeyMutex = Mutex()
 
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-
-                        continuation.resume("")
+    @Volatile
+    private var cachedPubkey: String? = null
 
+    override suspend fun getPublicKey(): String {
+        cachedPubkey?.let { return it }
+
+        return session.withRequestTimeout {
+            // Concurrent callers share one Amber prompt.
+            pubkeyMutex.withLock {
+                cachedPubkey ?: send(
+                    Intent(Intent.ACTION_VIEW).apply {
+                        data = Uri.parse("nostrsigner:?type=get_public_key")
+                        putExtra("type", "get_public_key")
                     }
-
+                ).also { pubkey ->
+                    if (pubkey.isNotBlank()) cachedPubkey = pubkey
                 }
-
-                continuation.invokeOnCancellation {
-
-                    pendingCallback = null
-
-                }
-
             }
-
         }
-
     }
 
     override suspend fun signEvent(
         eventJson: String
     ): String =
-        withTimeout(30_000) {
-
+        session.withRequestTimeout {
             val event = JSONObject(eventJson)
 
             val currentPubkey = event.optString("pubkey")
 
             if (currentPubkey.isBlank()) {
-
                 val amberPubkey = getPublicKey()
 
                 require(amberPubkey.isNotBlank()) {
-
                     "Amber returned empty pubkey"
-
                 }
 
-                event.put(
-
-                    "pubkey",
-
-                    amberPubkey
+                event.put("pubkey", amberPubkey)
+            }
 
+            val intent = Intent(
+                Intent.ACTION_VIEW,
+                Uri.parse(
+                    "nostrsigner:${Uri.encode(event.toString())}"
                 )
-
+            ).apply {
+                putExtra("type", "sign_event")
             }
 
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { signature ->
-
-                    if (signature.isEmpty()) {
-
-                        continuation.resume("")
-
-                    } else {
-
-                        val signedEvent =
-                            NostrEventBuilder.addId(event)
-                                .apply {
-                                    put(
-                                        "sig",
-                                        signature
-                                    )
-                                }
-
-
-                        val verified =
-                            NostrEventVerifier.verify(
-                                signedEvent
-                            )
-
-
-                        if (verified) {
-                            continuation.resume(
-                                signedEvent.toString()
-                            )
-                        } else {
-                            continuation.resume("")
-                        }
-                    }
-                }
+            val signature = session.request { requestId ->
+                launcher.launch(intent.putExtra("id", requestId))
+            }
 
+            if (signature.isEmpty()) {
+                ""
+            } else {
+                val signedEvent =
+                    NostrEventBuilder.addId(event)
+                        .apply { put("sig", signature) }
 
-                val intent = Intent(
-                    Intent.ACTION_VIEW,
-                    Uri.parse(
-                        "nostrsigner:${Uri.encode(event.toString())}"
-                    )
-                ).apply {
-                    putExtra(
-                        "type",
-                        "sign_event"
-                    )
+                if (NostrEventVerifier.verify(signedEvent)) {
+                    signedEvent.toString()
+                } else {
+                    ""
                 }
-
-
-                launcher.launch(intent)
             }
         }
 
@@ -202,297 +116,135 @@ class AmberSigner(
         pubkey: String,
         plaintext: String
     ): String =
-        withTimeout(30_000) {
-
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { encrypted ->
-
-                    if (continuation.isActive) {
-                        continuation.resume(encrypted)
-                    }
-                }
-
-                val intent = Intent(
-                    Intent.ACTION_VIEW
-                ).apply {
-
+        session.withRequestTimeout {
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
                     data = Uri.parse(
                         "nostrsigner:?type=nip04_encrypt" +
                                 "&pubkey=$pubkey" +
                                 "&plaintext=${Uri.encode(plaintext)}"
                     )
-
-                    putExtra(
-                        "type",
-                        "nip04_encrypt"
-                    )
-
-                    putExtra(
-                        "pubkey",
-                        pubkey
-                    )
-
-                    putExtra(
-                        "plaintext",
-                        plaintext
-                    )
-                }
-
-                try {
-
-                    launcher.launch(intent)
-
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-                        continuation.resume("")
-                    }
+                    putExtra("type", "nip04_encrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("plaintext", plaintext)
                 }
-
-                continuation.invokeOnCancellation {
-                    pendingCallback = null
-                }
-            }
+            )
         }
 
     override suspend fun nip04Decrypt(
         pubkey: String,
         ciphertext: String
-    ): String = withTimeout(30_000) {
-
-        suspendCancellableCoroutine { continuation ->
-
-            pendingCallback = { result ->
-
-                if (continuation.isActive) {
-                    continuation.resume(result)
-                }
-            }
-
-            val intent = Intent(
-                Intent.ACTION_VIEW
-            ).apply {
-
-                data = Uri.parse(
-                    "nostrsigner:?type=nip04_decrypt" +
-                            "&pubkey=$pubkey" +
-                            "&message=${Uri.encode(ciphertext)}"
-                )
-
-                putExtra(
-                    "type",
-                    "nip04_decrypt"
-                )
-
-                putExtra(
-                    "pubkey",
-                    pubkey
-                )
-
-                putExtra(
-                    "message",
-                    ciphertext
-                )
-            }
-
-            try {
-
-                launcher.launch(intent)
-
-            } catch (_: ActivityNotFoundException) {
-
-                if (continuation.isActive) {
-                    continuation.resume("")
+    ): String =
+        session.withRequestTimeout {
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse(
+                        "nostrsigner:?type=nip04_decrypt" +
+                                "&pubkey=$pubkey" +
+                                "&message=${Uri.encode(ciphertext)}"
+                    )
+                    putExtra("type", "nip04_decrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("message", ciphertext)
                 }
-            }
-
-            continuation.invokeOnCancellation {
-                pendingCallback = null
-            }
+            )
         }
-    }
 
     override suspend fun nip44Encrypt(
-
         pubkey: String,
-
         plaintext: String
-
     ): String =
-
-        withTimeout(30_000) {
-
+        session.withRequestTimeout {
             val currentUser = getCachedPublicKey()
-
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { encrypted ->
-
-                    if (continuation.isActive) {
-
-                        continuation.resume(encrypted)
-
-                    }
-
-                }
-
-                val intent = Intent(
-
-                    Intent.ACTION_VIEW
-
-                ).apply {
-
-                    data = Uri.parse(
-
-                        "nostrsigner:${Uri.encode(plaintext)}"
-
-                    )
-
-                    putExtra(
-
-                        "type",
-
-                        "nip44_encrypt"
-
-                    )
-
-                    putExtra(
-
-                        "pubkey",
-
-                        pubkey
-
-                    )
-
-                    putExtra(
-
-                        "current_user",
-
-                        currentUser
-
-                    )
-
-                }
-
-                try {
-
-                    launcher.launch(intent)
-
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-
-                        continuation.resume("")
-
-                    }
-
-                }
-
-                continuation.invokeOnCancellation {
-
-                    pendingCallback = null
-
-                }
-
-            }
-
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse("nostrsigner:${Uri.encode(plaintext)}")
+                    putExtra("type", "nip44_encrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("current_user", currentUser)
+                }
+            )
         }
 
     override suspend fun nip44Decrypt(
         pubkey: String,
         ciphertext: String
     ): String =
-        withTimeout(30_000) {
+        session.withRequestTimeout {
             val currentUser = getCachedPublicKey()
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { result ->
-
-                    if (continuation.isActive) {
-                        continuation.resume(result)
-                    }
-                }
-
-                val intent = Intent(
-                    Intent.ACTION_VIEW
-                ).apply {
-
-                    data = Uri.parse(
-                        "nostrsigner:${Uri.encode(ciphertext)}"
-                    )
-
-                    putExtra(
-                        "type",
-                        "nip44_decrypt"
-                    )
-
-                    putExtra(
-                        "pubkey",
-                        pubkey
-                    )
-
-                    putExtra(
-                        "current_user",
-                        currentUser
-                    )
-                }
-
-                try {
-
-                    launcher.launch(intent)
-
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-                        continuation.resume("")
-                    }
-                }
-
-
-                continuation.invokeOnCancellation {
-                    pendingCallback = null
-                }
-            }
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse("nostrsigner:${Uri.encode(ciphertext)}")
+                    putExtra("type", "nip44_decrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("current_user", currentUser)
+                }
+            )
         }
 
+    /**
+     * Delivers an Amber activity result to the request that launched it.
+     * Returns false if no outstanding request matched and it was dropped.
+     */
     fun onResult(
         result: ActivityResult
-    ) {
-
-        val callback = pendingCallback
-
-        pendingCallback = null
+    ): Boolean = channel.deliver(result)
+
+    /**
+     * Fails this signer's waiting requests and stops it launching Amber;
+     * used when the signer is replaced.
+     */
+    fun close() {
+        session.close()
+    }
 
-        if (result.resultCode != Activity.RESULT_OK) {
-            callback?.let {
-                it("")
+    /** Launches [intent] and waits for its result; "" if Amber is missing. */
+    private suspend fun send(intent: Intent): String {
+        return try {
+            session.request { requestId ->
+                launcher.launch(intent.putExtra("id", requestId))
             }
-            return
-
+        } catch (_: ActivityNotFoundException) {
+            ""
         }
-
-        val value =
-
-            result.data?.getStringExtra("result")
-
-                ?: result.data?.getStringExtra("event")
-
-                ?: result.data?.getStringExtra("signature")
-
-                ?: result.data?.getStringExtra("plaintext")
-
-                ?: result.data?.getStringExtra("message")
-                ?: result.data?.getStringExtra("content")
-
-                ?: ""
-        
-        callback?.invoke(value)
     }
 
     private suspend fun getCachedPublicKey(): String {
-
         return cachedPubkey ?: getPublicKey()
-
     }
-}
+}
+
+/** Delivers [result] to the request it answers; see [AmberRequestChannel.deliver]. */
+internal fun AmberRequestChannel.deliver(result: ActivityResult): Boolean {
+    val data = result.data
+    return deliver(
+        data?.getStringExtra("id"),
+        amberResultOutcome(
+            resultCode = result.resultCode,
+            rejected = data?.getBooleanExtra("rejected", false) == true,
+            extra = { name -> data?.getStringExtra(name) }
+        )
+    )
+}
+
+/**
+ * Maps an Amber activity result to the value its request resolves with.
+ * A NIP-55 rejection fails the request and none of its extras are read.
+ */
+internal fun amberResultOutcome(
+    resultCode: Int,
+    rejected: Boolean,
+    extra: (String) -> String?
+): Result<String> = when {
+    resultCode != Activity.RESULT_OK -> Result.success("")
+    rejected -> Result.failure(AmberRequestRejectedException())
+    else -> Result.success(
+        extra("result")
+            ?: extra("event")
+            ?: extra("signature")
+            ?: extra("plaintext")
+            ?: extra("message")
+            ?: extra("content")
+            ?: ""
+    )
+}

package/android-template/app/src/main/java/com/pakstr/app/signer/SignerManager.kt

@@ -39,6 +39,10 @@ class SignerManager(
         LocalAccountStore(this.context)
     }
 
+    // One channel per launcher, shared by every AmberSigner instance, so a
+    // replaced signer's Amber activity still holds the slot until it returns.
+    private val amberChannel = AmberRequestChannel()
+
     private var activeSigner: NostrSigner? = null
     private var currentUserPubkey: String? = null
     private var pendingPairing: PendingPairing? = null
@@ -317,7 +321,13 @@ class SignerManager(
             "AMBER",
             "Activity result received: ${result.resultCode}"
         )
-        (activeSigner as? AmberSigner)?.onResult(result)
+        if (!amberChannel.deliver(result)) {
+            AppDebugLogger.log(
+                context,
+                "AMBER",
+                "Activity result ignored: no matching request"
+            )
+        }
     }
 
     private fun createAmberSigner(): AmberSigner {
@@ -336,7 +346,7 @@ class SignerManager(
                 "Amber signer application is not installed"
             )
         }
-        return AmberSigner(amberLauncher)
+        return AmberSigner(amberLauncher, amberChannel)
     }
 
     private fun createBunkerSigner(): BunkerSigner {
@@ -427,6 +437,7 @@ class SignerManager(
 
     private fun closeActiveSigner() {
         (activeSigner as? BunkerSigner)?.close()
+        (activeSigner as? AmberSigner)?.close()
         activeSigner = null
         currentUserPubkey = null
     }

package/android-template/app/src/test/java/com/pakstr/app/signer/AmberRequestChannelTest.kt

@@ -0,0 +1,294 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.util.concurrent.atomic.AtomicInteger
+
+class AmberRequestChannelTest {
+    private val launched = Channel<String>(Channel.UNLIMITED)
+    private val ids = AtomicInteger()
+
+    // Failed requests must not cancel the test body that awaits them.
+    private val requests = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    @After
+    fun cancelRequests() {
+        requests.cancel()
+    }
+
+    private fun channel(timeoutMillis: Long = 5_000) =
+        AmberRequestChannel(timeoutMillis) { "req-${ids.incrementAndGet()}" }
+
+    @Test
+    fun concurrent_requests_launch_one_at_a_time_and_get_their_own_results() = runBlocking {
+        val channel = channel()
+        val session = channel.openSession()
+        val pending = (1..3).map { request(session) }
+
+        val results = mutableMapOf<String, String>()
+        repeat(3) {
+            val id = nextLaunch()
+            assertNoLaunch()
+            assertTrue(channel.deliver(id, Result.success("result-$id")))
+            results[id] = "result-$id"
+        }
+
+        assertEquals(results.values.toSet(), pending.map { it.await() }.toSet())
+    }
+
+    @Test
+    fun duplicate_and_unexpected_results_are_dropped() = runBlocking {
+        val channel = channel()
+        val session = channel.openSession()
+        assertFalse(channel.deliver(null, Result.success("nobody asked")))
+
+        val pending = request(session)
+        val id = nextLaunch()
+        assertTrue(channel.deliver(id, Result.success("right")))
+        assertFalse(channel.deliver(id, Result.success("duplicate")))
+        assertFalse(channel.deliver(null, Result.success("duplicate")))
+        assertEquals("right", pending.await())
+    }
+
+    @Test
+    fun results_without_an_id_resolve_the_outstanding_request() = runBlocking {
+        val channel = channel()
+        val pending = request(channel.openSession())
+        nextLaunch()
+
+        assertTrue(channel.deliver(null, Result.success("")))
+        assertEquals("", pending.await())
+    }
+
+    @Test
+    fun mismatched_result_fails_the_request_without_its_data_and_frees_the_slot() = runBlocking {
+        val channel = channel()
+        val session = channel.openSession()
+        val pending = request(session)
+        nextLaunch()
+        val queued = request(session)
+        assertNoLaunch()
+
+        assertFalse(channel.deliver("other-request", Result.success("secret payload")))
+
+        val error = failure(pending)
+        assertTrue(error is AmberResponseMismatchException)
+        assertFalse(error?.message.orEmpty().contains("secret payload"))
+
+        // The queued request launches and receives only its own result.
+        val id = nextLaunch()
+        assertEquals("req-2", id)
+        assertTrue(channel.deliver(id, Result.success("fresh")))
+        assertEquals("fresh", queued.await())
+    }
+
+    @Test
+    fun mismatched_result_releases_a_slot_held_by_an_abandoned_request() = runBlocking {
+        val channel = channel(timeoutMillis = 100)
+        val session = channel.openSession()
+        val abandoned = request(session)
+        nextLaunch()
+        assertTrue(failure(abandoned) is AmberRequestTimeoutException)
+
+        val next = request(session, timeout = false)
+        assertNoLaunch()
+
+        assertFalse(channel.deliver("other-request", Result.success("secret payload")))
+        val id = nextLaunch()
+        assertTrue(channel.deliver(id, Result.success("fresh")))
+        assertEquals("fresh", next.await())
+    }
+
+    @Test
+    fun rejected_result_fails_the_request_and_frees_the_slot() = runBlocking {
+        val channel = channel()
+        val session = channel.openSession()
+        val pending = request(session)
+        val id = nextLaunch()
+
+        assertTrue(channel.deliver(id, Result.failure(AmberRequestRejectedException())))
+        assertTrue(failure(pending) is AmberRequestRejectedException)
+
+        val next = request(session)
+        val nextId = nextLaunch()
+        assertTrue(channel.deliver(nextId, Result.success("ok")))
+        assertEquals("ok", next.await())
+    }
+
+    @Test
+    fun timeout_fails_with_a_regular_exception_and_late_result_does_not_leak() = runBlocking {
+        val channel = channel(timeoutMillis = 100)
+        val session = channel.openSession()
+        val abandoned = request(session)
+        nextLaunch()
+        val error = failure(abandoned)
+        assertTrue(error is AmberRequestTimeoutException)
+        assertEquals("Amber request timed out", error?.message)
+
+        val next = request(session, timeout = false)
+        assertNoLaunch()
+
+        // The abandoned activity's id-less result drains its own slot.
+        assertTrue(channel.deliver(null, Result.success("late")))
+        val id = nextLaunch()
+        assertTrue(channel.deliver(id, Result.success("fresh")))
+        assertEquals("fresh", next.await())
+    }
+
+    @Test
+    fun cancelled_caller_keeps_its_slot_until_its_result_arrives() = runBlocking {
+        val channel = channel()
+        val session = channel.openSession()
+        val cancelled = request(session)
+        val cancelledId = nextLaunch()
+        cancelled.cancelAndJoin()
+
+        val next = request(session)
+        assertNoLaunch()
+
+        assertTrue(channel.deliver(cancelledId, Result.success("late")))
+        val id = nextLaunch()
+        assertTrue(channel.deliver(id, Result.success("fresh")))
+        assertEquals("fresh", next.await())
+    }
+
+    @Test
+    fun requests_timing_out_in_the_queue_are_never_launched() = runBlocking {
+        val channel = channel(timeoutMillis = 100)
+        val session = channel.openSession()
+        val first = request(session)
+        val firstId = nextLaunch()
+        val queued = request(session)
+
+        assertTrue(failure(queued) is AmberRequestTimeoutException)
+        assertTrue(failure(first) is AmberRequestTimeoutException)
+        assertTrue(channel.deliver(firstId, Result.success("late")))
+        assertNoLaunch()
+    }
+
+    @Test
+    fun launch_failure_propagates_and_frees_the_signer() = runBlocking {
+        val channel = channel()
+        val session = channel.openSession()
+        assertThrows(IllegalStateException::class.java) {
+            runBlocking {
+                session.request { throw IllegalStateException("no activity") }
+            }
+        }
+
+        val next = request(session)
+        val id = nextLaunch()
+        assertTrue(channel.deliver(id, Result.success("ok")))
+        assertEquals("ok", next.await())
+    }
+
+    @Test
+    fun closing_a_session_fails_its_requests_at_once_and_queued_ones_never_launch() = runBlocking {
+        val channel = channel()
+        val old = channel.openSession()
+        val inFlight = request(old)
+        val inFlightId = nextLaunch()
+        val queued = request(old)
+        assertNoLaunch()
+
+        old.close()
+
+        withTimeout(1_000) {
+            assertTrue(failure(inFlight) is SignerUnavailableException)
+            assertTrue(failure(queued) is SignerUnavailableException)
+        }
+        assertTrue(failure(request(old)) is SignerUnavailableException)
+
+        // The old session's Amber activity still drains its own slot.
+        assertTrue(channel.deliver(inFlightId, Result.success("late")))
+        assertNoLaunch()
+    }
+
+    @Test
+    fun session_closed_just_before_launch_never_launches() = runBlocking {
+        lateinit var session: AmberRequestChannel.Session
+        // newRequestId runs after the request has its turn, right before launch.
+        val channel = AmberRequestChannel(5_000) { session.close(); "req-1" }
+        session = channel.openSession()
+
+        assertTrue(failure(request(session)) is SignerUnavailableException)
+        assertNoLaunch()
+        assertFalse(channel.deliver(null, Result.success("nobody asked")))
+    }
+
+    @Test
+    fun replacement_session_waits_for_the_closed_sessions_launch_and_gets_only_its_own_result() = runBlocking {
+        val channel = channel()
+        val old = channel.openSession()
+        val stale = request(old)
+        val staleId = nextLaunch()
+        old.close()
+        assertTrue(failure(stale) is SignerUnavailableException)
+
+        val replacement = channel.openSession()
+        val next = request(replacement)
+        assertNoLaunch()
+
+        // The stale result answers the old launch, not the replacement's request.
+        assertTrue(channel.deliver(staleId, Result.success("stale payload")))
+        val id = nextLaunch()
+        assertFalse(next.isCompleted)
+        assertTrue(channel.deliver(id, Result.success("fresh")))
+        assertEquals("fresh", next.await())
+    }
+
+    @Test
+    fun result_outcome_follows_nip55_result_codes_and_rejection() {
+        val extras = mapOf("result" to "sig", "event" to "{}", "id" to "req-1")
+
+        assertEquals("sig", amberResultOutcome(RESULT_OK, false, extras::get).getOrThrow())
+        assertEquals("{}", amberResultOutcome(RESULT_OK, false, mapOf("event" to "{}")::get).getOrThrow())
+        assertEquals("", amberResultOutcome(RESULT_OK, false, emptyMap<String, String>()::get).getOrThrow())
+        assertEquals("", amberResultOutcome(RESULT_CANCELED, false, extras::get).getOrThrow())
+
+        val read = mutableListOf<String>()
+        val rejected = amberResultOutcome(RESULT_OK, true) { name -> read += name; extras[name] }
+        assertTrue(rejected.exceptionOrNull() is AmberRequestRejectedException)
+        assertEquals(emptyList<String>(), read)
+    }
+
+    private fun request(
+        session: AmberRequestChannel.Session,
+        timeout: Boolean = true
+    ): Deferred<String> = requests.async {
+        val call = suspend { session.request { id -> launched.trySend(id) } }
+        if (timeout) session.withRequestTimeout { call() } else call()
+    }
+
+    private suspend fun failure(request: Deferred<String>): Throwable? =
+        runCatching { request.await() }.exceptionOrNull()
+
+    private suspend fun nextLaunch(): String =
+        withTimeout(2_000) { launched.receive() }
+
+    private suspend fun assertNoLaunch() {
+        delay(150)
+        assertTrue(launched.tryReceive().isFailure)
+    }
+
+    private companion object {
+        const val RESULT_OK = -1
+        const val RESULT_CANCELED = 0
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",