ADFA-4128 (11/11): address CodeRabbit review

- F1723-1 put QuickBuildPipelineTest into the suite that actually runs
- F1723-4 guard the deferred prebuild fire() against a throw

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FstXxJ5cwWPcvmhZ9vJgJ7

Author: fryanpan

app/src/androidTest/kotlin/com/itsaky/androidide/OrderedTestSuite.kt

@@ -7,6 +7,7 @@ import org.junit.runners.Suite
 @Suite.SuiteClasses(
 	CleanupTest::class,
 	EndToEndTest::class,
+	QuickBuildPipelineTest::class,
 	QuickBuildSmokeTest::class,
 	QuickBuildFlagOffTest::class,
 )

app/src/main/java/com/itsaky/androidide/quickbuild/QuickBuildPrebuildStagger.kt

@@ -1,5 +1,6 @@
 package com.itsaky.androidide.quickbuild
 
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
@@ -66,7 +67,20 @@ class QuickBuildPrebuildStagger(
 					scope.launch {
 						delay(staggerMillis)
 						synchronized(lock) { scheduled = null }
-						fire()
+						try {
+							fire()
+						} catch (e: CancellationException) {
+							// Closing the project cancels this window; teardown has to stay cancellable.
+							throw e
+						} catch (e: Throwable) {
+							// Nothing downstream catches this. The scope is the editor activity's, which
+							// carries a plain Job and no CoroutineExceptionHandler, so a throw here takes
+							// the IDE down half a minute after a project opens - with no action of the
+							// user's in between - and short of that would cancel the scope for the life of
+							// the activity, killing the editor's other launch sites with it. The immediate
+							// fire() below is left alone: it runs on the caller's thread, which can handle it.
+							log.error("Deferred Quick Build prebuild failed", e)
+						}
 					}
 			}
 		}

app/src/test/java/com/itsaky/androidide/quickbuild/QuickBuildPrebuildStaggerTest.kt

@@ -3,6 +3,7 @@ package com.itsaky.androidide.quickbuild
 import com.google.common.truth.Truth.assertThat
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.test.TestScope
 import kotlinx.coroutines.test.advanceTimeBy
 import kotlinx.coroutines.test.runCurrent
@@ -146,6 +147,29 @@ class QuickBuildPrebuildStaggerTest {
 		assertThat(transition.effects).isEmpty()
 	}
 
+	@Test
+	fun `a deferred prebuild that throws does not take the scope down with it`() =
+		runTest {
+			stagger().onProjectSynced(
+				sessionIsLive = { false },
+				fire = { throw IllegalStateException("selectedVariantName blew up") },
+			)
+
+			advanceTimeBy(STAGGER + 1)
+			runCurrent()
+
+			// The scope is the editor activity's: a plain Job, no CoroutineExceptionHandler.
+			// An escaping throw crashes the IDE outright, and short of that cancels the scope
+			// for the life of the activity - taking the editor's other launch sites with it.
+			assertThat(backgroundScope.isActive).isTrue()
+
+			// And the scope is still usable, not merely un-cancelled.
+			stagger().onProjectSynced(sessionIsLive = { false }, fire = { fires++ })
+			advanceTimeBy(STAGGER + 1)
+			runCurrent()
+			assertThat(fires).isEqualTo(1)
+		}
+
 	companion object {
 		private const val STAGGER = 30_000L
 	}