docs: add HelixSR integration plan

* feat(): gog & epic achievements UI

* feat(): AI-generated translations - Please get review for these

* build_local: run on macOS hosts with Docker Desktop

Two steps of tools/build_local.sh failed on a Mac:

- The uruntime staging runs on the host, where macOS's BSD install has
  no -D, so `install -Dm644` stopped with "No such file or directory".
  The folders are now made first and the files copied with install -m644.
- Inside the cross-compile container, Docker Desktop's VirtioFS share
  now and then refuses the chmod that install -m makes (EPERM, on a
  different file each run, e.g. "setting permissions for
  .../droiddeck-esync: Operation not permitted"). The overlay and
  desktop scripts are copied with a plain write instead. Nothing is
  lost: the APK keeps no file modes, and the app sets them when it
  stages the runtime.

* feat(): adjust the store

* feat(): store-achievements adjustment for UI

* feat(): translation fixes and separate hidden achievements

* Show all achievements directly on store game details

---------

Co-authored-by: xXJsonDeruloXx <[email protected]>

.gitattributes

@@ -0,0 +1,3 @@
+# Vendored files preserve upstream license spacing and unified-diff context lines.
+tools/comet/LICENSE whitespace=-blank-at-eof
+tools/comet/droiddeck.patch whitespace=-blank-at-eol,-blank-at-eof

.github/workflows/build.yml

@@ -186,7 +186,7 @@ jobs:
         uses: actions/cache@v4
         with:
           path: app/src/main/assets/linuxfs
-          key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/linuxfs/ssbs/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*', 'tools/msitools/**', 'tools/linuxfs/debian-image.env') }}
+          key: preloads-${{ env.PRELOAD_CACHE_VERSION }}-${{ hashFiles('app/src/main/cpp/fakeinput_steam.cpp', 'app/src/main/cpp/adrenotools/src/hook/kgsl.h', 'tools/quest/*', 'tools/linuxfs/preload/*.c', 'tools/linuxfs/build-x86-preloads.sh', 'tools/linuxfs/fex/*', 'tools/linuxfs/clipboard/*.c', 'tools/linuxfs/ssbs/*.c', 'tools/proot/fastpath/*.c', 'tools/linuxfs/overlay/usr/local/bin/*', 'tools/linuxfs/overlay/usr/bin/**', 'tools/linuxfs/desktop/*', 'tools/gamescope/release.env', 'tools/wlroots/release.env', 'tools/linuxfs/uruntime.env', 'tools/linuxfs/licenses/*', 'tools/mangoapp/*', 'tools/msitools/**', 'tools/comet/**', 'tools/linuxfs/debian-image.env') }}
 
       - name: Build libfakeinput.so and libblsession.so (glibc aarch64)
         if: steps.preloads.outputs.cache-hit != 'true'
@@ -450,6 +450,13 @@ jobs:
           restore-keys: |
             cxx-${{ env.NDK_VERSION }}-
 
+      - name: Build GOG Galaxy companion
+        if: steps.preloads.outputs.cache-hit != 'true'
+        run: |
+          rustup toolchain install 1.90.0 --profile minimal
+          rustup target add --toolchain 1.90.0 aarch64-unknown-linux-gnu
+          RUSTUP_TOOLCHAIN=1.90.0 bash tools/comet/build.sh
+
       - name: Build
         id: build
         env:
@@ -457,6 +464,7 @@ jobs:
           SGDB_API_KEY: ${{ secrets.SGDB_API_KEY }}
         run: |
           set -o pipefail
+          python3 tools/quest/build-driver.py "$ANDROID_HOME/ndk/$NDK_VERSION"
           python3 tools/release/runtime_inputs.py record
           ./gradlew assembleRelease --console=plain -PndkVersion="$NDK_VERSION" 2>&1 | tee /tmp/build.log
           python3 tools/release/check_session_assets.py app/build/outputs/apk/release/app-release.apk

app/build.gradle

@@ -92,8 +92,8 @@ android {
         // file out of its own data directory, and this app's entire job is to exec a rootfs:
         // proot, gamescope, the Steam client and everything it launches all live under files/.
         targetSdkVersion 28
-        versionCode 12
-        versionName "0.3.2"
+        versionCode 13
+        versionName "0.4.0"
         buildConfigField "String", "BUILD_LABEL", "\"${escapedBuildLabel}\""
         buildConfigField "String", "SOURCE_COMMIT", "\"${sourceCommit}\""
         buildConfigField "int", "PR_NUMBER", "${prNumber}"
@@ -287,6 +287,9 @@ dependencies {
     implementation platform('androidx.compose:compose-bom:2024.02.00')
     implementation 'androidx.compose.ui:ui'
     implementation 'androidx.compose.material3:material3'
+    // @Preview for the composables; the tooling that renders them is a debug-only dependency.
+    implementation 'androidx.compose.ui:ui-tooling-preview'
+    debugImplementation 'androidx.compose.ui:ui-tooling'
     implementation 'androidx.activity:activity-compose:1.8.2'
     // The File Manager, Bannerlator's: its icon set, image thumbnails and the coroutines it
     // copies on. Same versions as Bannerlator so the screen stays a straight copy.
@@ -302,4 +305,7 @@ dependencies {
 
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'org.robolectric:robolectric:4.16.1'
+    testImplementation 'androidx.compose.ui:ui-test-junit4'
+    // The Android archive does not include the host natives used by JVM archive tests.
+    testRuntimeOnly 'com.github.luben:zstd-jni:1.5.2-3@jar'
 }

app/src/main/cpp/fakeinput_steam.cpp

@@ -3600,6 +3600,13 @@ static bool wait_snapshot(std::shared_ptr<FakeController> fake,
   }
 }
 
+static int forward_ioctl(int fd, ioctl_request_t op, void *argp) {
+  using ioctl_fn = int (*)(int, ioctl_request_t, ...);
+  // Preserve later preload hooks, including GPU allocation adapters.
+  static const auto next = reinterpret_cast<ioctl_fn>(dlsym(RTLD_NEXT, "ioctl"));
+  return next ? next(fd, op, argp) : static_cast<int>(syscall(SYS_ioctl, fd, op, argp));
+}
+
 EXPORT int ioctl(int fd, ioctl_request_t op, ...) {
   va_list va;
   void *argp;
@@ -3611,7 +3618,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) {
   // The lock must not be held across the passthrough: binder's transport is a
   // blocking ioctl(BINDER_WRITE_READ), so a parked binder pool thread would own
   // controller_mutex() for as long as it waits and deadlock every other ioctl.
-  if (!watched(fd)) return syscall(SYS_ioctl, fd, op, argp);
+  if (!watched(fd)) return forward_ioctl(fd, op, argp);
   std::unique_lock<std::recursive_mutex> guard(controller_mutex());
   auto maker = uinput_map().find(fd);
   if (maker != uinput_map().end()) return ioctl_uinput(*maker->second, op, argp);
@@ -3629,7 +3636,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) {
   auto controller = controller_map().find(fd);
   if (controller == controller_map().end()) {
     guard.unlock();
-    return syscall(SYS_ioctl, fd, op, argp);
+    return forward_ioctl(fd, op, argp);
   }
 
   int type = (op >> 8 & 0xFF);
@@ -3825,7 +3832,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) {
   } else {
     Logger::log("Unhandled evdev ioctl, type %d number %d\n", type, number);
     guard.unlock();
-    return syscall(SYS_ioctl, fd, op, argp);
+    return forward_ioctl(fd, op, argp);
   }
 }
 

app/src/main/cpp/waylandcomp/src/effects_chain.c

@@ -255,7 +255,11 @@ static void target_destroy(struct fx_target *t) {
 static int target_ensure(struct fx_target *t, int w, int h, const char *what) {
     if (t->img && t->w == w && t->h == h) return 0;
     target_destroy(t);
-    VkImageCreateInfo ii = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .imageType = VK_IMAGE_TYPE_2D,
+    /* Unrestricted mutable views keep these render-then-blit targets uncompressed on Turnip.
+     * UBWC targets corrupt even a constant-colour pass on Adreno 740 (FSR becomes black).
+     * Only the chain's intermediate images need this; the scene and guest images stay unchanged. */
+    VkImageCreateInfo ii = {.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+                            .flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, .imageType = VK_IMAGE_TYPE_2D,
                             .format = g_fx_fmt, .extent = {(uint32_t)w, (uint32_t)h, 1}, .mipLevels = 1,
                             .arrayLayers = 1, .samples = VK_SAMPLE_COUNT_1_BIT, .tiling = VK_IMAGE_TILING_OPTIMAL,
                             .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
@@ -292,6 +296,10 @@ static void scene_release(void) {
     memset(&g_scene, 0, sizeof(g_scene));
 }
 
+void vkp_effects_forget_image(VkImage img) {
+    if (img && g_scene.img == img) scene_release();
+}
+
 static int scene_ensure(VkImage img, int w, int h) {
     if (g_scene.img == img && g_scene.w == w && g_scene.h == h && g_scene.ds) return 0;
     scene_release();

app/src/main/cpp/waylandcomp/src/effects_chain.h

@@ -55,6 +55,10 @@ VkImage vkp_effects_run(VkCommandBuffer cmd, VkImage scene, int scene_w, int sce
 /* Compositor thread: drop every Vulkan object (device teardown / device lost). */
 void vkp_effects_destroy(void);
 
+/* Compositor thread: release the cached source view/descriptor before its owner destroys img.
+ * A later image can reuse the same Vulkan handle and dimensions; that is not the same resource. */
+void vkp_effects_forget_image(VkImage img);
+
 /* Compositor thread, before vkp_effects_run(): the format of the scene image it will be handed and the
  * format its own targets use. R8G8B8A8 / R8G8B8A8 for every SDR frame (the default); A2B10G10R10 /
  * A2B10G10R10 while an HDR picture runs through it (hdr_compose.h). A target-format change rebuilds the

app/src/main/cpp/waylandcomp/src/vk_present.c

@@ -1164,6 +1164,7 @@ static void record_draw(VkCommandBuffer cmd, const struct vkp_draw *d, const VkI
 }
 
 static void destroy_scene_image(void) {
+    if (g_scene.img) vkp_effects_forget_image(g_scene.img);
     if (g_scene.img) hdrc_forget_image(g_scene.img); /* the HDR pass may have drawn into it */
     if (g_scene.img) blendp_forget_image(g_scene.img);
     if (g_scene.img) g_vk.DestroyImage(g_dev, g_scene.img, NULL);
@@ -1203,6 +1204,7 @@ static int ensure_scene_image(int w, int h) {
 static int ensure_img(struct vkp_img_slot *s, int w, int h, VkFormat fmt, VkImageUsageFlags usage, const char *what) {
     if (s->img && s->w == w && s->h == h && s->fmt == fmt) return 0;
     if (s->img) hdrc_forget_image(s->img);
+    if (s->img) vkp_effects_forget_image(s->img);
     if (s->img) blendp_forget_image(s->img);
     if (s->img) g_vk.DestroyImage(g_dev, s->img, NULL);
     if (s->mem) g_vk.FreeMemory(g_dev, s->mem, NULL);

app/src/main/java/com/droiddeck/launcher/App.kt

@@ -22,6 +22,7 @@ class App : Application() {
     override fun onCreate() {
         super.onCreate()
         CrashHandler.install(this)
+        com.droiddeck.launcher.session.QuestExperimental.initialize(this)
         com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this)
         com.droiddeck.launcher.update.AppUpdates.init(this)
         GpuClockPin.clearLeftover(this)

app/src/main/java/com/droiddeck/launcher/ComponentsMenu.kt

@@ -9,10 +9,10 @@ import com.droiddeck.launcher.session.ComponentsManager
 import com.droiddeck.launcher.session.ProtonDefault
 
 /**
- * The Components page's state and work: the Protons and their DXVK/VKD3D sets, the Nightlies
- * catalog, downloads and the swap/restore actions. The launcher screen keeps one and shows it.
+ * Component state and work for the launcher and session drawer: the Protons and their
+ * DXVK/VKD3D sets, the Nightlies catalog, downloads and the swap/restore actions.
  */
-internal class ComponentsMenu(private val activity: android.app.Activity, private val ui: android.os.Handler) {
+internal class ComponentsMenu(private val activity: android.app.Activity, private val ui: Handler) {
     var compSnapshot by mutableStateOf<ComponentsManager.Snapshot?>(null)
     var compCatalog by mutableStateOf<List<ComponentsManager.CatalogItem>>(emptyList())
     var compCatalogAt by mutableStateOf(0L)
@@ -20,7 +20,10 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
     var compComp by mutableStateOf(com.droiddeck.launcher.ui.GPU_TAB)
     var compChecking by mutableStateOf(false)
     var compBusy by mutableStateOf<String?>(null)
-    var compDownloads by mutableStateOf<Map<String, Int>>(emptyMap())
+    var compDownloads: Map<String, Int>
+        get() = downloads
+        private set(value) { downloads = value }
+    val compDownloadRevision: Long get() = downloadRevision
     private var shownDefault: String? = null
 
     /** Reads the Protons (and on first open saves their originals) off the UI thread; the Nightlies list comes from its cache. */
@@ -72,15 +75,15 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
         }, "components-action").start()
     }
 
-    fun refreshComponentCatalog() {
+    fun refreshComponentCatalog(force: Boolean = true) {
         if (compChecking) return
         compChecking = true
         Thread({
-            val cat = runCatching { ComponentsManager.catalog(activity, true) }.getOrNull()
+            val cat = runCatching { ComponentsManager.catalog(activity, force) }.getOrNull()
             ui.post {
                 compChecking = false
-                if (cat == null || cat.items.isEmpty()) android.widget.Toast.makeText(activity, activity.getString(R.string.comp_nightlies_unreachable), android.widget.Toast.LENGTH_LONG).show()
-                else { compCatalog = cat.items; compCatalogAt = cat.fetchedAt }
+                if (cat != null && cat.items.isNotEmpty()) { compCatalog = cat.items; compCatalogAt = cat.fetchedAt }
+                else if (force) android.widget.Toast.makeText(activity, activity.getString(R.string.comp_nightlies_unreachable), android.widget.Toast.LENGTH_LONG).show()
             }
         }, "components-catalog").start()
     }
@@ -95,6 +98,7 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
             }.getOrElse { e -> activity.getString(R.string.comp_download_failed, e.message ?: e.javaClass.simpleName) }
             ui.post {
                 compDownloads = compDownloads - item.file
+                downloadRevision++
                 android.widget.Toast.makeText(activity, message, android.widget.Toast.LENGTH_SHORT).show()
                 refreshComponents()
             }
@@ -102,6 +106,10 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
     }
 
     private companion object {
-        const val TAG = "MainActivity"
+        const val TAG = "ComponentsMenu"
+        // Both screens use the same package store and .part files. Keep the in-flight registry
+        // across menu/activity instances so a package cannot be downloaded twice at once.
+        var downloads by mutableStateOf<Map<String, Int>>(emptyMap())
+        var downloadRevision by mutableStateOf(0L)
     }
 }

app/src/main/java/com/droiddeck/launcher/MainActivity.kt

@@ -46,7 +46,6 @@ import com.droiddeck.launcher.session.GameSaves
 import com.droiddeck.launcher.session.SessionLogShare
 import com.droiddeck.launcher.session.SessionPrefs
 import com.droiddeck.launcher.session.SteamRepair
-import com.droiddeck.launcher.ui.ProtonPage
 import com.droiddeck.launcher.core.CpuCores
 import com.droiddeck.launcher.core.PhantomProcessLimit
 import com.droiddeck.launcher.core.PhantomProcessStatus
@@ -55,7 +54,6 @@ import com.droiddeck.launcher.core.WifiDiscovery
 import com.droiddeck.launcher.core.WirelessAdbPairingService
 import com.droiddeck.launcher.ui.CoreRow
 import com.droiddeck.launcher.ui.PerformancePage
-import com.droiddeck.launcher.ui.ModeSettingsPage
 import com.droiddeck.launcher.ui.ModeSettings
 import com.droiddeck.launcher.ui.ModeSettingsActions
 import com.droiddeck.launcher.ui.ConfirmDialog
@@ -124,7 +122,6 @@ class MainActivity : ComponentActivity() {
     private var steamRepairQueued by mutableStateOf(false)
     private var mangoapp by mutableStateOf(true)
     private var steamController by mutableStateOf(SessionPrefs.CONTROLLER_DECK)
-    private var showProtons by mutableStateOf(false)
     // Components page: FEX / DXVK / VKD3D-Proton per Proton (ComponentsManager).
     private var showComponents by mutableStateOf(false)
     private var focusComponentsContent by mutableStateOf(true)
@@ -166,8 +163,7 @@ class MainActivity : ComponentActivity() {
     private var orientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE)
     private var launcherFullscreen by mutableStateOf(true)
     private var animationsEnabled by mutableStateOf(true)
-    private var storeEnabled by mutableStateOf(false)
-    private var gameStoresEnabled by mutableStateOf(false)
+    private var gameStoresEnabled by mutableStateOf(true)
     private var gameStoresSpeedTier by mutableStateOf("fast")
     private var storesOpenTab by mutableStateOf(SessionPrefs.STORES_OPEN_LIBRARY)
     /** A page a notification asked for ("stores:downloads", "app:<id>"), until the front end has gone there. */
@@ -338,7 +334,7 @@ class MainActivity : ComponentActivity() {
             romsDir = path
         }
     }
-    // The mode whose settings dialog is open, with what it shows; refreshed by openModeSettings().
+    // The mode whose lifted sheet last read its settings, with what it shows; refreshed by loadModeSettings().
     private var settingsMode by mutableStateOf<String?>(null)
     private var resolution by mutableStateOf(com.droiddeck.launcher.session.SessionDisplay.DEFAULT_RESOLUTION)
     private var fexPreset by mutableStateOf("")
@@ -539,7 +535,6 @@ class MainActivity : ComponentActivity() {
         requestedOrientation = orientation
         launcherFullscreen = SessionPrefs.launcherFullscreen(this)
         animationsEnabled = SessionPrefs.animationsEnabled(this)
-        storeEnabled = SessionPrefs.storeEnabled(this)
         gameStoresEnabled = SessionPrefs.gameStoresEnabled(this)
         gameStoresSpeedTier = SessionPrefs.gameStoresSpeedTier(this)
         storesOpenTab = SessionPrefs.storesOpenTab(this)
@@ -549,11 +544,8 @@ class MainActivity : ComponentActivity() {
         setContent {
             DroidDeckTheme(theme, appScale = appScale) {
             com.droiddeck.launcher.ui.FocusGlideHost(androidx.compose.ui.Modifier.fillMaxSize().exposeTestTags()) {
-                val sm = settingsMode
                 val page: (@Composable () -> Unit)? = when {
-                    sm != null -> { { ModeSettingsHost(sm) } }
                     showPerformance -> { { PerformanceHost() } }
-                    showProtons -> { { ProtonHost() } }
                     showComponents -> { { ComponentsHost() } }
                     showMapping -> { { MappingHost() } }
                     else -> null
@@ -572,7 +564,7 @@ class MainActivity : ComponentActivity() {
                         steamGames = steamGames, emulators = emulatorList, running = runningLabel,
                         frameGen = FrameGen.mode(this),
                         lossless = lossless,
-                        pageKey = sm?.let { "settings:$it" } ?: if (showPerformance) "performance" else if (showProtons) "protons" else if (showComponents) "components" else if (showMapping) "controller-mapping" else null,
+                        pageKey = if (showPerformance) "performance" else if (showComponents) "components" else if (showMapping) "controller-mapping" else null,
                         theme = theme,
                         language = com.droiddeck.launcher.core.AppLanguage.chosen(this),
                         appScale = appScale,
@@ -597,7 +589,6 @@ class MainActivity : ComponentActivity() {
                         orientation = orientation,
                         launcherFullscreen = launcherFullscreen,
                         animationsEnabled = animationsEnabled,
-                        storeEnabled = storeEnabled,
                         gameStoresEnabled = gameStoresEnabled,
                         gameStoresSpeedTier = gameStoresSpeedTier,
                         storesOpenTab = storesOpenTab,
@@ -683,9 +674,10 @@ class MainActivity : ComponentActivity() {
                         },
                         // The activity re-attaches to the session that is running; nothing restarts.
                         onResume = { startActivity(Intent(this, SessionActivity::class.java)) },
-                        onSteamSettings = { openModeSettings(SessionService.MODE_STEAM) },
+                        onSteamSettings = { loadModeSettings(SessionService.MODE_STEAM) },
                         onRemoveDesktop = { removeDesktop() },
-                        onDesktopSettings = { openModeSettings(SessionService.MODE_DESKTOP) },
+                        onDesktopSettings = { loadModeSettings(SessionService.MODE_DESKTOP) },
+                        modeSheet = { mode, tab, extras -> ModeSheetHost(mode, tab, extras) },
                         onInstallPackage = { id -> installPackage(id) },
                         onRemovePackage = { id -> removePackage(id) },
                         onRuntime = { onRuntimeButton() },
@@ -698,10 +690,11 @@ class MainActivity : ComponentActivity() {
                         },
                         onProtons = { openProtons() },
                         onComponents = { focusContent -> openComponents(focusContent) },
+                        onComponentsTab = { tab -> openComponents(focusContent = true, tab = tab) },
                         // A game page's Manage saves: the game's Proton and saves are read when the work runs, off the main thread.
                         onSaveImport = { sg -> importSaves(sg.name) { GameSaves.game(sg) } },
                         onSaveExport = { sg, layout -> exportSaves(sg.name, layout) { GameSaves.game(sg) } },
-                        onPerformance = { refreshCores(); showProtons = false; showComponents = false; showMapping = false; showPerformance = true },
+                        onPerformance = { refreshCores(); showComponents = false; showMapping = false; showPerformance = true },
                         onRoms = { showRoms = true },
                         onFiles = { startActivity(Intent(this, com.droiddeck.launcher.files.FileManagerActivity::class.java)) },
                         onBrowseFiles = { dir ->
@@ -736,7 +729,8 @@ class MainActivity : ComponentActivity() {
                             OfflineMode.setEnabled(this, !OfflineMode.enabled(this))
                             offline = OfflineMode.enabled(this)
                         },
-                        onPageBack = { settingsMode = null; showPerformance = false; showProtons = false; showComponents = false; showMapping = false },
+                        onPageBack = { showPerformance = false; showComponents = false; showMapping = false },
+                        onGameStoresEnabled = { on -> SessionPrefs.setGameStoresEnabled(this, on); gameStoresEnabled = on },
                         onTheme = { id -> SessionPrefs.setTheme(this, id); theme = id },
                         onLanguage = { tag ->
                             if (tag != com.droiddeck.launcher.core.AppLanguage.chosen(this)) {
@@ -759,8 +753,6 @@ class MainActivity : ComponentActivity() {
                             launcherFullscreen = on
                             applyLauncherFullscreen()
                         },
-                        onStoreEnabled = { on -> SessionPrefs.setStoreEnabled(this, on); storeEnabled = on },
-                        onGameStoresEnabled = { on -> SessionPrefs.setGameStoresEnabled(this, on); gameStoresEnabled = on; if (on) com.droiddeck.launcher.stores.StoresState.refresh(this) },
                         onGameStoresSpeedTier = { tier -> SessionPrefs.setGameStoresSpeedTier(this, tier); gameStoresSpeedTier = tier },
                         onStoresOpenTab = { tab -> SessionPrefs.setStoresOpenTab(this, tab); storesOpenTab = tab },
                         onNavigated = { navRequest = null },
@@ -846,7 +838,7 @@ class MainActivity : ComponentActivity() {
                             onSelectSteam = { on -> ControllerPrefs.setSelectSteam(this, on); refreshController() },
                             onEditLayout = { startActivity(Intent(this, ControllerEditorActivity::class.java)) },
                             onResetLayout = { ControllerPrefs.resetAllLayouts(this); refreshController() },
-                            onMapping = { settingsMode = null; showPerformance = false; showProtons = false; showComponents = false; showMapping = true },
+                            onMapping = { showPerformance = false; showComponents = false; showMapping = true },
                             onResetAll = { ControllerPrefs.resetAll(this); refreshController() },
                         ),
                     ),
@@ -966,14 +958,12 @@ class MainActivity : ComponentActivity() {
         }
     }
 
-    /** On the Components page the pad's LB / RB step through GPU drivers, FEX, DXVK and VKD3D-Proton, wrapping around. */
+    /** On the Components page the pad's LB / RB step through the stack's layers, wrapping around. */
     override fun dispatchKeyEvent(event: KeyEvent): Boolean {
         if (event.keyCode == KeyEvent.KEYCODE_BUTTON_A) com.droiddeck.launcher.ui.HeldKeys.confirm = event.action == KeyEvent.ACTION_DOWN
         if (showComponents && (event.keyCode == KeyEvent.KEYCODE_BUTTON_L1 || event.keyCode == KeyEvent.KEYCODE_BUTTON_R1)) {
             if (event.action == KeyEvent.ACTION_DOWN && event.repeatCount == 0) {
-                val all = listOf(com.droiddeck.launcher.ui.GPU_TAB) + ComponentsManager.COMPONENTS
-                val step = if (event.keyCode == KeyEvent.KEYCODE_BUTTON_R1) 1 else all.size - 1
-                components.compComp = all[(all.indexOf(components.compComp).coerceAtLeast(0) + step) % all.size]
+                components.compComp = com.droiddeck.launcher.ui.layerStep(components.compComp, if (event.keyCode == KeyEvent.KEYCODE_BUTTON_R1) 1 else -1)
             }
             return true
         }
@@ -995,7 +985,7 @@ class MainActivity : ComponentActivity() {
         refreshWifiDiscovery()
         // Back from a store's sign-in page: the Stores chips show the account at once. A store
         // install finishing while this screen is up rebuilds the Games list through the listener.
-        if (gameStoresEnabled) com.droiddeck.launcher.stores.StoresState.refresh(this)
+        com.droiddeck.launcher.stores.StoresState.refresh(this)
         com.droiddeck.launcher.stores.StoresState.libraryListener = { refreshAddedGames(); refresh() }
         com.droiddeck.launcher.ui.Motion.refresh(this)
         // Back from a session stopped behind a flood: open on its blue, before the first frame.
@@ -1008,6 +998,8 @@ class MainActivity : ComponentActivity() {
         updates.onResume()
         // Auto keeps this GPU's recommended driver pair installed and set: once per app start.
         drivers.ensureAuto(force = false)
+        // Newer GE-Proton / proton-cachyos / DroidDeck-Proton releases: looked up every few hours at most.
+        protons.checkUpdates()
         // Swaps queued while a game ran on that Proton go in once nothing uses it (usually the
         // session has just ended). Cheap when nothing is queued.
         if (!SessionState.running) Thread({
@@ -1126,14 +1118,8 @@ class MainActivity : ComponentActivity() {
         }, "game-saves-action").start()
     }
 
-    private fun openProtons() {
-        settingsMode = null
-        showPerformance = false
-        showComponents = false
-        showMapping = false
-        showProtons = true
-        protons.refreshProtons()
-    }
+    /** The Protons DroidDeck installs are the Components page's Proton layer. */
+    private fun openProtons() = openComponents(focusContent = true, tab = com.droiddeck.launcher.ui.PROTON_TAB)
 
     private fun refreshController() {
         controllerSettings = ControllerPrefs.read(this)
@@ -1153,13 +1139,19 @@ class MainActivity : ComponentActivity() {
     private fun openComponents(focusContent: Boolean = true, tab: String? = null) {
         focusComponentsContent = focusContent
         if (tab != null) components.compComp = tab
-        settingsMode = null
         showPerformance = false
-        showProtons = false
         showMapping = false
         showComponents = true
+        // The Proton layer's options for every Proton, as they are now.
+        fexPreset = SessionPrefs.fexPreset(this)
+        forceSsbs = SessionPrefs.forceSsbs(this)
+        fastSync = SessionPrefs.fastSync(this)
+        fsyncFirst = SessionPrefs.fsyncFirst(this)
+        syncFallback = SessionPrefs.syncFallback(this)
         components.refreshComponents(snapshotFirst = true)
         drivers.refreshDrivers()
+        protons.refreshProtons()
+        protons.checkUpdates()
     }
 
     private fun importComponent(uri: Uri) {
@@ -1193,7 +1185,11 @@ class MainActivity : ComponentActivity() {
             onDownload = { components.downloadComponent(it) },
             onRefresh = { components.refreshComponentCatalog() },
             onImport = { pickComponent.launch(InAppFilePicker.buildIntent(this, WCP_EXT, getString(R.string.comp_pick_wcp))) },
-            onBack = { showComponents = false },
+            // Reached by a hop (a game's Components card, Play's Graphics drivers): back the way it came.
+            onBack = { if (!com.droiddeck.launcher.ui.Hops.back { showComponents = false }) showComponents = false },
+            games = steamGames,
+            generalFexPreset = fexPreset,
+            onGeneralFexPreset = { id -> SessionPrefs.setFexPreset(this, id); fexPreset = id },
             gpu = drivers.state(),
             gpuActions = com.droiddeck.launcher.ui.GpuDriversActions(
                 onAuto = { on -> drivers.setMode(on) },
@@ -1210,23 +1206,34 @@ class MainActivity : ComponentActivity() {
                 onImportZip = { pickAnyDriver.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, getString(R.string.drivers_pick_any))) },
                 onRestoreBundled = { TurnipDriver(this).restoreBundled(); drivers.refreshDrivers() },
             ),
+            protons = com.droiddeck.launcher.ui.ProtonsState(
+                rows = protons.protonRows, busyId = protons.protonBusyId, stage = protons.protonStage, percent = protons.protonPercent,
+                runtimeReady = ready && !busy, sessionRunning = SessionState.running,
+            ),
+            protonActions = com.droiddeck.launcher.ui.ProtonsActions(
+                onInstall = { id -> protons.installProton(id) },
+                onCancel = { id -> ProtonExtras.tools.firstOrNull { it.id == id }?.let { ProtonExtras.unqueue(this, it) }; protons.refreshProtons() },
+                onRemove = { id, dir -> protons.removeProton(id, dir) },
+                onRemoveOlder = { id -> protons.removeProton(id, older = true) },
+            ),
+            protonOptions = {
+                com.droiddeck.launcher.ui.ProtonOptions(
+                    syncBackend = SessionPrefs.syncBackendOf(fastSync, fsyncFirst, syncFallback), fexPreset = fexPreset, forceSsbs = forceSsbs,
+                    onSyncBackend = { id ->
+                        SessionPrefs.setSyncBackend(this, id)
+                        fastSync = SessionPrefs.fastSync(this)
+                        fsyncFirst = SessionPrefs.fsyncFirst(this)
+                        syncFallback = SessionPrefs.syncFallback(this)
+                    },
+                    onFexPreset = { id -> SessionPrefs.setFexPreset(this, id); fexPreset = id },
+                    onForceSsbs = { on -> SessionPrefs.setForceSsbs(this, on); forceSsbs = on },
+                )
+            },
         )
-    }
-
-    @Composable
-    private fun ProtonHost() {
-        ProtonPage(
-            rows = protons.protonRows,
-            busyId = protons.protonBusyId,
-            stage = protons.protonStage,
-            percent = protons.protonPercent,
-            runtimeReady = ready && !busy,
-            sessionRunning = SessionState.running,
-            onInstall = { id -> protons.installProton(id) },
-            onCancel = { id -> ProtonExtras.tools.firstOrNull { it.id == id }?.let { ProtonExtras.unqueue(this, it) }; protons.refreshProtons() },
-            onRemove = { id -> protons.removeProton(id) },
-            onBack = { showProtons = false },
-        )
+        // A download can finish in the session drawer while this page is visible.
+        androidx.compose.runtime.LaunchedEffect(components.compDownloadRevision) { components.refreshComponents() }
+        // A Proton installed or removed changes the stack's list of Protons.
+        androidx.compose.runtime.LaunchedEffect(protons.protonBusyId) { if (protons.protonBusyId == null) components.refreshComponents() }
     }
 
     private fun refreshPackages() {
@@ -1273,8 +1280,10 @@ class MainActivity : ComponentActivity() {
     }
 
     @Composable
-    private fun ModeSettingsHost(mode: String) {
-        ModeSettingsPage(
+    private fun ModeSheetHost(mode: String, tab: String, extras: com.droiddeck.launcher.ui.SheetExtras) {
+        // Read for the other mode last (or not yet): what this one shows is read as it opens.
+        if (settingsMode != mode) return
+        com.droiddeck.launcher.ui.ModeSheetRows(
             ModeSettings(
                 mode = mode, resolution = resolution,
                 panelSize = com.droiddeck.launcher.session.SessionDisplay.panelSize(this),
@@ -1394,8 +1403,9 @@ class MainActivity : ComponentActivity() {
                 onPickDeckyPluginZip = {
                     pickDeckyPluginZip.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, getString(R.string.main_pick_decky_zip)))
                 },
-                onDismiss = { settingsMode = null },
+                onDismiss = {},
             ),
+            tab, extras,
         )
     }
 
@@ -1496,13 +1506,9 @@ class MainActivity : ComponentActivity() {
     private var pipAutoEnter by mutableStateOf(false)
     private var unfoldedControls by mutableStateOf(false)
 
-    private fun openModeSettings(mode: String) {
+    private fun loadModeSettings(mode: String) {
         pipAutoEnter = SessionPrefs.pipAutoEnter(this)
         unfoldedControls = SessionPrefs.unfoldedControls(this)
-        showPerformance = false
-        showProtons = false
-        showComponents = false
-        showMapping = false
         resolution = SessionPrefs.resolutionChoice(this, mode, com.droiddeck.launcher.session.SessionDisplay.panelSize(this))
         fexPreset = SessionPrefs.fexPreset(this)
         forceSsbs = SessionPrefs.forceSsbs(this)
@@ -1530,8 +1536,8 @@ class MainActivity : ComponentActivity() {
         gameStorage = SessionPrefs.gameStorage(this)
         storageDiagnostics = SessionPrefs.storageDiagnosticsEnabled(this)
         settingsMode = mode
-        // The page opens at once, on what was last read; the slow part (driver files, a walk of the
-        // added-games folders, the storage volumes) lands while it animates in.
+        // The sheet lifts at once, on what was last read; the slow part (driver files, a walk of the
+        // added-games folders, the storage volumes) lands while it rises.
         Thread({
             drivers.refreshDrivers()
             val storage = GameStorage.options(this)
@@ -1607,7 +1613,10 @@ class MainActivity : ComponentActivity() {
         val scanGeneration = ++libraryScanGeneration
         if (shortcutPicker) shortcutLibraryScanning = true
         Thread({
-            // Steam's own games first, from their manifests alone (quick), beside the added games
+            // The emulators first: they need no walk of the games, and Desktop's dock is made of them.
+            val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null }
+            ui.post { if (scanGeneration == libraryScanGeneration) emulatorList = emus }
+            // Steam's own games next, from their manifests alone (quick), beside the added games
             // already listed: a game Steam installed during the session shows as the session ends,
             // without waiting for the added games' walk below. Its Windows components' list is
             // queued then too, on the low-priority worker, so its page is usually ready.
@@ -1628,7 +1637,6 @@ class MainActivity : ComponentActivity() {
             // so a partial list first would shuffle every capsule when the rest arrived.
             // LibraryCache covers the wait.
             val games = if (ready) Library.launchableGames(this) else emptyList()
-            val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null }
             val all = games.distinctBy { it.gameId }
             if (ready) com.droiddeck.launcher.frontend.LibraryCache.save(this, all)
             // Once per app start: the Steam games' Windows components from Steam's lists.
@@ -1643,7 +1651,6 @@ class MainActivity : ComponentActivity() {
             ui.post {
                 if (scanGeneration == libraryScanGeneration) {
                     steamGames = all
-                    emulatorList = emus
                     shortcutLibraryScanning = false
                     handleGameLink(all)
                 }

app/src/main/java/com/droiddeck/launcher/ProtonMenu.kt

@@ -10,14 +10,16 @@ import com.droiddeck.launcher.ui.ProtonRow
 import com.droiddeck.launcher.session.SessionState
 
 /**
- * The optional ARM64 Protons (GE-Proton, proton-cachyos): the rows the page lists and an install or
- * removal in progress. The launcher screen keeps one and shows it.
+ * The optional ARM64 Protons (GE-Proton, proton-cachyos, DroidDeck-Proton): the rows the page lists,
+ * an install or removal in progress, and whether a newer release is out. The launcher screen keeps
+ * one and shows it.
  */
 internal class ProtonMenu(private val activity: android.app.Activity, private val ui: android.os.Handler) {
     var protonRows by mutableStateOf<List<ProtonRow>>(emptyList())
     var protonBusyId by mutableStateOf<String?>(null)
     var protonStage by mutableStateOf<String?>(null)
     var protonPercent by mutableIntStateOf(-1)
+    private val checking = java.util.concurrent.atomic.AtomicBoolean(false)
 
     fun installProton(id: String) {
         val tool = ProtonExtras.tools.firstOrNull { it.id == id } ?: return
@@ -40,14 +42,15 @@ internal class ProtonMenu(private val activity: android.app.Activity, private va
         }, "install-proton-$id").start()
     }
 
-    fun removeProton(id: String) {
+    /** Removes the build in [dir], or with [older] every build of it but the newest. */
+    fun removeProton(id: String, dir: String? = null, older: Boolean = false) {
         val tool = ProtonExtras.tools.firstOrNull { it.id == id } ?: return
         if (protonBusyId != null || SessionState.running) return
         protonBusyId = id
-        protonStage = activity.getString(R.string.main_removing_named, tool.name)
+        protonStage = activity.getString(R.string.main_removing_named, dir ?: tool.name)
         protonPercent = -1
         Thread({
-            ProtonExtras.remove(activity, tool)
+            if (older) ProtonExtras.removeOlder(activity, tool) else ProtonExtras.remove(activity, tool, dir)
             ui.post {
                 protonBusyId = null
                 protonStage = null
@@ -57,6 +60,18 @@ internal class ProtonMenu(private val activity: android.app.Activity, private va
     }
 
     fun refreshProtons() {
-        protonRows = ProtonExtras.tools.map { ProtonRow(it.id, it.name, ProtonExtras.installed(activity, it), ProtonExtras.queued(activity, it)) }
+        protonRows = ProtonExtras.tools.map {
+            val all = ProtonExtras.installedAll(activity, it)
+            ProtonRow(it.id, it.name, all.lastOrNull(), ProtonExtras.queued(activity, it), all, ProtonExtras.update(activity, it))
+        }
+    }
+
+    /** Looks for newer releases, at most every few hours (see ProtonExtras.checkLatest); quiet offline. */
+    fun checkUpdates(force: Boolean = false) {
+        if (!checking.compareAndSet(false, true)) return
+        Thread({
+            val asked = try { ProtonExtras.checkLatest(activity, force) } catch (_: Throwable) { false } finally { checking.set(false) }
+            if (asked) ui.post { refreshProtons() }
+        }, "proton-updates").start()
     }
 }

app/src/main/java/com/droiddeck/launcher/SessionActivity.kt

@@ -28,10 +28,12 @@ import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.OnBackPressedCallback
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.graphics.toArgb
@@ -40,6 +42,13 @@ import com.droiddeck.launcher.core.FileUtils
 import com.droiddeck.launcher.core.TextureFiltering
 import com.droiddeck.launcher.files.InAppFilePicker
 import com.droiddeck.launcher.frontend.Library
+import com.droiddeck.launcher.agent.AgentGuest
+import com.droiddeck.launcher.frontend.LibraryCache
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoreAchievements
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import com.droiddeck.launcher.stores.StoreLaunchRequests
+import com.droiddeck.launcher.ui.SessionAchievements
 import com.droiddeck.launcher.gpu.FrameGen
 import com.droiddeck.launcher.gpu.ScreenEffectLooks
 import com.droiddeck.launcher.gpu.ScreenEffects
@@ -64,6 +73,9 @@ import com.droiddeck.launcher.session.PerfHud
 import com.droiddeck.launcher.session.PerfMode
 import com.droiddeck.launcher.session.SteamRepair
 import com.droiddeck.launcher.session.GameEnvironmentStore
+import com.droiddeck.launcher.session.GameProfileFollowState
+import com.droiddeck.launcher.session.GameProfileInventoryCache
+import com.droiddeck.launcher.session.GameProfileRefreshState
 import com.droiddeck.launcher.session.SessionPrefs
 import com.droiddeck.launcher.session.SessionEvents
 import com.droiddeck.launcher.session.SessionArtifacts
@@ -73,6 +85,9 @@ import com.droiddeck.launcher.session.SessionPaths
 import com.droiddeck.launcher.wayland.HdrSupport
 import com.droiddeck.launcher.session.SessionService
 import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.session.ProtonDefault
+import com.droiddeck.launcher.session.SelectedGameProfile
+import com.droiddeck.launcher.session.WinComponents
 import com.droiddeck.launcher.ui.CursorOverlay
 import androidx.compose.ui.graphics.asImageBitmap
 import com.droiddeck.launcher.ui.DrawerActions
@@ -86,6 +101,7 @@ import com.droiddeck.launcher.wayland.CompositorHost
 import com.droiddeck.launcher.wayland.WaylandCompositor
 import java.io.File
 import com.droiddeck.launcher.session.ComponentsManager
+import com.droiddeck.launcher.session.LatestRequestCoordinator
 import com.droiddeck.launcher.ui.SessionDrawerPage
 import com.droiddeck.launcher.ui.sessionDrawerPages
 import com.droiddeck.launcher.ui.step
@@ -247,6 +263,26 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
     private var closeAtOnce = false
     /** The drawer's Components tab: the Protons as last read (ComponentsManager). */
     private var drawerComponents by mutableStateOf<ComponentsManager.Snapshot?>(null)
+    private val drawerComponentMenu by lazy { ComponentsMenu(this, uiHandler) }
+    private var drawerGameProfileId by mutableStateOf<Long?>(null)
+    private val drawerGameInventory = GameProfileInventoryCache<Library.SteamGame>()
+    private var drawerGameInventoryRevision = 0L
+    private var drawerGameFexPresetSaving by mutableStateOf(false)
+    private var drawerGameNoSteamSaving by mutableStateOf(false)
+    private val drawerGameProfileFollowState = GameProfileFollowState()
+    private data class DrawerGameProfileRefresh(
+        val followsSteam: Boolean,
+        val requestedAppId: Long?,
+        val inventoryRevision: Long,
+    )
+    private data class DrawerGameProfileResult(
+        val profiles: List<Pair<Long, String>>,
+        val selectedAppId: Long?,
+        val profile: SelectedGameProfile?,
+        val error: Exception? = null,
+    )
+    private var drawerGameProfileRefresh by mutableStateOf(GameProfileRefreshState<DrawerGameProfileResult>())
+    private val drawerGameProfileRefreshes = LatestRequestCoordinator<DrawerGameProfileRefresh>()
     private var drawerPage by mutableStateOf(SessionDrawerPage.CONTROLLER)
     private var drawerControllerActive by mutableStateOf(false)
     private var backActionsInverted by mutableStateOf(false)
@@ -254,12 +290,17 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
     private var padType by mutableStateOf(SessionPrefs.CONTROLLER_DECK)
     /** The on-screen PC keyboard (ui/PcKeyboard): real key presses, Esc and F1 included. */
     private var pcKeyboardOpen by mutableStateOf(false)
+    /** The game in front, when its source has achievements. */
+    private var achievementsInFront by mutableStateOf<AchievementsInFront?>(null)
+    private var achievementsOpen by mutableStateOf(false)
     private var hudOn by mutableStateOf(true)
     private var upscaler by mutableStateOf(0)
     private var upscaleSharpness by mutableStateOf(75)
     private var effects by mutableStateOf(ScreenEffects.OFF)
     private var textureAnisotropy by mutableStateOf(0)
     private var textureLodBias by mutableStateOf(TextureFiltering.LOD_BIAS_OFF)
+    private var drawerTextureAnisotropy by mutableStateOf<Int?>(null)
+    private var drawerTextureLodBias by mutableStateOf<String?>(null)
     private var lossless by mutableStateOf(Lossless.State.NONE)
     private val pickLossless = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r ->
         if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { importLossless(it) }
@@ -310,6 +351,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
     private val deviceListener = object : InputManager.InputDeviceListener {
         override fun onInputDeviceAdded(deviceId: Int) {
             logInputDevice("connected", deviceId)
+            padBridge?.syncConnectedControllers()
             updateOnScreenControls()
             updatePointerCapture()
         }
@@ -326,7 +368,6 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        requestedOrientation = SessionPrefs.orientation(this)
         if (com.droiddeck.launcher.runtime.LinuxRuntimeInstaller.isRemoving() ||
             com.droiddeck.launcher.runtime.LinuxRuntimeInstaller.isMaintaining()) {
             runtimeRemovalBlocked = true
@@ -466,6 +507,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
                 when {
                     ::loading.isInitialized && loading.ended -> finish()
                     drawerOpen -> drawerOpen = false
+                    achievementsOpen -> closeAchievements()
                     pcKeyboardOpen -> pcKeyboardOpen = false
                     else -> routeBackAction()
                 }
@@ -486,7 +528,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         defaultFocusHighlightEnabled = false
         setContent {
             // The drawer, the PC keyboard and picture in picture take the mouse back.
-            androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, pipUi) { updatePointerCapture() }
+            androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, pipUi) { updatePointerCapture() }
             DroidDeckTheme {
             if (pipUi) {
                 if (SessionState.suspended) androidx.compose.foundation.layout.Box(
@@ -529,6 +571,15 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
                         releaseDrawerDirection()
                     }
                 }
+                LaunchedEffect(drawerOpen, achievementsOpen, AgentGuest.focusRevision, StoreAchievements.revision) {
+                    if (!drawerOpen && !achievementsOpen) return@LaunchedEffect
+                    val found = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) {
+                        runCatching { resolveAchievementsInFront() }
+                            .onFailure { Log.w(TAG, "achievements in front: ${it.javaClass.simpleName}") }.getOrNull()
+                    }
+                    achievementsInFront = found
+                    if (found == null) achievementsOpen = false
+                }
                 // The PC keyboard takes it too, for moving over the keys; the drawer opens over it.
                 androidx.compose.runtime.LaunchedEffect(pcKeyboardOpen) { if (pcKeyboardOpen) padBridge?.releaseAll() }
                 if (pcKeyboardOpen) com.droiddeck.launcher.ui.PcKeyboard(
@@ -544,7 +595,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
                     androidApps = androidApps,
                     hudOn = hudOn,
                     upscaler = upscaler, upscaleSharpness = upscaleSharpness,
-                    effects = effects, textureAnisotropy = textureAnisotropy, textureLodBias = textureLodBias,
+                    effects = effects,
+                    textureAnisotropy = if (drawerGameProfileId == null) textureAnisotropy else drawerTextureAnisotropy,
+                    textureLodBias = if (drawerGameProfileId == null) textureLodBias else drawerTextureLodBias,
                     frameGen = frameGen,
                     lossless = lossless,
                     oscMode = oscMode, onScreenButtonsVisible = onScreenButtonsVisible, suspendPolicy = suspendPolicy,
@@ -569,8 +622,24 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
                         SessionPrefs.setScreenEffects(this@SessionActivity, e); effects = e
                         e.push(upscaler)
                     },
-                    onTextureAnisotropy = { v -> SessionPrefs.setTextureAnisotropy(this@SessionActivity, v); textureAnisotropy = v },
-                    onTextureLodBias = { v -> SessionPrefs.setTextureLodBias(this@SessionActivity, v); textureLodBias = v },
+                    onTextureAnisotropy = { value ->
+                        drawerGameProfileId?.let { appId ->
+                            SessionPrefs.setGameTextureAnisotropy(this@SessionActivity, appId.toString(), value)
+                            drawerTextureAnisotropy = value
+                        } ?: value?.let {
+                            SessionPrefs.setTextureAnisotropy(this@SessionActivity, it)
+                            textureAnisotropy = it
+                        }
+                    },
+                    onTextureLodBias = { value ->
+                        drawerGameProfileId?.let { appId ->
+                            SessionPrefs.setGameTextureLodBias(this@SessionActivity, appId.toString(), value)
+                            drawerTextureLodBias = value
+                        } ?: value?.let {
+                            SessionPrefs.setTextureLodBias(this@SessionActivity, it)
+                            textureLodBias = it
+                        }
+                    },
                     onFrameGenPick = { mode ->
                         FrameGen.set(this@SessionActivity, mode)
                         readPrefs()
@@ -589,6 +658,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
                     onKeyboardButton = { on -> updateControllerPrefs { ControllerPrefs.setKeyboardButton(this@SessionActivity, on) } },
                     onSteamMenu = if (SessionState.mode == SessionService.MODE_STEAM) ({ sendSteamGuide() }) else null,
                     onQam = if (SessionState.mode == SessionService.MODE_STEAM) ({ triggerSteamQam() }) else null,
+                    onAchievements = achievementsInFront?.let { { drawerOpen = false; achievementsOpen = true } },
+                    achievementsProgress = achievementsInFront?.progress,
                     // Only where the session set the pad up to be switched (SessionService: deckPad).
                     padType = if (SessionState.mode == SessionService.MODE_STEAM && SessionState.deckPad) padType else null,
                     onPadType = { id ->
@@ -665,9 +736,48 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
                     },
                     onClose = { drawerOpen = false },
                     components = drawerComponents,
-                    onComponentsRefresh = { refreshDrawerComponents() },
+                    onComponentsRefresh = {
+                        refreshDrawerComponents()
+                        drawerComponentMenu.refreshComponentCatalog(force = false)
+                    },
+                    componentCatalog = drawerComponentMenu.compCatalog,
+                    componentCatalogAt = drawerComponentMenu.compCatalogAt,
+                    componentCatalogChecking = drawerComponentMenu.compChecking,
+                    componentDownloads = drawerComponentMenu.compDownloads,
+                    componentDownloadRevision = drawerComponentMenu.compDownloadRevision,
+                    onComponentCatalogRefresh = { drawerComponentMenu.refreshComponentCatalog() },
+                    onComponentDownload = drawerComponentMenu::downloadComponent,
+                    gameProfiles = drawerGameProfileRefresh.data?.profiles.orEmpty(),
+                    selectedGameProfileId = drawerGameProfileId,
+                    selectedGameProfile = drawerGameProfileRefresh.data
+                        ?.takeIf { it.selectedAppId == drawerGameProfileId }?.profile,
+                    gameProfilesLoaded = drawerGameProfileRefresh.loaded,
+                    gameProfileRefreshFailed = drawerGameProfileRefresh.failed,
+                    onSelectedGameProfile = ::selectDrawerGameProfile,
+                    onGameProfilesPageOpened = {
+                        drawerGameProfileFollowState.resumeFollowingSteam()
+                        drawerGameInventoryRevision++
+                    },
+                    onSelectedGameProfileRefresh = ::refreshDrawerGameProfile,
+                    gameFexPresetSaving = drawerGameFexPresetSaving,
+                    onGameFexPreset = ::setDrawerGameFexPreset,
+                    gameNoSteamSaving = drawerGameNoSteamSaving,
+                    onGameNoSteam = ::setDrawerGameNoSteam,
                     onComponentSwap = { pid, comp, value -> swapDrawerComponent(pid, comp, value) },
+                    onGameComponent = ::setDrawerGameComponent,
                 ))
+                // The panel takes the pad, as the PC keyboard does.
+                LaunchedEffect(achievementsOpen) {
+                    if (achievementsOpen) {
+                        padBridge?.releaseAll()
+                        withFrameNanos { }
+                        sessionOverlay.requestFocus()
+                    }
+                }
+                achievementsInFront?.takeIf { achievementsOpen }?.let { inFront ->
+                    SessionAchievements(inFront.game, inFront.title, onClose = ::closeAchievements)
+                }
+                com.droiddeck.launcher.ui.AchievementNotificationOverlay()
                 if (SessionState.suspended) SessionPausedOverlay(
                     title = pausedTitle(),
                     onResume = { SessionService.resume(this@SessionActivity) },
@@ -708,6 +818,28 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         padBridge?.triggerQam()
     }
 
+    private fun closeAchievements() { achievementsOpen = false }
+
+    /** A live game window only; Steam's overlay may be in front of that window. */
+    private fun resolveAchievementsInFront(): AchievementsInFront? {
+        if (!SessionState.running || SessionState.mode != SessionService.MODE_STEAM) return null
+        val snapshot = AgentGuest.focus(this) ?: return null
+        val games = LibraryCache.load(this)
+        val byKey = games.mapNotNull { g -> g.profileKey.toLongOrNull()?.let { it to g } }.toMap()
+        val windows = snapshot.optJSONArray("focusableApps")?.let { list -> List(list.length()) { list.optLong(it) } }.orEmpty()
+        val focusedId = snapshot.optLong("focusedApp").takeUnless { snapshot.isNull("focusedApp") }
+        val appId = com.droiddeck.launcher.session.SessionAchievementGame.activeAppId(focusedId, windows, byKey.keys) ?: return null
+        val focused = byKey[appId] ?: return null
+        val store = Store.byId(focused.source) ?: return null
+        val id = focused.storeId ?: return null
+        val source = StoreAchievements.forSource(store.id) ?: return null
+        val sidecar = StoreGameSidecar.find(this, store, id) ?: return null
+        val game = StoreAchievements.Game.of(sidecar)
+        val list = source.cached(this, game) ?: (source.fetch(this, game) as? StoreAchievements.Result.Found)?.list ?: return null
+        if (list.isEmpty()) return null
+        return AchievementsInFront(game, sidecar.title, list.count { it.unlocked } to list.size)
+    }
+
     private fun togglePcKeyboard() {
         drawerOpen = false
         keyboard?.hide()
@@ -763,6 +895,107 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         }, "drawer-components").start()
     }
 
+    private fun selectDrawerGameProfile(appId: Long?) {
+        drawerGameProfileFollowState.selectManually()
+        drawerGameProfileId = appId
+        drawerGameProfileRefresh = drawerGameProfileRefresh.retrying()
+        readDrawerTextureFiltering(appId)
+        refreshDrawerGameProfile()
+    }
+
+    private fun readDrawerTextureFiltering(appId: Long?) {
+        val choice = appId?.let { SessionPrefs.gameTextureFiltering(this, it.toString()) }
+        drawerTextureAnisotropy = choice?.anisotropy
+        drawerTextureLodBias = choice?.lodBias
+    }
+
+    private fun refreshDrawerGameProfile() {
+        val refresh = DrawerGameProfileRefresh(
+            drawerGameProfileFollowState.followsSteam,
+            drawerGameProfileId,
+            drawerGameInventoryRevision,
+        )
+        if (!drawerGameProfileRefreshes.submit(refresh)) return
+        Thread({
+            var request = drawerGameProfileRefreshes.takeLatest()
+            while (request != null) {
+                val current = request
+                val result = resolveDrawerGameProfileRefresh(current.value)
+                uiHandler.post {
+                    if (!drawerGameProfileRefreshes.isLatest(current)) return@post
+                    applyDrawerGameProfileRefresh(current.value, result)
+                }
+                request = drawerGameProfileRefreshes.takeLatest()
+            }
+        }, "drawer-game-profile").start()
+    }
+
+    private fun resolveDrawerGameProfileRefresh(
+        refresh: DrawerGameProfileRefresh,
+    ): DrawerGameProfileResult {
+        return try {
+            val games = drawerGameInventory.get(refresh.inventoryRevision) { Library.launchableGames(this) }
+            val options = games.mapNotNull { game ->
+                game.profileKey.toLongOrNull()?.let { it to game.name }
+            }.sortedBy { it.second.lowercase() }
+            val installedAppIds = options.mapTo(mutableSetOf()) { it.first }
+            val selectedAppId = if (refresh.followsSteam) {
+                val activeAppId = AgentGuest.activeSteamAppId(this, installedAppIds)
+                val selectedSteamAppId = runCatching { AgentGuest.selectedSteamAppId(this) }
+                AgentGuest.selectedOrActiveInstalledSteamAppId(selectedSteamAppId, activeAppId, installedAppIds)
+                    ?: refresh.requestedAppId
+            } else {
+                refresh.requestedAppId
+            }
+            val profile = selectedAppId?.let { resolveDrawerGameProfile(it, games) }
+            DrawerGameProfileResult(options, selectedAppId, profile)
+        } catch (error: Exception) {
+            DrawerGameProfileResult(emptyList(), refresh.requestedAppId, null, error)
+        }
+    }
+
+    private fun applyDrawerGameProfileRefresh(
+        refresh: DrawerGameProfileRefresh,
+        result: DrawerGameProfileResult,
+    ) {
+        if (result.error != null) {
+            if (!drawerGameProfileRefresh.failed) {
+                Log.w(TAG, "Could not refresh the selected game profile", result.error)
+            }
+            drawerGameProfileRefresh = drawerGameProfileRefresh.failed()
+            return
+        }
+        drawerGameProfileRefresh = drawerGameProfileRefresh.succeeded(result)
+        if (refresh.followsSteam) {
+            if (drawerGameProfileFollowState.followsSteam) {
+                drawerGameProfileId = result.selectedAppId
+                readDrawerTextureFiltering(result.selectedAppId)
+            }
+        }
+    }
+
+    private fun resolveDrawerGameProfile(
+        selectedAppId: Long,
+        games: List<Library.SteamGame>,
+    ): SelectedGameProfile? {
+        val game = games.firstOrNull { it.profileKey == selectedAppId.toString() } ?: return null
+        val snapshot = drawerComponents ?: ComponentsManager.snapshot(this)
+        val protons = snapshot.protons.map { it.proton }
+        val gameChoice = ProtonDefault.gameChoice(this, game.profileKey)
+        return SelectedGameProfile.resolve(
+            selectedAppId = selectedAppId,
+            games = games,
+            generalFexPreset = SessionPrefs.fexPreset(this),
+            environment = GameEnvironmentStore.read(this),
+            snapshot = snapshot,
+            generalProtonId = ProtonDefault.selectedId(this, protons),
+            gameProtonChoice = gameChoice,
+            gameProtonId = ProtonDefault.gameSelectedId(this, game.profileKey, protons),
+            gameComponents = ComponentsManager.gameComponents(this, game.profileKey),
+            gameWindowsComponents = WinComponents.picks(this, game.profileKey),
+        )
+    }
+
     private fun swapDrawerComponent(protonId: String, comp: String, value: String) {
         Thread({
             val message = runCatching {
@@ -784,6 +1017,63 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         }, "drawer-components-swap").start()
     }
 
+    private fun setDrawerGameComponent(appId: Long, comp: String, file: String?) {
+        val name = drawerGameProfileRefresh.data?.profiles?.firstOrNull { it.first == appId }?.second ?: appId.toString()
+        Thread({
+            val message = runCatching {
+                ComponentsManager.setGameComponent(this, appId.toString(), comp, file)
+                getString(R.string.comp_game_saved_next, name)
+            }.getOrElse { e ->
+                getString(R.string.session_profile_save_failed, e.message ?: e.javaClass.simpleName)
+            }
+            uiHandler.post {
+                android.widget.Toast.makeText(this, message, android.widget.Toast.LENGTH_LONG).show()
+                refreshDrawerComponents()
+                refreshDrawerGameProfile()
+            }
+        }, "drawer-game-component").start()
+    }
+
+    private fun setDrawerGameFexPreset(appId: Long, preset: String?) {
+        if (drawerGameFexPresetSaving) return
+        drawerGameFexPresetSaving = true
+        val name = drawerGameProfileRefresh.data?.profiles?.firstOrNull { it.first == appId }?.second ?: appId.toString()
+        Thread({
+            val message = try {
+                GameEnvironmentStore.setGameFexPreset(this, appId.toString(), preset)
+                getString(R.string.comp_game_saved_next, name)
+            } catch (error: Exception) {
+                Log.w(TAG, "Could not save the game FEX preset for $appId", error)
+                getString(R.string.session_profile_save_failed, error.message ?: error.javaClass.simpleName)
+            }
+            uiHandler.post {
+                drawerGameFexPresetSaving = false
+                Toast.makeText(this, message, Toast.LENGTH_LONG).show()
+                refreshDrawerGameProfile()
+            }
+        }, "drawer-game-fex-preset").start()
+    }
+
+    private fun setDrawerGameNoSteam(appId: Long, on: Boolean) {
+        if (drawerGameNoSteamSaving) return
+        drawerGameNoSteamSaving = true
+        val name = drawerGameProfileRefresh.data?.profiles?.firstOrNull { it.first == appId }?.second ?: appId.toString()
+        Thread({
+            val message = try {
+                GameEnvironmentStore.setGameNoSteam(this, appId.toString(), on)
+                getString(R.string.comp_game_saved_next, name)
+            } catch (error: Exception) {
+                Log.w(TAG, "Could not save Start without Steam for $appId", error)
+                getString(R.string.session_profile_save_failed, error.message ?: error.javaClass.simpleName)
+            }
+            uiHandler.post {
+                drawerGameNoSteamSaving = false
+                Toast.makeText(this, message, Toast.LENGTH_LONG).show()
+                refreshDrawerGameProfile()
+            }
+        }, "drawer-game-no-steam").start()
+    }
+
     /** The session this screen is bringing up: the live one when re-attached, else the intent's. */
     private fun loadingMode(): String =
         if (SessionState.running) SessionState.mode
@@ -1146,12 +1436,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
     /**
      * Follow screen on a large panel (a Fold's inner screen) may turn with the device: a window
      * locked to landscape on a squarer panel is letterboxed by the system itself, which no output
-     * size can undo. A phone-sized panel (the cover screen) stays landscape as before.
+     * size can undo. Every other case keeps the landscape orientation picked in Setup.
      */
     private fun applyFollowOrientation(config: android.content.res.Configuration) {
-        if (!SessionState.followScreen) return
-        val wanted = if (config.smallestScreenWidthDp >= 600) android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER
-            else android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+        val wanted = if (SessionState.followScreen && config.smallestScreenWidthDp >= 600) {
+            android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER
+        } else {
+            SessionPrefs.orientation(this)
+        }
         if (requestedOrientation != wanted) requestedOrientation = wanted
     }
 
@@ -1438,7 +1730,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
             }
             return true
         }
-        if (pcKeyboardOpen && fromController) return super.dispatchKeyEvent(event)
+        if ((pcKeyboardOpen || achievementsOpen) && fromController) return super.dispatchKeyEvent(event)
         if (event.keyCode != KeyEvent.KEYCODE_BACK && padBridge?.onKeyEvent(event) == true) return true
         // A hardware keyboard, forwarded to the compositor's wl_keyboard. Back is left to the
         // activity, which opens the drawer.
@@ -1491,7 +1783,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
             return true
         }
         if (drawerDirectionKey != KeyEvent.KEYCODE_UNKNOWN) releaseDrawerDirection()
-        if (pcKeyboardOpen && PadBridge.isControllerMotionEvent(event)) return super.dispatchGenericMotionEvent(event)
+        if ((pcKeyboardOpen || achievementsOpen) && PadBridge.isControllerMotionEvent(event)) return super.dispatchGenericMotionEvent(event)
         if (padBridge?.onMotionEvent(event) == true) return true
         if (event.isFromSource(android.view.InputDevice.SOURCE_MOUSE) && !drawerOpen && onMouse(event)) return true
         return super.dispatchGenericMotionEvent(event)
@@ -1929,7 +2221,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
     private fun updatePointerCapture() {
         if (!::surfaceView.isInitialized) return
         val view = window.decorView
-        val want = pointerLocked && resumed && hasWindowFocus() && !drawerOpen && !pcKeyboardOpen && !pipUi && mouseAttached()
+        val want = pointerLocked && resumed && hasWindowFocus() && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && !pipUi && mouseAttached()
         if (want == view.hasPointerCapture()) return
         if (want) view.requestPointerCapture() else view.releasePointerCapture()
     }
@@ -2101,6 +2393,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         if (show) {
             drawerOpen = false
             pcKeyboardOpen = false
+            achievementsOpen = false
             pendingBackAction?.let(uiHandler::removeCallbacks)
             pendingBackAction = null
             releaseDrawerDirection()
@@ -2198,7 +2491,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
 
     override fun onResume() {
         super.onResume()
-        requestedOrientation = SessionPrefs.orientation(this)
+        applyFollowOrientation(resources.configuration)
         if (runtimeRemovalBlocked) return
         com.droiddeck.launcher.ui.Motion.refresh(this)
         refreshHomeApp()
@@ -2208,6 +2501,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         }
         (getSystemService(INPUT_SERVICE) as? InputManager)
             ?.registerInputDeviceListener(deviceListener, Handler(Looper.getMainLooper()))
+        if (SessionState.guestPid > 1) padBridge?.syncConnectedControllers()
         onScreenControls?.reload()
         controllerSettings = ControllerPrefs.read(this)
         updateOnScreenControls()
@@ -2227,6 +2521,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         // drawer's dim layer can otherwise remain over Steam when this activity returns.
         drawerOpen = false
         pcKeyboardOpen = false
+        achievementsOpen = false
         (getSystemService(INPUT_SERVICE) as? InputManager)?.unregisterInputDeviceListener(deviceListener)
         releaseDrawerDirection()
         // A button held when the app goes away would stay held in the ring for the whole session.
@@ -2401,3 +2696,6 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback {
         )
     }
 }
+
+/** [progress]: (unlocked, total) from the cached list. */
+private class AchievementsInFront(val game: StoreAchievements.Game, val title: String, val progress: Pair<Int, Int>?)

app/src/main/java/com/droiddeck/launcher/agent/AgentGuest.kt

@@ -1,6 +1,11 @@
 package com.droiddeck.launcher.agent
 
 import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.setValue
 import android.os.FileObserver
 import android.util.Log
 import com.droiddeck.launcher.runtime.LinuxRuntime
@@ -16,6 +21,9 @@ import java.util.UUID
  * whatever runs does so inside the live session with its own environment.
  */
 object AgentGuest {
+    private val main by lazy { Handler(Looper.getMainLooper()) }
+    var focusRevision by mutableIntStateOf(0)
+        private set
     private const val TAG = "AgentGuest"
     private const val POLL_MS = 50L
     private val lock = Any()
@@ -70,6 +78,7 @@ object AgentGuest {
             if (key == lastFocusKey) return
             lastFocusKey = key
         }
+        main.post { focusRevision++ }
         SessionEvents.record("focus.changed", fields + ("seq" to snapshot.optInt("seq")))
     }
 
@@ -85,6 +94,63 @@ object AgentGuest {
     fun focus(context: Context): JSONObject? =
         if (SessionState.running) readJson(File(dir(context), "focus.json")) else null
 
+    /** The Steam library game whose tile currently has controller or keyboard focus. */
+    fun selectedSteamAppId(context: Context): Long? {
+        val result = call(context, JSONObject().put("kind", "steam-selection"), 6_000)
+        if (!result.optBoolean("ok") || result.isNull("appId")) return null
+        return result.optLong("appId").takeIf { it in 1..4_294_967_295L }
+    }
+
+    /** The installed game Gamescope is presenting, including while Steam's overlay has focus. */
+    fun activeSteamAppId(context: Context, installedAppIds: Set<Long>): Long? {
+        val snapshot = focus(context) ?: return null
+        val focusedAppId = snapshot.optLong("focusedApp").takeIf { snapshot.has("focusedApp") }
+        val focusableAppIds = snapshot.optJSONArray("focusableApps")?.let { apps ->
+            buildList {
+                for (index in 0 until apps.length()) {
+                    apps.optLong(index).takeIf { it > 0 }?.let(::add)
+                }
+            }
+        }.orEmpty()
+        val baselayerAppIds = snapshot.optJSONArray("baselayerAppIds")?.let { apps ->
+            buildList {
+                for (index in 0 until apps.length()) {
+                    apps.optLong(index).takeIf { it > 0 }?.let(::add)
+                }
+            }
+        }.orEmpty()
+        return activeInstalledSteamAppId(focusedAppId, focusableAppIds, installedAppIds, baselayerAppIds)
+    }
+
+    internal fun focusedInstalledSteamAppId(focusedAppId: Long?, installedAppIds: Set<Long>): Long? =
+        focusedAppId?.takeIf { it in installedAppIds }
+
+    internal fun activeInstalledSteamAppId(
+        focusedAppId: Long?,
+        focusableAppIds: List<Long>,
+        installedAppIds: Set<Long>,
+        baselayerAppIds: List<Long> = emptyList(),
+    ): Long? = focusedInstalledSteamAppId(focusedAppId, installedAppIds)
+        ?: focusableAppIds.filter { it in installedAppIds }.distinct().singleOrNull()
+        ?: baselayerAppIds.filter { it in installedAppIds }.distinct().singleOrNull()
+
+    internal fun preferredInstalledSteamAppId(
+        selectedAppId: Long?,
+        activeAppId: Long?,
+        installedAppIds: Set<Long>,
+    ): Long? = selectedAppId?.takeIf { it in installedAppIds }
+        ?: activeAppId?.takeIf { it in installedAppIds }
+
+    internal fun selectedOrActiveInstalledSteamAppId(
+        selectedAppId: Result<Long?>,
+        activeAppId: Long?,
+        installedAppIds: Set<Long>,
+    ): Long? {
+        preferredInstalledSteamAppId(selectedAppId.getOrNull(), activeAppId, installedAppIds)?.let { return it }
+        selectedAppId.exceptionOrNull()?.let { throw it }
+        return null
+    }
+
     /** Send one request and wait for its answer. Throws [AgentException] with a stable code. */
     fun call(context: Context, request: JSONObject, timeoutMs: Long): JSONObject {
         if (request.optString("kind") in setOf("exec", "cdp")) AgentAccess.requireCommands(context)

app/src/main/java/com/droiddeck/launcher/core/CpuAllocationDefaults.kt

@@ -0,0 +1,29 @@
+package com.droiddeck.launcher.core
+
+import com.droiddeck.launcher.gpu.GpuInfo
+import com.droiddeck.launcher.gpu.SocNames
+
+/** Device defaults only: affinity does not reserve cores or lock their clocks. */
+object CpuAllocationDefaults {
+    data class Allocation(val client: String, val game: String)
+
+    val device: Allocation? by lazy {
+        forDevice(SocNames.model(), GpuInfo.systemProperty("ro.board.platform"),
+            CpuCores.all.associateWith(CpuCores::maxGhz))
+    }
+
+    /** Select by topology, including faster SM8550 variants; never guess core indices. */
+    fun forDevice(model: String, platform: String, frequencies: Map<Int, Double?>): Allocation? {
+        val chip = model.trim().uppercase().substringBefore('-')
+        val gen2 = chip in setOf("SM8550", "QCS8550") ||
+            (chip.isEmpty() && platform.trim().equals("kalama", ignoreCase = true))
+        if (!gen2 || frequencies.size != 8 || frequencies.keys.any { it < 0 } ||
+            frequencies.values.any { it == null || !it.isFinite() || it <= 0.0 }) return null
+        val clusters = frequencies.entries.groupBy { it.value }.toSortedMap(compareBy { it ?: 0.0 }).values.toList()
+        if (clusters.map { it.size } != listOf(3, 4, 1)) return null
+        return Allocation(
+            client = CpuCores.format(clusters[2].map { it.key }.toSet()),
+            game = CpuCores.format(clusters[1].map { it.key }.toSet()),
+        )
+    }
+}

app/src/main/java/com/droiddeck/launcher/core/CpuCores.kt

@@ -28,6 +28,10 @@ object CpuCores {
         return format(if (cores.isEmpty()) all.toSet() else cores)
     }
 
+    /** An all-core game must undo the affinity inherited from a pinned Steam client. */
+    fun gameLaunchList(list: String, clientPinned: Boolean): String =
+        restrictionOrEmpty(list).ifEmpty { if (clientPinned) listOrAll("") else "" }
+
     /**
      * The list only when it is a real restriction, else "". Empty, absent, or naming every core
      * all mean "no preference": pinning a process to all cores is what the scheduler does

app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt

@@ -147,7 +147,7 @@ object DeviceReport {
         h("Settings in effect")
         k("Client core override", SessionPrefs.clientCpusOverride(context))
         k("  client cores", CpuCores.listOrAll(SessionPrefs.clientCpus(context)))
-        k("  game cores", CpuCores.restrictionOrEmpty(SessionPrefs.gameCpus(context)).ifEmpty { "every core (nothing sent)" })
+        k("  game cores", CpuCores.restrictionOrEmpty(SessionPrefs.gameCpus(context)).ifEmpty { "every core" })
         k("Turnip sysmem", SessionPrefs.tuSysmem(context))
         k("Zink lazy descriptors", SessionPrefs.zinkLazy(context))
         k("Threaded GL (glthread)", SessionPrefs.glThread(context))

app/src/main/java/com/droiddeck/launcher/core/FexPreset.kt

@@ -30,4 +30,11 @@ object FexPreset {
 
     /** Game-launch variables in KEY=VALUE form. */
     fun env(id: String): List<String> = byId(id).env
+
+    val environmentKeys: Set<String> by lazy {
+        all.flatMap { it.env }.mapTo(linkedSetOf()) { it.substringBefore('=') }
+    }
+
+    fun environment(id: String): Map<String, String> =
+        env(id).associate { it.substringBefore('=') to it.substringAfter('=') }
 }

app/src/main/java/com/droiddeck/launcher/core/GameEnvironment.kt

@@ -44,6 +44,53 @@ object GameEnvironment {
 
     const val FORCE_SSBS = "DROIDDECK_FORCE_SSBS"
 
+    /**
+     * A game's Start without Steam: droiddeck-game-env launches it without Proton's steam.exe (umu's
+     * launch where the Proton has it, else runinprefix), for games that close right away.
+     */
+    const val NO_STEAM = "DROIDDECK_NO_STEAM"
+
+    fun gameNoSteam(config: Config, scope: String): Boolean =
+        scope.isNotEmpty() && config.games[scope]?.get(NO_STEAM)?.lowercase() in setOf("1", "on", "true", "yes")
+
+    fun withGameNoSteam(config: Config, scope: String, on: Boolean): Config {
+        require(scope.isNotEmpty() && validScope(scope))
+        return withScopeValue(config, scope, NO_STEAM, if (on) "1" else null)
+    }
+
     fun effective(config: Config, preset: String, scope: String, forceSsbs: Boolean = false): Map<String, String?> =
         defaults(preset, forceSsbs) + config.shared + if (scope.isEmpty()) emptyMap() else config.games[scope].orEmpty()
+
+    fun hasOverride(config: Config, scope: String, name: String): Boolean =
+        scope.isNotEmpty() && config.entries(scope).containsKey(name)
+
+    fun withScopeValue(config: Config, scope: String, name: String, value: String?): Config {
+        require(scope.isEmpty() || validScope(scope))
+        val entries = config.entries(scope).toMutableMap()
+        if (value == null) entries.remove(name) else entries[name] = value
+        return config.withEntries(scope, entries)
+    }
+
+    fun gameFexPreset(config: Config, scope: String): String? {
+        require(scope.isNotEmpty() && validScope(scope))
+        val entries = config.games[scope].orEmpty()
+        if (FexPreset.environmentKeys.none(entries::containsKey)) return null
+        return FexPreset.all.firstOrNull { preset ->
+            val expected = FexPreset.environment(preset.id)
+            FexPreset.environmentKeys.all { key -> entries.containsKey(key) && entries[key] == expected[key] }
+        }?.id ?: CUSTOM_FEX_PRESET
+    }
+
+    fun withGameFexPreset(config: Config, scope: String, preset: String?): Config {
+        require(scope.isNotEmpty() && validScope(scope))
+        require(preset == null || FexPreset.all.any { it.id == preset })
+        val entries = config.entries(scope).filterKeys { it !in FexPreset.environmentKeys }.toMutableMap()
+        if (preset != null) {
+            val values = FexPreset.environment(preset)
+            FexPreset.environmentKeys.forEach { key -> entries[key] = values[key] }
+        }
+        return config.withEntries(scope, entries)
+    }
+
+    const val CUSTOM_FEX_PRESET = "__custom__"
 }

app/src/main/java/com/droiddeck/launcher/frontend/Library.kt

@@ -31,6 +31,8 @@ object Library {
     ) {
         /** Decimal form used by Steam links and Android shortcuts, including unsigned shortcut ids. */
         val gameIdString: String get() = java.lang.Long.toUnsignedString(gameId)
+        /** Key used by per-game environment and Windows-component profiles. */
+        val profileKey: String get() = if (library == ADDED) java.lang.Integer.toUnsignedString(appId) else appId.toString()
     }
     /** The [SteamGame.library] of a game added to the library rather than installed by Steam, and the [SteamGame.source] of a plain added folder. */
     const val ADDED = "added"

app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java

@@ -50,7 +50,8 @@ public final class TurnipDriver {
     /** Adreno 8xx (8 Elite, e.g. a Fold 8's A830). */
     private static final String DRIVER_A8XX = "turnip-sdk36";
     /** The two the apk carries; never removable, unpacked on demand. */
-    public static final List<String> BUNDLED = Collections.unmodifiableList(Arrays.asList(DRIVER_A7XX, DRIVER_A8XX));
+    public static final List<String> BUNDLED = Collections.unmodifiableList(Arrays.asList(
+            DRIVER_A7XX, DRIVER_A8XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER));
     /** Overrides the pick, for a device we cannot reach: a7xx, a8xx or system. */
     private static final String OVERRIDE_FILE = "Download/droiddeck-driver";
     /** Bundled drivers the user deleted: hidden from the list, their unpacked copy removed. */

app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java

@@ -566,6 +566,16 @@ public class FakeInputWriter {
         }
     }
 
+    /**
+     * Whether the pad, as the Steam client now sees it, has a Quick Access button: a Deck's or a
+     * Steam Controller's does, an Xbox or PlayStation pad's does not (libfakeinput drops the bit).
+     * Unset is the Deck, libfakeinput's default.
+     */
+    public static boolean padHasQam() {
+        int type = padType;
+        return type < 0 || type == PAD_TYPE_DECK || type == PAD_TYPE_STEAM;
+    }
+
     /**
      * Switches what the pad is to the Steam client while the session runs ([PAD_TYPE_DECK],
      * [PAD_TYPE_STEAM] or [PAD_TYPE_XBOX]); libfakeinput unplugs the old device and plugs in the new.

app/src/main/java/com/droiddeck/launcher/input/PadBridge.java

@@ -257,6 +257,14 @@ public final class PadBridge {
         return false;
     }
 
+    /** Publishes every currently connected controller so the client can enumerate all players. */
+    public synchronized void syncConnectedControllers() {
+        for (int deviceId : InputDevice.getDeviceIds()) {
+            InputDevice device = InputDevice.getDevice(deviceId);
+            if (isFromController(device)) publish(slotFor(device));
+        }
+    }
+
     /**
      * Called (main thread) when a player presses a button, pushes a stick, trigger or d-pad past
      * halfway, or uses the on-screen controls - the session hides its mouse cursor then. Resting
@@ -392,8 +400,8 @@ public final class PadBridge {
         boolean qamStarted = qamPressed && !systemQamPressed;
         systemGuidePressed = guidePressed;
         systemQamPressed = qamPressed;
-        // A Deck controller's QAM button is held for as long as the touch one is.
-        if (qamStarted && !SessionState.getDeckPad()) startQamChord();
+        // A Deck or Steam Controller's QAM button is held for as long as the touch one is.
+        if (qamStarted && !nativeQam()) startQamChord();
         else publish();
     }
 
@@ -418,9 +426,18 @@ public final class PadBridge {
         }
     }
 
-    /** Opens the client's Quick Access menu: a tap of the Deck's button, or the Guide-then-A chord. */
+    /**
+     * Whether the client's pad has its own QAM button to press. The Deck's sysfs being up is not
+     * enough: the drawer can make the pad an Xbox or PlayStation one, which has none, and a press
+     * of it never reaches the client.
+     */
+    private static boolean nativeQam() {
+        return SessionState.getDeckPad() && FakeInputWriter.padHasQam();
+    }
+
+    /** Opens the client's Quick Access menu: a tap of the pad's button, or the Guide-then-A chord. */
     public synchronized void triggerQam() {
-        if (!SessionState.getDeckPad()) {
+        if (!nativeQam()) {
             startQamChord();
             return;
         }
@@ -563,7 +580,7 @@ public final class PadBridge {
             return;
         }
         boolean guide = systemGuidePressed || qamChordActive;
-        boolean qam = SessionState.getDeckPad() && (systemQamPressed || qamTapPressed);
+        boolean qam = nativeQam() && (systemQamPressed || qamTapPressed);
         if (!guide && !qam) {
             writer.writePad(state);
             return;

app/src/main/java/com/droiddeck/launcher/input/TouchpadGestures.kt

@@ -59,15 +59,31 @@ class TouchpadGestures(
     private var moverLastX = 0f
     private var moverLastY = 0f
     private var holdDrag = false
+    private var clicked = 0
     private val longPress = Runnable {
         held = true
         dragging = true
         listener.onLongPress()
         listener.onButton(PointerGestures.BTN_LEFT, true, x, y)
     }
+    private val clickUp = Runnable { releaseClick() }
+
+    private fun click(button: Int) {
+        releaseClick()
+        listener.onButton(button, true, x, y)
+        clicked = button
+        handler.postDelayed(clickUp, CLICK_MS)
+    }
+
+    private fun releaseClick() {
+        handler.removeCallbacks(clickUp)
+        if (clicked != 0) listener.onButton(clicked, false, x, y)
+        clicked = 0
+    }
 
     fun cancel() {
         handler.removeCallbacks(longPress)
+        releaseClick()
         if (dragging) listener.onButton(PointerGestures.BTN_LEFT, false, x, y)
         dragging = false
         held = false
@@ -85,6 +101,7 @@ class TouchpadGestures(
     fun onTouch(event: MotionEvent): Boolean {
         when (event.actionMasked) {
             MotionEvent.ACTION_DOWN -> {
+                releaseClick()
                 lastX = event.x; lastY = event.y
                 downAt = event.eventTime
                 travelled = 0f; held = false; twoFingers = false; scrolled = false; secondWasTap = false
@@ -204,8 +221,7 @@ class TouchpadGestures(
                 }
                 // The second finger lifting quickly, with nothing scrolled: a right click.
                 if (twoFingers && secondWasTap && event.eventTime - secondDownAt < TAP_MS && !scrolled) {
-                    listener.onButton(PointerGestures.BTN_RIGHT, true, x, y)
-                    listener.onButton(PointerGestures.BTN_RIGHT, false, x, y)
+                    click(PointerGestures.BTN_RIGHT)
                     secondWasTap = false
                 }
                 return true
@@ -218,13 +234,11 @@ class TouchpadGestures(
                     twoFingers -> {
                         // Both fingers down and up together, no scroll: a right click.
                         if (secondWasTap && !scrolled && !cancelled && event.eventTime - downAt < TAP_MS * 2) {
-                            listener.onButton(PointerGestures.BTN_RIGHT, true, x, y)
-                            listener.onButton(PointerGestures.BTN_RIGHT, false, x, y)
+                            click(PointerGestures.BTN_RIGHT)
                         }
                     }
                     !cancelled && travelled <= slopPx && event.eventTime - downAt < TAP_MS -> {
-                        listener.onButton(PointerGestures.BTN_LEFT, true, x, y)
-                        listener.onButton(PointerGestures.BTN_LEFT, false, x, y)
+                        click(PointerGestures.BTN_LEFT)
                         lastTapAt = event.eventTime
                     }
                 }
@@ -239,6 +253,7 @@ class TouchpadGestures(
     companion object {
         private const val HOLD_MS = 500L
         private const val TAP_MS = 300L
+        private const val CLICK_MS = 50L
         private const val DOUBLE_TAP_MS = 300L
         private const val SCROLL_STEP_PX = 36f
     }

app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt

@@ -33,7 +33,7 @@ import java.util.concurrent.atomic.AtomicInteger
  */
 object BwrapSpawner {
     private const val TAG = "BwrapSpawner"
-    const val SOCKET = "com.droiddeck.launcher.bwrap"
+    fun socket(context: Context): String = "${context.packageName}.bwrap"
     private val seq = AtomicInteger()
     @Volatile private var server: LocalServerSocket? = null
 
@@ -42,10 +42,11 @@ object BwrapSpawner {
     fun start(context: Context) {
         if (server != null) return
         val app = context.applicationContext
+        val name = socket(app)
         val socket = try {
-            LocalServerSocket(SOCKET)
+            LocalServerSocket(name)
         } catch (e: IOException) {
-            Log.e(TAG, "cannot listen on $SOCKET", e)
+            Log.e(TAG, "cannot listen on $name", e)
             return
         }
         server = socket

app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt

@@ -110,6 +110,9 @@ object DesktopCatalog {
         return File(root, DesktopRemoval.PENDING).exists() || marker(context, DESKTOP_ID).exists()
     }
 
+    /** The installed desktop's size on disk; off the main thread. */
+    fun desktopSize(context: Context): Long = DesktopRemoval.installedSize(context)
+
     fun cleanLegacy(context: Context, listener: LinuxRuntimeInstaller.ProgressListener? = null) =
         DesktopRemoval.cleanLegacy(context, listener)
 

app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt

@@ -19,6 +19,14 @@ internal object DesktopRemoval {
     private fun protected(context: Context, root: File) =
         DesktopFileRemoval.runtimeFiles(root) + lines(context, "emulators-keep.txt.gzip")
 
+    /**
+     * What the desktop's own files take on disk, from the same inventory its removal uses (each
+     * file's size); the bundled apps' and emulators' shared files are not counted. Reads an asset:
+     * call it off the main thread.
+     */
+    fun installedSize(context: Context): Long =
+        lines(context, "kde-remove.tsv.gzip").sumOf { line -> line.split('\t').getOrNull(1)?.toLongOrNull() ?: 0L }
+
     /** Called before a guest starts or just after KDE extraction; retries after a process death. */
     fun cleanLegacy(context: Context, listener: LinuxRuntimeInstaller.ProgressListener? = null) {
         val root = LinuxRuntime.rootDir(context)

app/src/main/java/com/droiddeck/launcher/runtime/GuestCommand.kt

@@ -51,6 +51,7 @@ object GuestCommand {
             "/usr/bin/env", "-i", "HOME=/root", "USER=root", "LANG=C.UTF-8",
             "PATH=/usr/local/bin:/usr/bin:/bin", "XDG_RUNTIME_DIR=${LinuxRuntime.GUEST_RUNTIME_DIR}",
             "XDG_DATA_HOME=/root/.local/share", "FLATPAK_BWRAP=${FlatpakManager.BWRAP}",
+            "DROIDDECK_BWRAP_SOCKET=${BwrapSpawner.socket(context)}",
             "XDG_DATA_DIRS=/root/.local/share/flatpak/exports/share:/usr/local/share:/usr/share",
         )
         cmd += argv

app/src/main/java/com/droiddeck/launcher/session/ComponentsManager.kt

@@ -6,6 +6,7 @@ import android.content.Context
 import android.util.Log
 import com.droiddeck.launcher.core.Downloader
 import com.droiddeck.launcher.core.FileUtils
+import com.droiddeck.launcher.core.GameEnvironment
 import com.droiddeck.launcher.gpu.GpuInfo
 import com.droiddeck.launcher.runtime.LinuxRuntime
 import com.github.luben.zstd.ZstdInputStream
@@ -79,7 +80,14 @@ object ComponentsManager {
     private const val PLUGIN_DATA = "root/homebrew/data/decky-components-manager"
 
     data class Proton(val id: String, val name: String, val dir: File, val guestPath: String, val version: String, val valve: Boolean)
-    data class Component(val detected: String, val detail: String, val inUse: String, val activeFile: String?, val queued: String?)
+    data class Component(
+        val detected: String,
+        val detail: String,
+        val inUse: String,
+        val selected: String,
+        val activeFile: String?,
+        val queued: String?,
+    )
     data class Original(val comp: String, val protonVersion: String, val label: String, val size: Long)
     data class Package(val file: String, val comp: String, val version: String, val description: String, val size: Long)
     data class CatalogItem(val file: String, val comp: String, val release: String, val url: String, val size: Long, val digest: String)
@@ -129,23 +137,121 @@ object ComponentsManager {
 
     // ------------------------------------------------------------------ state
 
-    private fun loadState(context: Context): JSONObject =
-        runCatching { JSONObject(stateFile(context).readText()) }.getOrElse { JSONObject() }.apply {
+    private fun pendingStateFile(context: Context) = File(dataDir(context), "state.pending.json")
+
+    private fun loadState(context: Context): JSONObject {
+        recoverState(context)
+        return runCatching { JSONObject(stateFile(context).readText()) }.getOrElse { JSONObject() }.apply {
             if (!has("active")) put("active", JSONObject())
             if (!has("queued")) put("queued", JSONObject())
+            if (!has("profiles")) put("profiles", JSONObject())
         }
+    }
+
+    private fun writeStateFile(file: File, text: String) {
+        val tmp = File(file.parentFile, file.name + ".tmp")
+        try {
+            writeSynced(tmp, text)
+            check(tmp.renameTo(file)) { "Could not save component selections: ${file.name}" }
+        } finally {
+            tmp.delete()
+        }
+    }
+
+    private fun writeSynced(file: File, text: String) {
+        FileOutputStream(file).use {
+            it.write(text.toByteArray(Charsets.UTF_8))
+            it.fd.sync()
+        }
+    }
+
+    private fun recoverState(context: Context) {
+        val pending = pendingStateFile(context)
+        if (!pending.exists()) return
+        val transaction = JSONObject(pending.readText())
+        val state = transaction.getJSONObject("state")
+        val expected = transaction.getString("launchSha256")
+        val published = File(launchDir(context), "desired.tsv")
+        val staged = File(launchDir(context), "desired.tsv.tmp")
+        // The launch-table rename is the commit point. Never read stale app selections after it.
+        if (!staged.exists() && published.isFile && Hashes.sha256(published) == expected) {
+            writeStateFile(stateFile(context), state.toString(2))
+            Log.i(TAG, "recovered published component selections")
+        } else {
+            Log.i(TAG, "discarded unpublished component selections")
+        }
+        check(pending.delete()) { "Could not finish component selection recovery" }
+        if (staged.exists()) check(staged.delete()) { "Could not remove unpublished component selections" }
+    }
 
     private fun saveState(context: Context, state: JSONObject) {
-        val f = stateFile(context)
-        val tmp = File(f.parentFile, f.name + ".tmp")
-        tmp.writeText(state.toString(2))
-        tmp.renameTo(f)
-        // Every change of choice reaches the launch wrappers at once.
-        runCatching { syncLaunchState(context, state) }.onFailure { Log.w(TAG, "launch state", it) }
+        val prepared = prepareLaunchState(context, state)
+        val dir = launchDir(context)
+        val tmp = File(dir, "desired.tsv.tmp")
+        try {
+            writeSynced(tmp, prepared.text)
+            writeStateFile(pendingStateFile(context), JSONObject()
+                .put("state", state)
+                .put("launchSha256", Hashes.sha256(tmp))
+                .toString())
+            check(tmp.renameTo(File(dir, "desired.tsv"))) { "Could not publish component selections" }
+            writeStateFile(stateFile(context), state.toString(2))
+            check(pendingStateFile(context).delete()) { "Could not finish saving component selections" }
+        } finally {
+            if (!pendingStateFile(context).exists()) tmp.delete()
+        }
+        File(dir, "store").listFiles()?.filter { it.isDirectory && it.name !in prepared.keep }
+            ?.forEach { it.deleteRecursively() }
     }
 
     private fun JSONObject.sub(key: String): JSONObject = optJSONObject(key) ?: JSONObject().also { put(key, it) }
 
+    // Keep launch-time restore rows after the last per-game selection is removed.
+    private fun rememberProfiledComponent(state: JSONObject, comp: String) {
+        val profiled = state.optJSONArray("profiledComponents")?.let { values ->
+            (0 until values.length()).mapNotNull { values.optString(it).takeIf(COMPONENTS::contains) }
+        }.orEmpty().toMutableSet()
+        if (profiled.add(comp)) state.put("profiledComponents", JSONArray(profiled.sorted()))
+    }
+
+    fun gameComponents(context: Context, scope: String): Map<String, String> = synchronized(lock) {
+        val profile = loadState(context).sub("profiles").optJSONObject(scope) ?: return emptyMap()
+        COMPONENTS.mapNotNull { comp -> profile.optString(comp).takeIf(String::isNotEmpty)?.let { comp to it } }.toMap()
+    }
+
+    fun setGameComponent(context: Context, scope: String, comp: String, file: String?) = synchronized(lock) {
+        require(scope.matches(Regex("[1-9][0-9]{0,9}")) && scope.toLong() <= 4294967295L)
+        require(comp in COMPONENTS)
+        val state = loadState(context)
+        val profiles = state.sub("profiles")
+        val profile = profiles.optJSONObject(scope) ?: JSONObject().also { profiles.put(scope, it) }
+        if (file == null) {
+            if (profile.optString(comp).isNotEmpty()) rememberProfiledComponent(state, comp)
+            profile.remove(comp)
+            if (profile.length() == 0) profiles.remove(scope)
+        } else {
+            val name = safeName(file)
+            val wcp = File(packagesDir(context), name)
+            require(packageInfo(context, wcp).comp == comp)
+            for (proton in protons(context)) ensureOriginal(context, proton, comp, state)
+            rememberProfiledComponent(state, comp)
+            profile.put(comp, name)
+        }
+        saveState(context, state)
+    }
+
+    fun clearGameComponents(context: Context, scope: String) = synchronized(lock) {
+        require(GameEnvironment.validScope(scope))
+        val state = loadState(context)
+        val profiles = state.sub("profiles")
+        profiles.optJSONObject(scope)?.let { profile ->
+            COMPONENTS.filter { profile.optString(it).isNotEmpty() }
+                .forEach { rememberProfiledComponent(state, it) }
+        }
+        profiles.remove(scope)
+        saveState(context, state)
+    }
+
     /** Takes over the Decky plugin's packages, originals and swap records, once. */
     private fun migratePlugin(context: Context) {
         val marker = File(dataDir(context), ".plugin-imported")
@@ -220,24 +326,33 @@ object ComponentsManager {
      * Is anything running on this Proton right now - a game, or the client's own start-up runs,
      * whose Wine processes can outlive them? Swaps wait while it is. Read from the command lines.
      */
-    fun inUse(context: Context, proton: Proton): Boolean = anyProcess(context, proton) { needle, text -> text.contains(needle + "proton ") || text.contains(needle + "files/bin") }
+    fun inUse(context: Context, proton: Proton): Boolean =
+        anyProcess(context, proton) { paths, text -> processUsesProton(paths, text, gameOnly = false) }
 
     /**
      * Is a game running on this Proton? Only a launch runs proton with the verb waitforexitandrun
      * (Proton's own script stays up until the game exits); the client's start-up runs do not.
      */
-    fun gameRunning(context: Context, proton: Proton): Boolean = anyProcess(context, proton) { needle, text -> text.contains(needle + "proton waitforexitandrun") }
+    fun gameRunning(context: Context, proton: Proton): Boolean =
+        anyProcess(context, proton) { paths, text -> processUsesProton(paths, text, gameOnly = true) }
 
-    private fun anyProcess(context: Context, proton: Proton, match: (String, String) -> Boolean): Boolean {
-        val needles = (listOf(proton.guestPath) + EsyncPacks.distPathsFor(root(context), proton.guestPath))
-            .map { it.trimEnd('/') + "/" }
+    internal fun processUsesProton(paths: List<String>, text: String, gameOnly: Boolean): Boolean =
+        paths.any { path ->
+            val needle = path.trimEnd('/') + "/"
+            if (gameOnly) text.contains(needle + "proton waitforexitandrun")
+            else text.contains(needle + "proton ") || text.contains(needle + "files/bin")
+        }
+
+    private fun anyProcess(context: Context, proton: Proton, match: (List<String>, String) -> Boolean): Boolean {
+        val guestPaths = listOf(proton.guestPath) + EsyncPacks.distPathsFor(root(context), proton.guestPath)
+        val paths = (guestPaths + guestPaths.map { host(context, it).absolutePath } + proton.dir.absolutePath).distinct()
         val procs = File("/proc").listFiles() ?: return false
         for (p in procs) {
             if (!p.name.all(Char::isDigit)) continue
             val cmd = runCatching { File(p, "cmdline").readBytes() }.getOrNull() ?: continue
             if (cmd.isEmpty()) continue
             val text = String(cmd).replace('\u0000', ' ')
-            if (needles.any { match(it, text) }) return true
+            if (match(paths, text)) return true
         }
         return false
     }
@@ -261,7 +376,7 @@ object ComponentsManager {
     private fun compFiles(dir: File, comp: String): List<String> {
         if (comp == "fex") return FEX_FILES.filter { File(dir, it).isFile }
         val base = File(dir, COMP_DIR.getValue(comp))
-        return base.walkTopDown().filter { it.isFile }.map { it.relativeTo(dir).path }.sorted().toList()
+        return base.walkTopDown().filter { it.isFile }.map { it.relativeTo(dir).invariantSeparatorsPath }.sorted().toList()
     }
 
     private fun owned(comp: String, rel: String) = comp == "fex" || PE_ARCHES.any { "/$it/" in rel }
@@ -291,9 +406,11 @@ object ComponentsManager {
         return Package(f.name, comp, prof.optString("versionName", f.nameWithoutExtension), prof.optString("description"), f.length())
     }
 
+    /** The stored packages, newest version first. */
     fun packages(context: Context): List<Package> = packagesDir(context).listFiles()
-        ?.filter { it.isFile && it.name.endsWith(".wcp") }?.sortedBy { it.name }
+        ?.filter { it.isFile && it.name.endsWith(".wcp") }
         ?.mapNotNull { f -> runCatching { packageInfo(context, f) }.onFailure { Log.w(TAG, "skipping ${f.name}", it) }.getOrNull() }
+        ?.sortedWith(newestFirst { it.version.ifEmpty { it.file } })
         ?: emptyList()
 
     /** Unpacks a package's files/ into a Proton; for DXVK/VKD3D the component's own DLLs are replaced as a set. */
@@ -352,7 +469,7 @@ object ComponentsManager {
                 tar.closeArchiveEntry()
             }
         }
-        tmp.renameTo(dest)
+        check(tmp.renameTo(dest)) { "Could not save original bundle ${dest.name}" }
     }
 
     // ------------------------------------------------------------------ originals
@@ -380,8 +497,18 @@ object ComponentsManager {
         if (dest.isFile) return
         val active = state.sub("active").optJSONObject(p.id)?.optJSONObject(comp)
         if (active != null && active.optString("protonVersion") == p.version) return
+        val published = File(launchDir(context), "desired.tsv")
+        if (published.isFile) {
+            val mayHaveOverride = published.useLines { rows ->
+                rows.any { row ->
+                    val fields = row.split('\t')
+                    fields.size == 7 && fields[0] != "*" && fields[1] == p.dir.name &&
+                        fields[2] == p.version && fields[3] == comp
+                }
+            }
+            check(!mayHaveOverride) { context.getString(R.string.cmgr_original_missing) }
+        }
         val rels = compFiles(p.dir, comp)
-        if (rels.isEmpty()) return
         val current = if (comp == "fex") fexVersion(p.dir) else readVersionFile(File(p.dir, "${COMP_DIR.getValue(comp)}/version"))
         val profile = JSONObject()
             .put("type", TYPE_OF.getValue(comp))
@@ -400,7 +527,7 @@ object ComponentsManager {
         for (p in protons(context)) for (comp in COMPONENTS) {
             runCatching { ensureOriginal(context, p, comp, state) }.onFailure { Log.w(TAG, "original $comp of ${p.name}", it) }
         }
-        runCatching { syncLaunchState(context, state) }.onFailure { Log.w(TAG, "launch state", it) }
+        runCatching { saveState(context, state) }.onFailure { Log.w(TAG, "launch state", it) }
     }
 
     // ------------------------------------------------------------------ view
@@ -431,9 +558,14 @@ object ComponentsManager {
                         else context.getString(R.string.cmgr_changed_outside)
                     }
                 }
+                val selectedLabel = when {
+                    active == null || active.optString("protonVersion") != p.version ->
+                        context.getString(R.string.comp_tag_original)
+                    else -> originalLabel(context, active) ?: active.optString("label", active.optString("file"))
+                }
                 val q = state.sub("queued").optJSONObject(p.id)?.optJSONObject(comp)
                 Component(
-                    detected.ifEmpty { context.getString(R.string.cmgr_not_present) }, detail, inUseLabel,
+                    detected.ifEmpty { context.getString(R.string.cmgr_not_present) }, detail, inUseLabel, selectedLabel,
                     active?.optString("file")?.takeIf { active.optString("protonVersion") == p.version },
                     q?.let { originalLabel(context, it) ?: it.optString("label") },
                 )
@@ -455,64 +587,111 @@ object ComponentsManager {
 
     // ------------------------------------------------------------------ launch-time enforcement
 
+    private data class PreparedLaunchState(val text: String, val keep: Set<String>)
+
     /**
-     * Writes what each Proton should be using for the launch wrappers: desired.tsv, one line per
-     * file (tool dir, Proton build, component, file, sha256, source copy), and an unpacked copy of
-     * every package or older-build original in use to copy from. Rebuilt whole after every change, so
-     * a restored or deleted choice simply stops being enforced. The Proton's own current-build
-     * originals are not listed: the wrappers also give Steam's probe runs their own prefix, which is
-     * what overwrote files in the first place.
+     * Stages what each Proton should use for the launch wrappers. General rows use scope `*`;
+     * per-game rows use the game's compatdata id and replace General for that component. Deletion
+     * rows remove managed DLLs absent from the chosen package, so switching games cannot leave files
+     * from the previous game's component set behind.
      */
-    private fun syncLaunchState(context: Context, state: JSONObject) {
+    private fun prepareLaunchState(context: Context, state: JSONObject): PreparedLaunchState {
         val dir = launchDir(context)
         val store = File(dir, "store").apply { mkdirs() }
         val all = protons(context)
         val lines = StringBuilder()
         val keep = HashSet<String>()
-        val active = state.sub("active")
-        for (pid in active.keys()) {
-            val p = all.firstOrNull { it.id == pid } ?: continue
-            val comps = active.optJSONObject(pid) ?: continue
-            for (comp in comps.keys()) {
-                val a = comps.optJSONObject(comp) ?: continue
-                if (a.optString("protonVersion") != p.version) continue
-                val file = a.optString("file")
-                val (key, wcp) = if (file.startsWith("original ")) {
-                    val v = file.removePrefix("original ")
-                    "original-$pid-${safeName(v)}-$comp" to File(originalsDir(context), "$pid/${safeName(v)}/$comp.wcp")
-                } else safeName(file.removeSuffix(".wcp")) to File(packagesDir(context), file)
-                if (!wcp.isFile) continue
-                val unpacked = File(store, key)
-                if (!File(unpacked, ".complete").isFile) {
-                    unpacked.deleteRecursively()
-                    readWcp(wcp) { tar ->
-                        while (true) {
-                            val e = tar.nextTarEntry ?: break
-                            val rel = normalize(e.name)
-                            if (e.isDirectory || !rel.startsWith("files/") || rel.split('/').any { it == ".." }) continue
-                            val out = File(unpacked, rel)
-                            out.parentFile?.mkdirs()
-                            FileOutputStream(out).use { tar.copyTo(it) }
-                        }
+
+        fun unpack(key: String, wcp: File, comp: String): File {
+            check(wcp.isFile) { context.getString(R.string.cmgr_not_stored) }
+            val unpacked = File(store, key)
+            if (!File(unpacked, ".complete").isFile) {
+                check(packageInfo(context, wcp).comp == comp) { "Wrong component in ${wcp.name}" }
+                unpacked.deleteRecursively()
+                check(unpacked.mkdirs()) { "Could not stage component bundle ${wcp.name}" }
+                readWcp(wcp) { tar ->
+                    while (true) {
+                        val e = tar.nextTarEntry ?: break
+                        val rel = normalize(e.name)
+                        if (e.isDirectory || !rel.startsWith("files/") || rel.split('/').any { it == ".." }) continue
+                        val out = File(unpacked, rel)
+                        out.parentFile?.mkdirs()
+                        FileOutputStream(out).use { tar.copyTo(it) }
                     }
-                    File(unpacked, ".complete").writeText("1\n")
-                }
-                keep += key
-                val files = a.optJSONObject("files") ?: continue
-                for (rel in files.keys()) {
-                    val src = File(unpacked, rel)
-                    if (!src.isFile) continue
-                    val guestSrc = "/" + src.absolutePath.removePrefix(root(context).absolutePath.trimEnd('/')).trimStart('/')
-                    lines.append(p.dir.name).append('\t').append(p.version).append('\t').append(comp).append('\t')
-                        .append(rel).append('\t').append(files.optString(rel)).append('\t').append(guestSrc).append('\n')
                 }
+                File(unpacked, ".complete").writeText("1\n")
+            }
+            keep += key
+            return unpacked
+        }
+
+        fun managed(comp: String): Set<String> = if (comp == "fex") FEX_FILES.toSet() else buildSet {
+            for (arch in PE_ARCHES) for (dll in COMP_DLLS.getValue(comp)) add("${COMP_DIR.getValue(comp)}/$arch/$dll")
+        }
+
+        fun append(scope: String, p: Proton, comp: String, key: String, wcp: File) {
+            val unpacked = unpack(key, wcp, comp)
+            val files = unpacked.let { base ->
+                File(base, "files").walkTopDown().filter { it.isFile }.map { it.relativeTo(base).invariantSeparatorsPath }
+                    .filter { owned(comp, it) }.associateWith { File(base, it) }
+            }
+            for (rel in managed(comp) - files.keys) {
+                lines.append(scope).append('\t').append(p.dir.name).append('\t').append(p.version).append('\t').append(comp)
+                    .append('\t').append(rel).append("\t-\t-\n")
+            }
+            for ((rel, src) in files) {
+                val guestSrc = "/" + src.relativeTo(root(context)).invariantSeparatorsPath
+                lines.append(scope).append('\t').append(p.dir.name).append('\t').append(p.version).append('\t').append(comp)
+                    .append('\t').append(rel).append('\t').append(Hashes.sha256(src)).append('\t').append(guestSrc).append('\n')
             }
         }
-        store.listFiles()?.filter { it.isDirectory && it.name !in keep }?.forEach { it.deleteRecursively() }
-        val list = File(dir, "desired.tsv")
-        val tmp = File(dir, "desired.tsv.tmp")
-        tmp.writeText(lines.toString())
-        tmp.renameTo(list)
+
+        fun choice(p: Proton, comp: String, entry: JSONObject): Pair<String, File>? {
+            val file = entry.optString("file")
+            return if (file.startsWith("original ")) {
+                val version = safeName(file.removePrefix("original "))
+                "original-${p.id}-$version-$comp" to File(originalsDir(context), "${p.id}/$version/$comp.wcp")
+            } else {
+                safeName(file.removeSuffix(".wcp")) to File(packagesDir(context), file)
+            }.takeIf { it.second.isFile }
+        }
+
+        val profiles = state.sub("profiles")
+        val profiledComponents = buildSet {
+            state.optJSONArray("profiledComponents")?.let { stored ->
+                for (index in 0 until stored.length()) {
+                    stored.optString(index).takeIf(COMPONENTS::contains)?.let(::add)
+                }
+            }
+            for (scope in profiles.keys()) {
+                val profile = profiles.optJSONObject(scope) ?: continue
+                COMPONENTS.filterTo(this) { profile.optString(it).isNotEmpty() }
+            }
+        }
+        val active = state.sub("active")
+        for (p in all) for (comp in COMPONENTS) {
+            val entry = active.optJSONObject(p.id)?.optJSONObject(comp)
+            val selected = entry?.takeIf { it.optString("protonVersion") == p.version }?.let { choice(p, comp, it) }
+            if (selected != null) append("*", p, comp, selected.first, selected.second)
+            else if (comp in profiledComponents) {
+                ensureOriginal(context, p, comp, state)
+                val original = originalFile(context, p, comp)
+                check(original.isFile) { context.getString(R.string.cmgr_original_missing) }
+                append("*", p, comp, "original-${p.id}-${safeName(p.version)}-$comp", original)
+            }
+        }
+        for (scope in profiles.keys()) {
+            val profile = profiles.optJSONObject(scope) ?: continue
+            for (comp in COMPONENTS) {
+                val file = profile.optString(comp)
+                if (file.isEmpty()) continue
+                val wcp = File(packagesDir(context), file)
+                if (!wcp.isFile) continue
+                val key = safeName(file.removeSuffix(".wcp"))
+                for (p in all) append(scope, p, comp, key, wcp)
+            }
+        }
+        return PreparedLaunchState(lines.toString(), keep)
     }
 
     // ------------------------------------------------------------------ actions
@@ -615,6 +794,11 @@ object ComponentsManager {
             val comps = active.optJSONObject(pid) ?: continue
             for (comp in comps.keys()) check(comps.optJSONObject(comp)?.optString("file") != name) { context.getString(R.string.cmgr_package_in_use, name, pid) }
         }
+        val profiles = state.sub("profiles")
+        for (scope in profiles.keys()) {
+            val profile = profiles.optJSONObject(scope) ?: continue
+            check(COMPONENTS.none { profile.optString(it) == name }) { context.getString(R.string.cmgr_package_in_use, name, scope) }
+        }
         val f = File(packagesDir(context), name)
         check(f.isFile) { context.getString(R.string.cmgr_package_not_stored, name) }
         f.delete()
@@ -670,10 +854,14 @@ object ComponentsManager {
         val arr = o.optJSONArray("items") ?: JSONArray()
         val items = (0 until arr.length()).map { arr.getJSONObject(it) }.map {
             CatalogItem(it.optString("file"), it.optString("comp"), it.optString("release"), it.optString("url"), it.optLong("size"), it.optString("digest"))
-        }.sortedWith(compareBy({ it.comp }, { it.release }, { it.file }))
+        }.sortedWith(compareBy<CatalogItem> { it.comp }.then(newestFirst { it.file }))
         return Catalog(items, o.optLong("fetchedAt"))
     }
 
+    /** By the version in [of], highest first: the newest builds lead a list, as they are what is picked. */
+    private fun <T> newestFirst(of: (T) -> String): Comparator<T> =
+        Comparator { a, b -> ProtonExtras.compareVersions(of(b), of(a)) }
+
     /**
      * A package Proton does not ship, required on the GPUs listed here. An empty [models] set
      * means every model in [families]. A row the user already chose in Components is left alone;

app/src/main/java/com/droiddeck/launcher/session/CrashHandler.kt

@@ -24,6 +24,12 @@ object CrashHandler {
         Thread.setDefaultUncaughtExceptionHandler { thread, error ->
             try {
                 Log.e(TAG, "uncaught on ${thread.name}", error)
+                if (QuestExperimental.isSupported()) runCatching {
+                    File(context.filesDir, "quest-last-crash.txt").writeText(
+                        "${java.time.Instant.now()} thread=${thread.name}\n" +
+                            StringWriter().also { error.printStackTrace(PrintWriter(it)) }.toString()
+                    )
+                }
                 val dir = SessionPaths.current()
                 if (dir != null && dir.isDirectory) {
                     val trace = StringWriter().also { error.printStackTrace(PrintWriter(it)) }.toString()

app/src/main/java/com/droiddeck/launcher/session/GameEnvironmentStore.kt

@@ -13,6 +13,7 @@ object GameEnvironmentStore {
     private const val GUEST_FILE = "root/.config/droiddeck/game-environment.json"
     /** The published file's extra DXVK options (droiddeck-game-env reads it; the app's own file has none). */
     const val DXVK_CONFIG = "dxvkConfig"
+    const val DXVK_CONFIG_GAMES = "dxvkConfigGames"
 
     @Synchronized
     fun read(context: Context): GameEnvironment.Config {
@@ -57,6 +58,20 @@ object GameEnvironmentStore {
         publish(context, config)
     }
 
+    @Synchronized
+    fun setGameFexPreset(context: Context, scope: String, preset: String?): GameEnvironment.Config {
+        val config = GameEnvironment.withGameFexPreset(read(context), scope, preset)
+        save(context, config)
+        return config
+    }
+
+    @Synchronized
+    fun setGameNoSteam(context: Context, scope: String, on: Boolean): GameEnvironment.Config {
+        val config = GameEnvironment.withGameNoSteam(read(context), scope, on)
+        save(context, config)
+        return config
+    }
+
     @Synchronized
     fun publish(context: Context, config: GameEnvironment.Config = read(context)) {
         val resolved = config.copy(shared = GameEnvironment.defaults(SessionPrefs.fexPreset(context), SessionPrefs.forceSsbs(context)) + config.shared)
@@ -68,6 +83,21 @@ object GameEnvironmentStore {
             TextureFiltering.autoLodBias(SessionState.upscaleRatio),
         )
         if (dxvk.isNotEmpty()) json.put(DXVK_CONFIG, dxvk)
+        val autoBias = TextureFiltering.autoLodBias(SessionState.upscaleRatio)
+        val generalAnisotropy = SessionPrefs.textureAnisotropy(context)
+        val generalLodBias = SessionPrefs.textureLodBias(context)
+        val gameDxvk = JSONObject()
+        SessionPrefs.gameTextureFiltering(context).forEach { (scope, choice) ->
+            gameDxvk.put(
+                scope,
+                TextureFiltering.dxvkOptions(
+                    choice.anisotropy ?: generalAnisotropy,
+                    choice.lodBias ?: generalLodBias,
+                    autoBias,
+                ),
+            )
+        }
+        if (gameDxvk.length() > 0) json.put(DXVK_CONFIG_GAMES, gameDxvk)
         write(File(LinuxRuntime.rootDir(context), GUEST_FILE), json.toString())
     }
 

app/src/main/java/com/droiddeck/launcher/session/GameProfileFollowState.kt

@@ -0,0 +1,14 @@
+package com.droiddeck.launcher.session
+
+internal class GameProfileFollowState {
+    var followsSteam = true
+        private set
+
+    fun selectManually() {
+        followsSteam = false
+    }
+
+    fun resumeFollowingSteam() {
+        followsSteam = true
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/GameProfileInventoryCache.kt

@@ -0,0 +1,16 @@
+package com.droiddeck.launcher.session
+
+internal class GameProfileInventoryCache<T : Any> {
+    private val lock = Any()
+
+    private var revision: Long? = null
+    private var value: List<T>? = null
+
+    // Called only by the refresh worker; the UI invalidates through request revisions.
+    fun get(requestedRevision: Long, load: () -> List<T>): List<T> = synchronized(lock) {
+        value?.takeIf { revision == requestedRevision } ?: load().toList().also {
+            value = it
+            revision = requestedRevision
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/GameProfileManager.kt

@@ -0,0 +1,31 @@
+package com.droiddeck.launcher.session
+
+import android.content.Context
+import com.droiddeck.launcher.core.GameEnvironment
+
+object GameProfileManager {
+    @Synchronized
+    fun reset(context: Context, scope: String) {
+        require(scope.isNotEmpty() && GameEnvironment.validScope(scope))
+        val failures = mutableListOf<Pair<String, Throwable>>()
+        fun clear(name: String, action: () -> Unit) {
+            runCatching(action).onFailure { failures += name to it }
+        }
+
+        clear("environment") {
+            GameEnvironmentStore.save(
+                context,
+                GameEnvironmentStore.read(context).withEntries(scope, emptyMap()),
+            )
+        }
+        clear("Proton") { ProtonDefault.requestGame(context, scope, null) }
+        clear("component packages") { ComponentsManager.clearGameComponents(context, scope) }
+        clear("texture filtering") { SessionPrefs.clearGameTextureFiltering(context, scope) }
+        clear("Windows components") { WinComponents.setPicks(context, scope, emptyList()) }
+
+        if (failures.isNotEmpty()) {
+            val names = failures.joinToString { it.first }
+            throw IllegalStateException("Could not clear: $names", failures.first().second)
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/GameProfileRefreshState.kt

@@ -0,0 +1,13 @@
+package com.droiddeck.launcher.session
+
+internal data class GameProfileRefreshState<T>(
+    val data: T? = null,
+    val loaded: Boolean = false,
+    val failed: Boolean = false,
+) {
+    fun succeeded(data: T) = GameProfileRefreshState(data, loaded = true)
+
+    fun failed() = copy(failed = true)
+
+    fun retrying() = copy(failed = false)
+}

app/src/main/java/com/droiddeck/launcher/session/LatestRequestCoordinator.kt

@@ -0,0 +1,33 @@
+package com.droiddeck.launcher.session
+
+internal class LatestRequestCoordinator<T> {
+    data class Request<T>(val generation: Long, val value: T)
+
+    private val lock = Any()
+    private var generation = 0L
+    private var running = false
+    private var latest: Request<T>? = null
+    private var pending: Request<T>? = null
+
+    fun submit(value: T): Boolean = synchronized(lock) {
+        if (latest?.value != value) generation++
+        pending = Request(generation, value).also { latest = it }
+        if (running) {
+            false
+        } else {
+            running = true
+            true
+        }
+    }
+
+    fun takeLatest(): Request<T>? = synchronized(lock) {
+        pending.also {
+            pending = null
+            if (it == null) running = false
+        }
+    }
+
+    fun isLatest(request: Request<T>): Boolean = synchronized(lock) {
+        request.generation == latest?.generation
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/ProtonDefault.kt

@@ -2,6 +2,7 @@ package com.droiddeck.launcher.session
 
 import android.content.Context
 import android.util.Log
+import com.droiddeck.launcher.core.GameEnvironment
 import com.droiddeck.launcher.runtime.LinuxRuntime
 import org.json.JSONObject
 import java.io.File
@@ -9,10 +10,12 @@ import java.io.File
 object ProtonDefault {
     private const val TAG = "ProtonDefault"
     private const val DIR = "root/.local/share/droiddeck-compat"
+    private const val GAMES = "games.json"
 
     data class Tool(val name: String, val display: String, val dir: String, val valve: Boolean)
     data class Request(val seq: Long, val valve: Boolean, val dir: String)
     data class State(val default: String?, val applied: Long, val live: Boolean, val pending: String?, val tools: List<Tool>)
+    data class GameChoice(val valve: Boolean, val dir: String)
 
     enum class Outcome { LIVE, NEXT_START, NOT_RUNNABLE }
 
@@ -60,6 +63,33 @@ object ProtonDefault {
         return protons.firstOrNull { it.valve == pick.first && it.dir.name == pick.second }?.id
     }
 
+    internal fun parseGames(text: String?): Map<String, GameChoice?> {
+        val root = runCatching { JSONObject(text ?: "") }.getOrNull() ?: return emptyMap()
+        if (root.optInt("version", 0) != 1) return emptyMap()
+        val games = root.optJSONObject("games") ?: return emptyMap()
+        return buildMap {
+            games.keys().forEach { id ->
+                if (!GameEnvironment.validScope(id)) return@forEach
+                if (games.isNull(id)) {
+                    put(id, null)
+                } else {
+                    val value = games.optJSONObject(id) ?: return@forEach
+                    val gameDir = value.optString("dir")
+                    val valve = value.opt("valve")
+                    if (gameDir.isNotEmpty() && valve is Boolean) put(id, GameChoice(valve, gameDir))
+                }
+            }
+        }
+    }
+
+    fun gameChoice(context: Context, scope: String): GameChoice? =
+        parseGames(read(File(dir(context), GAMES)))[scope]
+
+    fun gameSelectedId(context: Context, scope: String, protons: List<ComponentsManager.Proton>): String? {
+        val pick = gameChoice(context, scope) ?: return null
+        return protons.firstOrNull { it.valve == pick.valve && it.dir.name == pick.dir }?.id
+    }
+
     internal fun nextSeq(now: Long, state: State, previous: Request?): Long =
         maxOf(now, state.applied + 1, (previous?.seq ?: 0) + 1)
 
@@ -83,4 +113,33 @@ object ProtonDefault {
         val tool = state.tools.firstOrNull { it.valve == proton.valve && it.dir == proton.dir.name }
         return if (SessionState.running && state.live && (tool == null || state.pending != tool.name)) Outcome.LIVE else Outcome.NEXT_START
     }
+
+    @Synchronized
+    fun requestGame(context: Context, scope: String, proton: ComponentsManager.Proton?): Outcome {
+        require(GameEnvironment.validScope(scope))
+        val d = dir(context)
+        val choices = parseGames(read(File(d, GAMES))).toMutableMap()
+        choices[scope] = proton?.let { GameChoice(it.valve, it.dir.name) }
+        val games = JSONObject()
+        choices.forEach { (id, choice) ->
+            games.put(id, choice?.let { JSONObject().put("valve", it.valve).put("dir", it.dir) } ?: JSONObject.NULL)
+        }
+        val staged = File(d, "$GAMES.staged")
+        try {
+            d.mkdirs()
+            staged.writeText(JSONObject().put("version", 1).put("games", games).toString(1) + "\n")
+            if (!staged.renameTo(File(d, GAMES))) throw java.io.IOException("rename failed")
+        } catch (e: Exception) {
+            staged.delete()
+            Log.w(TAG, "could not write the per-game Proton request", e)
+            throw e
+        }
+        val state = state(context)
+        val tool = proton?.let { selected -> state.tools.firstOrNull { it.valve == selected.valve && it.dir == selected.dir.name } }
+        return if (SessionState.running && state.live && (proton == null || tool != null && state.pending != tool.name)) {
+            Outcome.LIVE
+        } else {
+            Outcome.NEXT_START
+        }
+    }
 }

app/src/main/java/com/droiddeck/launcher/session/ProtonExtras.kt

@@ -10,12 +10,15 @@ import com.droiddeck.launcher.core.FileUtils
 import com.droiddeck.launcher.runtime.LinuxRuntime
 import java.io.File
 import org.json.JSONArray
+import org.json.JSONObject
 
 /** Immediate download and installation of the optional ARM64 Proton builds. */
 object ProtonExtras {
     private const val TAG = "ProtonExtras"
     private const val NEED_BYTES = 4L * 1024 * 1024 * 1024
     private const val RELEASES = "https://api.github.com/repos/%s/releases?per_page=15"
+    /** How long a release check stands before the next one goes to GitHub. */
+    const val CHECK_EVERY_MS = 6L * 60 * 60 * 1000
     @Volatile
     var installInProgress = false
         private set
@@ -23,23 +26,122 @@ object ProtonExtras {
     class Tool(val id: String, val name: String, val prefix: String, val repo: String, val assetPattern: Regex)
 
     /** [sha256] from GitHub's asset digest; [sha512] the URL of a checksum file published beside it. */
-    private data class Asset(val tag: String, val name: String, val url: String, val sha512: String?, val size: Long,
+    internal data class Asset(val tag: String, val name: String, val url: String, val sha512: String?, val size: Long,
                              val sha256: String? = null)
 
     val tools = listOf(
         Tool("ge", "GE-Proton", "GE-Proton", "GloriousEggroll/proton-ge-custom", Regex("aarch64\\.tar\\.(gz|xz)$")),
         Tool("cachyos", "proton-cachyos", "proton-cachyos", "CachyOS/proton-cachyos", Regex("arm64\\.tar\\.(gz|xz)$")),
+        Tool("droiddeck", "DroidDeck-Proton", "DroidDeck-Proton", "The412Banner/DroidDeck-Proton", Regex("aarch64\\.tar\\.(gz|xz)$")),
     )
 
     private fun home(context: Context) = File(LinuxRuntime.rootDir(context), "root")
     private fun requests(context: Context) = File(home(context), ".bl-proton-extra")
     private fun toolsDir(context: Context) = File(home(context), ".local/share/Steam/compatibilitytools.d")
+    /** The release tag each build was installed from, by directory name. */
+    private fun releasesFile(context: Context) = File(context.filesDir, "proton-extras.json")
+    /** The newest release seen per source, and when it was looked up. */
+    private fun latestFile(context: Context) = File(context.filesDir, "proton-latest.json")
 
-    /** The installed build's directory name (e.g. GE-Proton11-7), or null. */
-    fun installed(context: Context, tool: Tool): String? =
-        toolsDir(context).listFiles()
+    /** The installed build's directory name (e.g. GE-Proton11-7), the newest when there are several, or null. */
+    fun installed(context: Context, tool: Tool): String? = installedIn(toolsDir(context), tool).lastOrNull()
+
+    /** Every installed build's directory name, oldest first. */
+    fun installedAll(context: Context, tool: Tool): List<String> = installedIn(toolsDir(context), tool)
+
+    internal fun installedIn(dir: File, tool: Tool): List<String> =
+        dir.listFiles()
             ?.filter { it.isDirectory && it.name.startsWith(tool.prefix) && File(it, "toolmanifest.vdf").isFile }
-            ?.maxByOrNull { it.name }?.name
+            ?.map { it.name }
+            ?.sortedWith { a, b -> compareVersions(a, b) }
+            ?: emptyList()
+
+    // Architecture names carry digits (aarch64, x86_64) that are not part of a version.
+    private val ARCH = Regex("(?i)aarch64|arm64|x86_64|x86-64|amd64")
+    private val NUMBER = Regex("\\d+")
+
+    /** The numbers in a release tag or build folder, in order: GE-Proton11-10 is 11, 10. */
+    internal fun versionKey(name: String): List<Long> =
+        NUMBER.findAll(ARCH.replace(name, " ")).mapNotNull { it.value.toLongOrNull() }.toList()
+
+    /** Orders by those numbers, so 11-10 is after 11-9; the name itself only breaks a tie. */
+    internal fun compareVersions(a: String, b: String): Int {
+        val x = versionKey(a)
+        val y = versionKey(b)
+        for (i in 0 until minOf(x.size, y.size)) if (x[i] != y[i]) return x[i].compareTo(y[i])
+        return if (x.size != y.size) x.size.compareTo(y.size) else a.compareTo(b)
+    }
+
+    /** [latest] when it is newer than every installed release, else null. Nothing installed is not an update. */
+    internal fun updateFor(installed: List<String>, latest: String?): String? {
+        if (latest == null || installed.isEmpty()) return null
+        val newest = installed.maxWithOrNull { a, b -> compareVersions(a, b) } ?: return null
+        val x = versionKey(latest)
+        val y = versionKey(newest)
+        for (i in 0 until minOf(x.size, y.size)) if (x[i] != y[i]) return if (x[i] > y[i]) latest else null
+        return if (x.size > y.size) latest else null
+    }
+
+    /** The release each installed build came from: the tag recorded at install, else its folder name. */
+    fun installedTags(context: Context, tool: Tool): List<String> {
+        val recorded = readJson(releasesFile(context))
+        return installedAll(context, tool).map { recorded.optString(it).ifEmpty { it } }
+    }
+
+    /** A newer release than the installed one, from the last check (no network), or null. */
+    fun update(context: Context, tool: Tool): String? = updateFor(installedTags(context, tool), cachedLatest(context, tool))
+
+    fun cachedLatest(context: Context, tool: Tool): String? =
+        readJson(latestFile(context)).optJSONObject(tool.id)?.optString("tag")?.ifEmpty { null }
+
+    /** Its own lock, not the install's: a check must not wait behind a download. */
+    private val checkLock = Any()
+    /** A failed look-up (offline) is not repeated on every resume, only after this long. */
+    private const val RETRY_MS = 15L * 60 * 1000
+    private var lastAttempt = 0L
+
+    /**
+     * Looks up each source's newest release unless it was looked up within [CHECK_EVERY_MS] (or
+     * [force]). Offline or rate limited, the last answer stands. True when anything was asked.
+     */
+    fun checkLatest(context: Context, force: Boolean = false, now: Long = System.currentTimeMillis()): Boolean {
+        synchronized(checkLock) {
+            val file = latestFile(context)
+            val cache = readJson(file)
+            val due = tools.filter { tool ->
+                val at = cache.optJSONObject(tool.id)?.optLong("at", 0L) ?: 0L
+                force || (now - at) !in 0 until CHECK_EVERY_MS
+            }
+            if (due.isEmpty() || !force && (now - lastAttempt) in 0 until RETRY_MS) return false
+            lastAttempt = now
+            for (tool in due) {
+                val tag = findLatestAsset(tool)?.tag ?: continue
+                cache.put(tool.id, JSONObject().put("tag", tag).put("at", now))
+            }
+            runCatching { file.writeText(cache.toString()) }
+            return true
+        }
+    }
+
+    private fun record(context: Context, tool: Tool, dir: String?, tag: String) {
+        runCatching {
+            val latest = readJson(latestFile(context))
+            val known = latest.optJSONObject(tool.id)?.optString("tag")
+            if (known.isNullOrEmpty() || compareVersions(tag, known) >= 0) {
+                latest.put(tool.id, JSONObject().put("tag", tag).put("at", System.currentTimeMillis()))
+                latestFile(context).writeText(latest.toString())
+            }
+            if (dir != null) {
+                val releases = readJson(releasesFile(context))
+                val present = toolsDir(context).list()?.toSet() ?: emptySet()
+                releases.keys().asSequence().toList().filter { it !in present }.forEach { releases.remove(it) }
+                releasesFile(context).writeText(releases.put(dir, tag).toString())
+            }
+        }.onFailure { Log.w(TAG, "record ${tool.id} $tag", it) }
+    }
+
+    private fun readJson(file: File): JSONObject =
+        runCatching { JSONObject(FileUtils.readString(file) ?: "{}") }.getOrDefault(JSONObject())
 
     /** A request left by an earlier app version, still consumed by the session shim. */
     fun queued(context: Context, tool: Tool): Boolean =
@@ -52,9 +154,15 @@ object ProtonExtras {
         else file.writeText(lines.joinToString("\n") + "\n")
     }
 
-    /** Deletes the installed build; Steam discovers its absence on its next start. */
-    fun remove(context: Context, tool: Tool) {
-        installed(context, tool)?.let { File(toolsDir(context), it).deleteRecursively() }
+    /** Deletes one installed build ([dir], else the newest); Steam discovers its absence on its next start. */
+    fun remove(context: Context, tool: Tool, dir: String? = null) {
+        val name = if (dir != null) dir.takeIf { it in installedAll(context, tool) } ?: return else installed(context, tool) ?: return
+        File(toolsDir(context), name).deleteRecursively()
+    }
+
+    /** Deletes every build but the newest. */
+    fun removeOlder(context: Context, tool: Tool) {
+        installedAll(context, tool).dropLast(1).forEach { File(toolsDir(context), it).deleteRecursively() }
     }
 
     /** Downloads, verifies and registers the latest build without waiting for another session. */
@@ -145,9 +253,12 @@ object ProtonExtras {
             hostEnv["PROOT_TMP_DIR"] = context.cacheDir.path
             LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { hostEnv["LD_LIBRARY_PATH"] = it }
             val child = process.start()
+            var placed: String? = null
             child.inputStream.bufferedReader().useLines { lines ->
                 lines.forEach { line ->
                     Log.i(TAG, line)
+                    // "droiddeck-proton-extra: installed <folder>", the folder as the tarball names it.
+                    line.substringAfter("droiddeck-proton-extra: installed ", "").takeIf { it.isNotEmpty() }?.let { placed = it }
                     if (line.contains("unpacking", ignoreCase = true) || line.contains("adopted", ignoreCase = true)) {
                         onProgress(installing, -1)
                     }
@@ -158,6 +269,7 @@ object ProtonExtras {
             else {
                 archive.delete()
                 unqueue(context, tool)
+                record(context, tool, placed, asset.tag)
                 if (EsyncPacks.enabled(context)) {
                     onProgress(context.getString(R.string.esync_fetching), -1)
                     try {
@@ -177,32 +289,36 @@ object ProtonExtras {
     private fun findLatestAsset(tool: Tool): Asset? {
         val releases = Downloader.downloadString(RELEASES.format(tool.repo)) ?: return null
         return try {
-            val array = JSONArray(releases)
-            for (i in 0 until array.length()) {
-                val release = array.getJSONObject(i)
-                if (release.optBoolean("draft", false)) continue
-                val assets = release.optJSONArray("assets") ?: continue
-                val entries = (0 until assets.length()).map { assets.getJSONObject(it) }
-                val archive = entries.sortedBy { it.optString("name") }.firstOrNull { tool.assetPattern.containsMatchIn(it.optString("name")) } ?: continue
-                val name = archive.optString("name")
-                val stem = name.substringBefore(".tar")
-                val checksum = entries.firstOrNull {
-                    it.optString("name").startsWith(stem) && it.optString("name").contains("sha512", ignoreCase = true)
-                }?.optString("browser_download_url")?.takeIf { it.startsWith("http") }
-                return Asset(
-                    release.optString("tag_name"), name,
-                    archive.optString("browser_download_url").takeIf { it.startsWith("http") } ?: continue, checksum,
-                    archive.optLong("size", 0L),
-                    Hashes.githubSha256(archive.optString("digest")),
-                )
-            }
-            null
+            pickAsset(tool, JSONArray(releases))
         } catch (e: Exception) {
             Log.w(TAG, "release metadata for ${tool.id}", e)
             null
         }
     }
 
+    /** The newest full release in GitHub's list (newest first) that carries [tool]'s ARM64 archive. */
+    internal fun pickAsset(tool: Tool, array: JSONArray): Asset? {
+        for (i in 0 until array.length()) {
+            val release = array.getJSONObject(i)
+            if (release.optBoolean("draft", false) || release.optBoolean("prerelease", false)) continue
+            val assets = release.optJSONArray("assets") ?: continue
+            val entries = (0 until assets.length()).map { assets.getJSONObject(it) }
+            val archive = entries.sortedBy { it.optString("name") }.firstOrNull { tool.assetPattern.containsMatchIn(it.optString("name")) } ?: continue
+            val name = archive.optString("name")
+            val stem = name.substringBefore(".tar")
+            val checksum = entries.firstOrNull {
+                it.optString("name").startsWith(stem) && it.optString("name").contains("sha512", ignoreCase = true)
+            }?.optString("browser_download_url")?.takeIf { it.startsWith("http") }
+            return Asset(
+                release.optString("tag_name"), name,
+                archive.optString("browser_download_url").takeIf { it.startsWith("http") } ?: continue, checksum,
+                archive.optLong("size", 0L),
+                Hashes.githubSha256(archive.optString("digest")),
+            )
+        }
+        return null
+    }
+
     private fun requestLines(context: Context): List<String> =
         FileUtils.readString(requests(context))?.lines()?.filter { it.isNotBlank() } ?: emptyList()
 }

app/src/main/java/com/droiddeck/launcher/session/QuestExperimental.kt

@@ -0,0 +1,60 @@
+package com.droiddeck.launcher.session
+
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import com.droiddeck.launcher.BuildConfig
+import java.io.File
+
+/** Device-detected defaults and launch evidence for experimental Quest compatibility. */
+object QuestExperimental {
+    private const val TAG = "QuestExperimental"
+    const val DRIVER = "turnip25.1.0-quest1"
+
+    // Quest 2 has an A6xx GPU and cannot use this bundled A7xx driver.
+    internal fun supported(model: String, device: String, manufacturer: String): Boolean =
+        model.equals("Quest 3", ignoreCase = true) || model.equals("Quest 3S", ignoreCase = true) ||
+            ((manufacturer.equals("Oculus", ignoreCase = true) || manufacturer.equals("Meta", ignoreCase = true)) &&
+                (device == "eureka" || device == "panther"))
+
+    fun isSupported(): Boolean = supported(Build.MODEL, Build.DEVICE, Build.MANUFACTURER)
+
+    fun initialize(context: Context) {
+        if (!isSupported()) return
+        val prefs = context.getSharedPreferences("session", Context.MODE_PRIVATE)
+        if (!prefs.getBoolean("questDefaultsV1", false)) {
+            // Auto would download an unwrapped display driver and lose the compatibility path.
+            // Apply once so deliberate changes made during headset testing remain possible.
+            prefs.edit()
+                .putString("gpuDriverMode", SessionPrefs.GPU_DRIVERS_MANUAL)
+                .putString("androidDriver", DRIVER)
+                .putString("linuxDriver", "")
+                // The existing HDR option uses SurfaceControl presentation. This is a
+                // corruption workaround from upstream issue #245, not a claim of HDR accuracy.
+                .putBoolean("hdr.steam", true)
+                .putBoolean("questDefaultsV1", true)
+                .apply()
+        }
+        val report = buildString {
+            appendLine("DroidDeck Quest Experimental ${BuildConfig.VERSION_NAME}")
+            appendLine("package=${context.packageName}")
+            appendLine("manufacturer=${Build.MANUFACTURER} model=${Build.MODEL}")
+            appendLine("device=${Build.DEVICE} board=${Build.BOARD} hardware=${Build.HARDWARE}")
+            appendLine("android=${Build.VERSION.RELEASE} sdk=${Build.VERSION.SDK_INT}")
+            appendLine("abis=${Build.SUPPORTED_ABIS.joinToString()}")
+            for (name in listOf("gpu_model", "gpu_chipid")) {
+                val value = runCatching { File("/sys/class/kgsl/kgsl-3d0/$name").readText().trim() }
+                    .getOrDefault("unavailable")
+                appendLine("$name=$value")
+            }
+            appendLine("driverMode=${SessionPrefs.gpuDriverMode(context)}")
+            appendLine("androidDriver=${SessionPrefs.androidDriver(context)}")
+            appendLine("steamSurfaceControlWorkaround=${SessionPrefs.hdr(context, "steam")}")
+            appendLine("GPUOBJ fallback installed in Android driver and ARM64 libblsession")
+            appendLine("Experimental Quest 3/3S compatibility; 2D panel application")
+        }
+        Log.i(TAG, report)
+        runCatching { File(context.filesDir, "quest-startup.txt").writeText(report) }
+            .onFailure { Log.w(TAG, "Could not write startup report", it) }
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/SelectedGameProfile.kt

@@ -0,0 +1,76 @@
+package com.droiddeck.launcher.session
+
+import com.droiddeck.launcher.core.FexPreset
+import com.droiddeck.launcher.core.GameEnvironment
+import com.droiddeck.launcher.frontend.Library
+
+data class ProfileValue(val value: String, val inherited: Boolean)
+
+data class SelectedGameProfile(
+    val appId: Long,
+    val name: String,
+    val fexPreset: ProfileValue,
+    val proton: ProfileValue,
+    val protonId: String?,
+    val components: Map<String, ProfileValue>,
+    val componentFiles: Map<String, String>,
+    val environmentOverrides: Int,
+    val windowsComponentNames: List<String>,
+    /** Start without Steam (GameEnvironment.NO_STEAM) is on for this game. */
+    val startWithoutSteam: Boolean = false,
+) {
+    val hasOverrides: Boolean
+        get() = !fexPreset.inherited ||
+            !proton.inherited ||
+            components.values.any { !it.inherited } ||
+            environmentOverrides > 0 ||
+            windowsComponentNames.isNotEmpty() ||
+            startWithoutSteam
+
+    companion object {
+        fun resolve(
+            selectedAppId: Long,
+            games: List<Library.SteamGame>,
+            generalFexPreset: String,
+            environment: GameEnvironment.Config,
+            snapshot: ComponentsManager.Snapshot,
+            generalProtonId: String?,
+            gameProtonChoice: ProtonDefault.GameChoice?,
+            gameProtonId: String?,
+            gameComponents: Map<String, String>,
+            gameWindowsComponents: List<String>,
+        ): SelectedGameProfile? {
+            val game = games.firstOrNull { it.profileKey == selectedAppId.toString() } ?: return null
+            val fexOverride = GameEnvironment.gameFexPreset(environment, game.profileKey)
+            val selectedProtonId = if (gameProtonChoice == null) generalProtonId else gameProtonId
+            val selectedProton = snapshot.protons.firstOrNull { it.proton.id == selectedProtonId }
+            val packages = snapshot.packages.associateBy { it.file }
+            val components = ComponentsManager.COMPONENTS.associateWith { component ->
+                val override = gameComponents[component]
+                ProfileValue(
+                    value = override?.let { packages[it]?.version ?: it }
+                        ?: selectedProton?.components?.get(component)?.selected.orEmpty(),
+                    inherited = override == null,
+                )
+            }
+            // Start without Steam is a switch of its own on the Games page, listed by name.
+            val otherEnvironment = environment.games[game.profileKey].orEmpty().keys - FexPreset.environmentKeys -
+                GameEnvironment.NO_STEAM
+            return SelectedGameProfile(
+                appId = selectedAppId,
+                name = game.name,
+                fexPreset = ProfileValue(fexOverride ?: generalFexPreset, fexOverride == null),
+                proton = ProfileValue(
+                    selectedProton?.proton?.name ?: gameProtonChoice?.dir.orEmpty(),
+                    gameProtonChoice == null,
+                ),
+                protonId = selectedProtonId,
+                components = components,
+                componentFiles = gameComponents,
+                environmentOverrides = otherEnvironment.size,
+                windowsComponentNames = gameWindowsComponents.map(WinComponentNames::of),
+                startWithoutSteam = GameEnvironment.gameNoSteam(environment, game.profileKey),
+            )
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/SessionAchievementGame.kt

@@ -0,0 +1,11 @@
+package com.droiddeck.launcher.session
+
+/** An active game needs a live window; a launch URL or stale Steam base layer is insufficient. */
+internal object SessionAchievementGame {
+    fun activeAppId(focused: Long?, windows: List<Long>, installed: Set<Long>): Long? {
+        if (focused != null && focused > 0 && focused != 769L) {
+            return focused.takeIf { it in windows && it in installed }
+        }
+        return windows.filter { it != 769L && it in installed }.distinct().singleOrNull()
+    }
+}

app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt

@@ -72,6 +72,7 @@ object SessionFiles {
             "usr/local/bin/droiddeck-steam-desktop-ui" to "usr/local/bin/droiddeck-steam-desktop-ui",
             "usr/local/bin/droiddeck-steam-library" to "usr/local/bin/droiddeck-steam-library",
             "usr/local/bin/droiddeck-seed-redists" to "usr/local/bin/droiddeck-seed-redists",
+            "usr/local/bin/droiddeck-launcher-cores" to "usr/local/bin/droiddeck-launcher-cores",
             "usr/local/bin/droiddeck-proton-extra" to "usr/local/bin/droiddeck-proton-extra",
             "usr/local/bin/droiddeck-netmanager" to "usr/local/bin/droiddeck-netmanager",
             "usr/local/bin/droiddeck-login1" to "usr/local/bin/droiddeck-login1",
@@ -139,7 +140,7 @@ object SessionFiles {
             "usr/local/bin/gamescope" to "usr/local/bin/gamescope",
             "usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime",
             "usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE",
-        ) + mangoapp + msitools.map { it to it } + fexPreloads).filter { (asset, _) ->
+        ) + mangoapp + listOf("comet", "GalaxyCommunication.exe", "update-permissions.exe", "LICENSE", "version").map { "usr/local/lib/droiddeck-comet/$it" to "usr/local/lib/droiddeck-comet/$it" } + msitools.map { it to it } + fexPreloads).filter { (asset, _) ->
             val dir = asset.substringBeforeLast('/')
             runCatching { context.assets.list("linuxfs/$dir")?.contains(asset.substringAfterLast('/')) == true }.getOrDefault(false)
         }

app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt

@@ -4,12 +4,16 @@ import android.content.Context
 import android.content.pm.ActivityInfo
 import androidx.annotation.StringRes
 import com.droiddeck.launcher.R
+import com.droiddeck.launcher.core.CpuAllocationDefaults
+import com.droiddeck.launcher.core.GameEnvironment
 import com.droiddeck.launcher.core.TextureFiltering
 import com.droiddeck.launcher.gpu.ScreenEffects
 import org.json.JSONObject
 
 /** The in-session switches: the HUD and how the on-screen controls decide to appear. */
 object SessionPrefs {
+    data class GameTextureFiltering(val anisotropy: Int? = null, val lodBias: String? = null)
+
     const val SUSPEND_AUTO = "auto"
     const val SUSPEND_NATIVE = "native"
     const val SUSPEND_MANUAL = "manual"
@@ -68,15 +72,7 @@ object SessionPrefs {
         prefs(context).edit().putBoolean("animations", on).apply()
     }
 
-    /** The Flathub Store (beta): its rail item. Off by default. */
-    fun storeEnabled(context: Context): Boolean = prefs(context).getBoolean("storeEnabled", false)
-
-    fun setStoreEnabled(context: Context, on: Boolean) {
-        prefs(context).edit().putBoolean("storeEnabled", on).apply()
-    }
-
-    /** The Stores section (GOG, Epic Games, Amazon Games): its rail item. Off by default. */
-    fun gameStoresEnabled(context: Context): Boolean = prefs(context).getBoolean("gameStoresEnabled", false)
+    fun gameStoresEnabled(context: Context): Boolean = prefs(context).getBoolean("gameStoresEnabled", true)
 
     fun setGameStoresEnabled(context: Context, on: Boolean) {
         prefs(context).edit().putBoolean("gameStoresEnabled", on).apply()
@@ -276,26 +272,34 @@ object SessionPrefs {
         prefs(context).edit().putBoolean("wifiDiscoveryAsked", true).apply()
     }
 
-    /**
-     * Whether the client's own core pick is overridden. When on, BL_CLIENT_CPUS is sent even when
-     * it names every core - unlike a game mask, the point here is to undo a pin Steam applies to
-     * itself, and the scheduler's default is exactly what Steam's choice takes away.
-     */
-    fun clientCpusOverride(context: Context): Boolean = prefs(context).getBoolean("clientCpusOverride", false)
+    internal data class CoreAllocation(val clientOverride: Boolean, val clientCpus: String, val gameCpus: String)
+
+    /** Defaults are read only for absent keys; even a saved empty/all-core choice wins. */
+    internal fun coreAllocation(context: Context, defaults: CpuAllocationDefaults.Allocation? = CpuAllocationDefaults.device): CoreAllocation {
+        val saved = prefs(context)
+        return CoreAllocation(
+            saved.getBoolean("clientCpusOverride", defaults != null && !saved.contains("clientCpus")),
+            saved.getString("clientCpus", defaults?.client.orEmpty()).orEmpty(),
+            saved.getString("gameCpus", defaults?.game.orEmpty()).orEmpty(),
+        )
+    }
+
+    /** Use the device default until the user saves an override or a client mask. */
+    fun clientCpusOverride(context: Context): Boolean = coreAllocation(context).clientOverride
 
     fun setClientCpusOverride(context: Context, on: Boolean) {
         prefs(context).edit().putBoolean("clientCpusOverride", on).apply()
     }
 
     /** Comma-separated core list for the client (taskset -c syntax); "" = every core. */
-    fun clientCpus(context: Context): String = prefs(context).getString("clientCpus", "") ?: ""
+    fun clientCpus(context: Context): String = coreAllocation(context).clientCpus
 
     fun setClientCpus(context: Context, list: String) {
         prefs(context).edit().putString("clientCpus", list).apply()
     }
 
-    /** Comma-separated core list for games (taskset -c syntax); "" = every core = nothing sent. */
-    fun gameCpus(context: Context): String = prefs(context).getString("gameCpus", "") ?: ""
+    /** Comma-separated core list for games (taskset -c syntax); "" = every core (explicitly restored when the client is pinned). */
+    fun gameCpus(context: Context): String = coreAllocation(context).gameCpus
 
     fun setGameCpus(context: Context, list: String) {
         prefs(context).edit().putString("gameCpus", list).apply()
@@ -882,6 +886,74 @@ object SessionPrefs {
         publishGameEnvironment(context)
     }
 
+    fun gameTextureFiltering(context: Context, scope: String): GameTextureFiltering {
+        require(GameEnvironment.validScope(scope))
+        return gameTextureFiltering(context)[scope] ?: GameTextureFiltering()
+    }
+
+    fun gameTextureFiltering(context: Context): Map<String, GameTextureFiltering> {
+        val json = runCatching {
+            JSONObject(prefs(context).getString("gameTextureFiltering", null) ?: "{}")
+        }.getOrElse { JSONObject() }
+        return buildMap {
+            json.keys().forEach { scope ->
+                if (!GameEnvironment.validScope(scope)) return@forEach
+                val entry = json.optJSONObject(scope) ?: return@forEach
+                val anisotropy = entry.optInt("anisotropy").takeIf {
+                    entry.has("anisotropy") && it in TextureFiltering.ANISOTROPY
+                }
+                val lodBias = entry.optString("lodBias").takeIf {
+                    entry.has("lodBias") && it in TextureFiltering.LOD_BIAS
+                }
+                if (anisotropy != null || lodBias != null) {
+                    put(scope, GameTextureFiltering(anisotropy, lodBias))
+                }
+            }
+        }
+    }
+
+    fun setGameTextureAnisotropy(context: Context, scope: String, value: Int?) {
+        require(value == null || value in TextureFiltering.ANISOTROPY)
+        updateGameTextureFiltering(context, scope) { it.copy(anisotropy = value) }
+    }
+
+    fun setGameTextureLodBias(context: Context, scope: String, choice: String?) {
+        require(choice == null || choice in TextureFiltering.LOD_BIAS)
+        updateGameTextureFiltering(context, scope) { it.copy(lodBias = choice) }
+    }
+
+    fun clearGameTextureFiltering(context: Context, scope: String) {
+        require(GameEnvironment.validScope(scope))
+        val choices = gameTextureFiltering(context).toMutableMap()
+        if (choices.remove(scope) == null) return
+        saveGameTextureFiltering(context, choices)
+        publishGameEnvironment(context)
+    }
+
+    private fun updateGameTextureFiltering(
+        context: Context,
+        scope: String,
+        change: (GameTextureFiltering) -> GameTextureFiltering,
+    ) {
+        require(GameEnvironment.validScope(scope))
+        val choices = gameTextureFiltering(context).toMutableMap()
+        val next = change(choices[scope] ?: GameTextureFiltering())
+        if (next.anisotropy == null && next.lodBias == null) choices.remove(scope) else choices[scope] = next
+        saveGameTextureFiltering(context, choices)
+        publishGameEnvironment(context)
+    }
+
+    private fun saveGameTextureFiltering(context: Context, choices: Map<String, GameTextureFiltering>) {
+        val json = JSONObject()
+        choices.forEach { (id, choice) ->
+            json.put(id, JSONObject().apply {
+                choice.anisotropy?.let { put("anisotropy", it) }
+                choice.lodBias?.let { put("lodBias", it) }
+            })
+        }
+        prefs(context).edit().putString("gameTextureFiltering", json.toString()).apply()
+    }
+
     /** Hands the change to the next game launch (GameEnvironmentStore); the running game keeps its own. */
     private fun publishGameEnvironment(context: Context) {
         runCatching { GameEnvironmentStore.publish(context) }

app/src/main/java/com/droiddeck/launcher/session/SessionService.kt

@@ -334,6 +334,7 @@ class SessionService : Service() {
         SessionFiles.stage(this, root)
         com.droiddeck.launcher.agent.AgentGuest.reset(this)
         // The compat tool asks for an Epic game's sign-in code at every launch, the client's Play button included.
+        com.droiddeck.launcher.stores.gog.GogComet.begin()
         com.droiddeck.launcher.stores.StoreLaunchRequests.start(this)
 
         val sessionDir = openSessionFolder()
@@ -381,7 +382,12 @@ class SessionService : Service() {
         val controllersOn = !File(Environment.getExternalStorageDirectory(), NO_PAD_SWITCH).exists()
         SessionState.deckPad = false
         deckBinds = emptyList()
-        if (controllersOn) addControllerEnvironment(guest, fakeInputDir, sessionDir)
+        if (controllersOn) {
+            addControllerEnvironment(guest, fakeInputDir, sessionDir)
+            // Steam enumerates /dev/input while it starts. Make every attached controller's
+            // discovery node exist after the rings and guest environment are ready.
+            SessionState.padBridge?.syncConnectedControllers()
+        }
         // The user's own games, for the runtime's shortcuts writer to put in the client's library
         // before the client starts (see frontend/AddedGames and droiddeck-steam-shortcuts).
         if (steamHere) {
@@ -579,6 +585,8 @@ class SessionService : Service() {
     private fun addClientEnvironment(guest: MutableList<String>, steamHere: Boolean) {
         guest.add("/usr/bin/env")
         guest.add("-i")
+        // PRoot executes guest[0] directly; assignments belong after env -i.
+        guest.add("DROIDDECK_BWRAP_SOCKET=" + com.droiddeck.launcher.runtime.BwrapSpawner.socket(this))
         guest.add("HOME=/root")
         guest.add("USER=root")
         guest.add("PATH=/usr/local/bin:/usr/bin:/bin")
@@ -661,16 +669,15 @@ class SessionService : Service() {
         extraEnv().forEach { guest.add(it) }
         // The agent bridge's experiment lines (AgentEnv), after the user's so an agent's win.
         com.droiddeck.launcher.agent.AgentEnv.beginSession(this).forEach { guest.add(it) }
-        // Core masks, Bannerlator's two (cfca3912). The client's is sent whenever the override is
-        // on, even naming every core: it exists to undo the pin Steam applies to its own interface
-        // renderer, and the scheduler's default is exactly what that pin takes away. A game's is
-        // sent only when it is a real restriction - a game has no pin of its own to undo.
-        if (steamHere && SessionPrefs.clientCpusOverride(this)) {
+        // A game launched by pinned Steam inherits its mask. Explicitly restore all game cores
+        // when requested, as well as applying restricted game choices in the Proton wrapper.
+        val clientPinned = steamHere && SessionPrefs.clientCpusOverride(this)
+        if (clientPinned) {
             guest.add("BL_CLIENT_CPUS=" + CpuCores.listOrAll(SessionPrefs.clientCpus(this)))
         }
         // The game cores also pin the desktop and a program from the rail; without a choice the
         // session script picks every core but the slowest cluster for those (program_cores).
-        CpuCores.restrictionOrEmpty(SessionPrefs.gameCpus(this))
+        CpuCores.gameLaunchList(SessionPrefs.gameCpus(this), clientPinned)
             .takeIf { it.isNotEmpty() }?.let { guest.add("BL_GAME_CPUS=$it") }
     }
 
@@ -1536,6 +1543,7 @@ class SessionService : Service() {
         }
         updateDownloadMonitoring()
         val stoppedGen = sessionGen
+        val stoppedSession = SessionState.sessionId
         SessionState.stopRequested = false
         SessionEvents.record("guest.exited", mapOf("status" to status))
         GpuClockPin.stop(this)
@@ -1582,13 +1590,14 @@ class SessionService : Service() {
             if (prootPid > 1 || auxiliary.isNotEmpty()) {
                 Thread({
                     if (prootPid > 1 && steamClientMayRun) askSteamToExit(prootPid)
+                    com.droiddeck.launcher.stores.gog.GogComet.end(stoppedSession)
                     auxiliary.forEach { (pid, started) -> teardown(pid, started) }
                     if (prootPid > 1) teardown(prootPid)
                     killGuestLeftovers()
                     finishSessionStop(status, stoppedGen)
                 }, "session-teardown").start()
             } else {
-                finishSessionStop(status, stoppedGen)
+                Thread({ com.droiddeck.launcher.stores.gog.GogComet.end(stoppedSession); finishSessionStop(status, stoppedGen) }, "gog-session-stop").start()
             }
         }
         if (prootPid > 1) acquireLocks()

app/src/main/java/com/droiddeck/launcher/store/StoreState.kt

@@ -48,6 +48,9 @@ object StoreState {
         private set
     var searching by mutableStateOf(false)
         private set
+
+    /** An app whose Flathub page was asked for from outside the store (its card on Desktop), once. */
+    var openRequest by mutableStateOf<String?>(null)
     private var searchSeq = 0
 
     val SECTIONS = listOf("popular" to R.string.store_section_popular, "trending" to R.string.store_section_trending, "recently-added" to R.string.store_section_new, "recently-updated" to R.string.store_section_updated)

app/src/main/java/com/droiddeck/launcher/stores/AchievementNotifications.kt

@@ -0,0 +1,50 @@
+package com.droiddeck.launcher.stores
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import org.json.JSONObject
+
+/** Session-owned unlocks; history reads and upload acknowledgements never create notifications. */
+object AchievementNotifications {
+    data class Unlock(val client: String, val id: String, val name: String, val description: String, val icon: String?, val game: String)
+
+    private var session: String? = null
+    private val seen = HashSet<String>()
+    var pending by mutableStateOf<List<Unlock>>(emptyList())
+        private set
+
+    fun begin(owner: String?) = StoresState.post {
+        session = owner
+        seen.clear()
+        pending = emptyList()
+    }
+
+    fun end(owner: String?) = StoresState.post {
+        if (session == owner) {
+            session = null
+            seen.clear()
+            pending = emptyList()
+        }
+    }
+
+    fun unlock(owner: String, unlock: Unlock) = StoresState.post {
+        if (session == owner && seen.add("${unlock.client}:${unlock.id}")) {
+            pending = (pending + unlock).take(16)
+        }
+    }
+
+    fun dismiss(unlock: Unlock) {
+        if (pending.firstOrNull() === unlock) pending = pending.drop(1)
+    }
+
+    /** Only presentation fields from the owned daemon, bounded before entering Compose. */
+    fun parse(event: JSONObject, game: String): Unlock? {
+        val client = event.optString("client_id")
+        val id = event.optString("id")
+        val name = event.optString("name").trim()
+        if (!client.matches(Regex("[0-9]{1,32}")) || id.isBlank() || id.length > 256 || name.isEmpty()) return null
+        val icon = event.optString("icon").takeIf { it.length <= 2048 && it.startsWith("https://") }
+        return Unlock(client, id, name.take(256), event.optString("description").take(1024), icon, game.take(256))
+    }
+}

app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt

@@ -137,7 +137,7 @@ object CloudSaves {
             val galaxy = GogAuth.validToken(context)
             val clientId = gogClientId(context, id, folder)
             if (userId.isEmpty() || galaxy == null || clientId == null) null
-            else GogCloud(userId, clientId, gogScopedToken(context, id, clientId, account?.optString("refresh_token").orEmpty()) ?: galaxy)
+            else GogCloud(userId, clientId, gogScopedToken(context, id, clientId) ?: galaxy)
         }
         Store.EPIC -> {
             val token = EpicCredentialStore.getValidAccessToken(context)
@@ -148,17 +148,9 @@ object CloudSaves {
     }
 
     /** GOG cloud storage wants a token issued to the game's own client: the Galaxy refresh token, exchanged with the game's id and secret. */
-    private fun gogScopedToken(context: Context, id: String, clientId: String, refresh: String): String? {
+    private fun gogScopedToken(context: Context, id: String, clientId: String): String? {
         val secret = GogPrefs.get(context).getString("client_secret_$id", null)?.ifEmpty { null } ?: return null
-        if (refresh.isEmpty()) return null
-        return try {
-            val enc = { s: String -> java.net.URLEncoder.encode(s, "UTF-8") }
-            val c = URL("https://auth.gog.com/token?client_id=${enc(clientId)}&client_secret=${enc(secret)}&grant_type=refresh_token&refresh_token=${enc(refresh)}").openConnection() as HttpURLConnection
-            c.connectTimeout = 15_000; c.readTimeout = 15_000
-            c.setRequestProperty("User-Agent", "GOG Galaxy")
-            if (c.responseCode != 200) { c.disconnect(); return null }
-            JSONObject(c.inputStream.bufferedReader().readText()).optString("access_token").ifEmpty { null }.also { c.disconnect() }
-        } catch (e: Exception) { null }
+        return GogAuth.gameToken(context, clientId, secret)?.accessToken
     }
 
     // ---- sync -----------------------------------------------------------------------------------

app/src/main/java/com/droiddeck/launcher/stores/StoreAchievements.kt

@@ -0,0 +1,108 @@
+package com.droiddeck.launcher.stores
+
+import android.content.Context
+import android.util.Log
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.setValue
+import com.droiddeck.launcher.stores.epic.EpicAchievements
+import com.droiddeck.launcher.stores.gog.GogAchievements
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.time.Instant
+import java.time.OffsetDateTime
+import java.util.Locale
+
+/**
+ * A source's achievements with the account's progress, the last good answer cached on disk. Blocking.
+ * [source] is the library's id for where a game came from ("gog", "epic"; "steam" once it has one).
+ */
+abstract class StoreAchievements(val source: String, val label: String) {
+
+    /** [extra]: what the source needs to find the game (Epic: "namespace"). */
+    data class Game(val source: String, val id: String, val extra: Map<String, String> = emptyMap()) {
+        companion object {
+            fun of(item: CatalogItem) = Game(item.store.id, item.id, item.extra)
+            fun of(sidecar: StoreGameSidecar) = Game(sidecar.store.id, sidecar.id, sidecar.extra)
+        }
+    }
+
+    class Achievement(
+        val id: String,
+        val name: String,
+        val description: String,
+        val hidden: Boolean,
+        val unlocked: Boolean,
+        /** Unix seconds; 0 when locked or unknown. */
+        val unlockedAt: Long,
+        val icon: String?,
+        val iconLocked: String?,
+    )
+
+    sealed class Result {
+        class Found(val list: List<Achievement>) : Result()
+        class Failed(val reason: Reason) : Result()
+    }
+
+    enum class Reason { SIGNED_OUT, UNREACHABLE, NO_SERVICE }
+
+    protected abstract fun request(context: Context, game: Game): Result
+
+    fun fetch(context: Context, game: Game): Result {
+        val result = runCatching { request(context, game) }.getOrElse { e ->
+            Log.w(TAG, "$source:${game.id}: ${e.javaClass.simpleName}")
+            Result.Failed(Reason.UNREACHABLE)
+        }
+        if (result is Result.Found) runCatching {
+            cacheFile(context, game).apply { parentFile?.mkdirs() }.writeText(toJson(result.list).toString())
+        }
+        return result
+    }
+
+    fun cached(context: Context, game: Game): List<Achievement>? = runCatching {
+        val file = cacheFile(context, game)
+        if (!file.exists()) null else fromJson(JSONArray(file.readText()))
+    }.getOrNull()
+
+    private fun cacheFile(context: Context, game: Game) =
+        File(context.filesDir, "achievements/$source/${game.id.replace(Regex("[^A-Za-z0-9._-]"), "_")}.json")
+
+    protected fun locale(): String = Locale.getDefault().toLanguageTag()
+
+    /** ISO-8601 (including GOG's "+0000" offsets) to Unix seconds; 0 if unreadable. */
+    protected fun epochSeconds(iso: String?): Long {
+        if (iso.isNullOrBlank()) return 0
+        val normalized = iso.replace(Regex("([+-]\\d{2})(\\d{2})$"), "$1:$2")
+        return runCatching { OffsetDateTime.parse(normalized).toEpochSecond() }
+            .recoverCatching { Instant.parse(normalized).epochSecond }
+            .getOrDefault(0)
+    }
+
+    private fun toJson(list: List<Achievement>) = JSONArray().apply {
+        for (a in list) put(
+            JSONObject().put("id", a.id).put("name", a.name).put("description", a.description).put("hidden", a.hidden)
+                .put("unlocked", a.unlocked).put("unlockedAt", a.unlockedAt).put("icon", a.icon ?: "").put("iconLocked", a.iconLocked ?: ""),
+        )
+    }
+
+    private fun fromJson(arr: JSONArray) = List(arr.length()) { i ->
+        val o = arr.getJSONObject(i)
+        Achievement(
+            id = o.getString("id"), name = o.optString("name"), description = o.optString("description"),
+            hidden = o.optBoolean("hidden"), unlocked = o.optBoolean("unlocked"), unlockedAt = o.optLong("unlockedAt"),
+            icon = o.optString("icon").ifEmpty { null }, iconLocked = o.optString("iconLocked").ifEmpty { null },
+        )
+    }
+
+    companion object {
+        private const val TAG = "StoreAchievements"
+        var revision by androidx.compose.runtime.mutableIntStateOf(0)
+            private set
+        fun invalidate() { revision++ }
+
+        private val all: List<StoreAchievements> by lazy { listOf(GogAchievements, EpicAchievements) }
+
+        /** Null for a source without achievements. */
+        fun forSource(source: String?): StoreAchievements? = all.firstOrNull { it.source == source }
+    }
+}

app/src/main/java/com/droiddeck/launcher/stores/StoreGameSidecar.kt

@@ -1,5 +1,6 @@
 package com.droiddeck.launcher.stores
 
+import android.content.Context
 import org.json.JSONArray
 import org.json.JSONObject
 import java.io.File
@@ -42,6 +43,7 @@ class StoreGameSidecar(
     val epic: EpicOptions = EpicOptions(),
     /** GOG / Epic cloud saves for this game: down before a launch, up after it (the game card's switch). */
     val cloud: Boolean = true,
+    val achievements: Boolean = true,
 ) {
     val isInstalled: Boolean get() = state == STATE_INSTALLED
 
@@ -52,8 +54,8 @@ class StoreGameSidecar(
         exe: String = this.exe, launcher: String? = this.launcher, args: List<String> = this.args,
         env: Map<String, String> = this.env, installVersion: String = this.installVersion,
         installedAt: Long = this.installedAt, cover: String? = this.cover, hero: String? = this.hero,
-        extra: Map<String, String> = this.extra, state: String = this.state, epic: EpicOptions = this.epic, cloud: Boolean = this.cloud,
-    ) = StoreGameSidecar(store, id, title, exe, launcher, args, env, installVersion, installedAt, cover, hero, extra, state, epic, cloud)
+        extra: Map<String, String> = this.extra, state: String = this.state, epic: EpicOptions = this.epic, cloud: Boolean = this.cloud, achievements: Boolean = this.achievements,
+    ) = StoreGameSidecar(store, id, title, exe, launcher, args, env, installVersion, installedAt, cover, hero, extra, state, epic, cloud, achievements)
 
     fun toJson(): JSONObject = JSONObject().apply {
         put("version", VERSION)
@@ -64,6 +66,7 @@ class StoreGameSidecar(
         if (state != STATE_INSTALLED) put("state", state)
         if (store == Store.EPIC) put("epic", JSONObject().put("eos", epic.eos).put("offline", epic.offline))
         if (store != Store.AMAZON) put("cloud", cloud)
+        if (store == Store.GOG) put("achievements", achievements)
         if (!launcher.isNullOrEmpty()) put("launcher", launcher)
         if (args.isNotEmpty()) put("args", JSONArray(args))
         if (env.isNotEmpty()) put("env", JSONObject(env as Map<*, *>))
@@ -90,6 +93,12 @@ class StoreGameSidecar(
 
         fun file(folder: File): File = File(folder, FILE_NAME)
 
+        /** An installed game's sidecar; walks the install folders. */
+        fun find(context: Context, store: Store, id: String): StoreGameSidecar? =
+            StoreInstallRoot.gameFolders(context.applicationContext).asSequence()
+                .mapNotNull { read(it) }
+                .firstOrNull { it.store == store && it.id == id }
+
         /**
          * Changes an Epic game's launch choices on disk: reads the sidecar fresh (never a copy held
          * by a screen), applies [change], writes it, and reads it back. The written sidecar, or null
@@ -109,6 +118,12 @@ class StoreGameSidecar(
             return read(folder)?.takeIf { it.cloud == on }
         }
 
+        fun updateAchievements(folder: File, on: Boolean): StoreGameSidecar? {
+            val current = read(folder) ?: return null
+            current.copy(achievements = on).write(folder)
+            return read(folder)?.takeIf { it.achievements == on }
+        }
+
         /** The sidecar in [folder], or null when there is none or it cannot be read. */
         fun read(folder: File): StoreGameSidecar? {
             val f = file(folder)
@@ -146,6 +161,7 @@ class StoreGameSidecar(
                 // An "overlay" (or "v") field from an earlier build is read past: there is no overlay.
                 epic = o.optJSONObject("epic")?.let { e -> EpicOptions(eos = e.optBoolean("eos", true), offline = e.optBoolean("offline", false)) } ?: EpicOptions(),
                 cloud = o.optBoolean("cloud", true),
+                achievements = o.optBoolean("achievements", true),
             )
         }
 

app/src/main/java/com/droiddeck/launcher/stores/StoreInstalls.kt

@@ -1,5 +1,6 @@
 package com.droiddeck.launcher.stores
 
+import com.droiddeck.launcher.session.SessionPrefs
 import android.content.Context
 import android.util.Log
 import com.droiddeck.launcher.frontend.AddedGames
@@ -44,7 +45,7 @@ object StoreInstalls {
         onStep?.invoke(0, STEPS)
         // The user's launch choices survive an update or a repair.
         val before = StoreGameSidecar.read(folder)
-        val finished = StoreLaunch.writeLauncher(folder, sidecar.copy(state = StoreGameSidecar.STATE_INSTALLED, epic = before?.epic ?: sidecar.epic, cloud = before?.cloud ?: sidecar.cloud))
+        val finished = StoreLaunch.writeLauncher(folder, sidecar.copy(state = StoreGameSidecar.STATE_INSTALLED, epic = before?.epic ?: sidecar.epic, cloud = before?.cloud ?: sidecar.cloud, achievements = before?.achievements ?: sidecar.achievements))
         finished.write(folder)
         if (StoreGameSidecar.read(folder)?.isInstalled != true) throw java.io.IOException("the install record could not be written in ${folder.name}")
         onStep?.invoke(1, STEPS)
@@ -76,14 +77,26 @@ object StoreInstalls {
 
     /**
      * Removes a store game: its folder with the sidecar, then the shortcut (the listing without
-     * it makes the writer drop the entry; the live client is asked too). Blocking.
+     * it makes the writer drop the entry; the live client is asked too). Blocking. [removed] runs
+     * once the files are gone, before the shortcut list is rebuilt (which reads every added game).
      */
-    fun uninstall(context: Context, game: InstalledStoreGame) {
+    fun uninstall(context: Context, game: InstalledStoreGame, progress: (Float) -> Unit = {}, removed: () -> Unit = {}) {
         val app = context.applicationContext
-        val appId = AddedGames.scan(app).firstOrNull { it.folder.absolutePath == game.folder.absolutePath }?.appId
+        // The shortcut's id as stored for the folder: scanning every added game for it first held
+        // the bar at 0% for seconds before a file went.
+        val appId = SessionPrefs.addedGameStoredAppId(app, game.folder.path)
+        // File by file, deepest first, saying how far it has got: a big game takes a while to go.
+        val files = game.folder.walkBottomUp().toList()
+        val step = (files.size / 100).coerceAtLeast(1)
+        files.forEachIndexed { i, f ->
+            f.delete()
+            if (i % step == 0) progress((i + 1).toFloat() / files.size)
+        }
         deleteTree(game.folder)
+        progress(1f)
         // The scratch cache an install on a card may have left in the app's cache.
         deleteTree(StoreInstallRoot.scratchDir(app, game.sidecar.store, game.sidecar.id))
+        removed()
         register(app)
         if (appId != null) SteamLiveShortcuts.remove(app, appId)
         StoresState.logLine("uninstalled \"${game.sidecar.title}\"")

app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt

@@ -19,6 +19,9 @@ object StoreLaunchRequests {
     private val lock = Any()
     private var observer: FileObserver? = null
 
+    /** The store game this session last started; covers Steam's own Play button. */
+    @Volatile var lastLaunched: Pair<Store, String>? = null
+
     fun dir(context: Context) = File(LinuxRuntime.sessionRoot(context), "stores")
 
     /** Before each session: nothing of the last one's requests; then watch for new ones. */
@@ -28,6 +31,7 @@ object StoreLaunchRequests {
             observer?.stopWatching()
             val root = dir(app)
             root.deleteRecursively()
+            lastLaunched = null
             val req = File(root, "req").apply { mkdirs() }
             File(root, "resp").mkdirs()
             @Suppress("DEPRECATION")
@@ -55,10 +59,13 @@ object StoreLaunchRequests {
             return  // withdrawn already, or not complete yet (the rename brings it again)
         }
         val reply = when (request.optString("op")) {
+            "gog-achievements" -> runCatching { com.droiddeck.launcher.stores.gog.GogComet.prepare(app, request.optString("id")) }
+                .getOrElse { JSONObject().put("ok", false).put("ready", false).put("reason", "service-unavailable") }
             "epic-code" -> {
                 val id = request.optString("id")
                 if (id.isEmpty()) JSONObject().put("ok", false).put("reason", "no-id")
                 else {
+                    lastLaunched = Store.EPIC to id
                     val code = StoreLaunch.epicCode(app, id)
                     JSONObject().put("ok", true).put("code", code.written).put("reason", code.reason)
                 }
@@ -70,6 +77,7 @@ object StoreLaunchRequests {
                 val id = request.optString("id")
                 if (store == null || id.isEmpty()) JSONObject().put("ok", false).put("reason", "no-game")
                 else {
+                    lastLaunched = store to id
                     // Marked before the game runs: whatever ends it, an upload follows (CloudSaves.uploadDirty).
                     CloudSaves.markDirty(app, store, id)
                     CloudSaves.downloadOrDefer(app, store, id).let { JSONObject().put("ok", it.ok).put("result", it.result).put("files", it.files).put("reason", it.reason) }

app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt

@@ -99,6 +99,8 @@ object StoresState {
     /** Reads what is on disk for every store: sign-ins, installed games, the engine probe. Off the main thread. */
     fun refresh(context: Context) {
         val app = context.applicationContext
+        // The first refresh after the app starts brings back what was in the download queue.
+        com.droiddeck.launcher.stores.download.SavedQueue.restore(app)
         Thread({
             val found = Store.entries.mapNotNull { store -> StoreAccounts.signedInAs(app, store)?.let { store to it } }
             val onDisk = StoreInstallRoot.gameFolders(app).mapNotNull { folder ->
@@ -172,7 +174,8 @@ object StoresState {
         val app = context.applicationContext
         Thread({
             backends[store]?.signOut(app)
-            StoreAccounts.clear(app, store)
+            if (store == Store.GOG) com.droiddeck.launcher.stores.gog.GogComet.replaceAccount { StoreAccounts.clear(app, store) }
+            else StoreAccounts.clear(app, store)
             main.post {
                 accounts.remove(store); library.remove(store); status.remove(store); problems.remove(store)
                 logLine("${store.label}: signed out")
@@ -217,15 +220,30 @@ object StoresState {
     fun install(context: Context, item: CatalogItem, root: java.io.File? = null) {
         val app = context.applicationContext
         val target = root ?: StoreInstallRoot.installRoot(app)
+        com.droiddeck.launcher.stores.download.SavedQueue.remember(app, item, target)
         backends[item.store]?.install(app, item, target) ?: logLine("${item.store.label}: this build cannot install yet")
     }
 
-    /** Removes the game's folder and its shortcut, then [onDone] on the main thread. */
+    /** Games being removed, by key ("store:id"), and how far along (0..1): their page shows it. */
+    val uninstalling = mutableStateMapOf<String, Float>()
+
+    /**
+     * Removes the game's folder and its shortcut, then [onDone] on the main thread. The game reads
+     * as removed the moment it is gone (its page shows Install, its card its size), not once the
+     * whole library has been read again.
+     */
     fun uninstall(context: Context, game: InstalledStoreGame, onDone: () -> Unit = {}) {
         val app = context.applicationContext
+        val key = "${game.sidecar.store.id}:${game.sidecar.id}"
+        uninstalling[key] = 0f
         Thread({
             runCatching { backends[game.sidecar.store]?.uninstall(app, game) }
-            StoreInstalls.uninstall(app, game)
+            StoreInstalls.uninstall(app, game, progress = { f -> main.post { if (key in uninstalling) uninstalling[key] = f } }, removed = {
+                main.post {
+                    installed = installed.filterNot { it.folder.absolutePath == game.folder.absolutePath }
+                    uninstalling.remove(key)
+                }
+            })
             main.post(onDone)
         }, "stores-uninstall").start()
     }

app/src/main/java/com/droiddeck/launcher/stores/download/DownloadQueue.kt

@@ -137,6 +137,11 @@ object DownloadQueue {
 
     private val lock = Any()
     private val items = LinkedHashMap<String, Item>()
+    /** Keys a restart brings back paused: queued as paused, not started. */
+    private val heldPaused = HashSet<String>()
+
+    /** [key]'s next [enqueue] comes in paused (a paused download restored after a restart). */
+    fun holdPaused(key: String) = synchronized(lock) { heldPaused.add(key) }
     private var running = 0
 
     fun parallel(context: Context): Int = SessionPrefs.gameStoresParallel(context)
@@ -171,7 +176,8 @@ object DownloadQueue {
         synchronized(lock) {
             items[entry.key]?.let { if (it.entry.isActive) { Log.i(TAG, "${entry.key}: already queued"); return } }
             items.remove(entry.key)
-            items[entry.key] = Item(entry.copy(state = DownloadState.QUEUED, stage = DownloadStage.MANIFEST, startedAt = System.currentTimeMillis()), factory)
+            val state = if (heldPaused.remove(entry.key)) DownloadState.PAUSED else DownloadState.QUEUED
+            items[entry.key] = Item(entry.copy(state = state, stage = DownloadStage.MANIFEST, startedAt = System.currentTimeMillis()), factory)
             renumber()
         }
         StoresState.logLine("${entry.store.label}: queued \"${entry.name}\"" + if (entry.bytesTotal > 0) " (${com.droiddeck.launcher.stores.formatBytes(entry.bytesTotal)})" else "")
@@ -306,6 +312,8 @@ object DownloadQueue {
             }
         }
         lastPublishAt = now
+        // A state change (not progress) is written down, so the queue outlives the app.
+        if (!progressOnly) SavedQueue.save(items.values.map { it.entry })
         val list = items.values.map { it.entry }.sortedByDescending { it.startedAt }
         StoresState.post { StoresState.publishDownloads(list) }
     }

app/src/main/java/com/droiddeck/launcher/stores/download/SavedQueue.kt

@@ -0,0 +1,108 @@
+package com.droiddeck.launcher.stores.download
+
+import android.content.Context
+import android.util.Log
+import com.droiddeck.launcher.stores.CatalogItem
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoresState
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.Executors
+
+/**
+ * The download queue kept on disk, so what was queued, running or paused comes back after the app
+ * closes or is killed: the queue itself lives in memory, and a queued game that never started has
+ * nothing on disk to find. Each install records the game and where it goes ([remember]); every
+ * change of state writes the active rows in queue order ([save]); the first refresh after the app
+ * starts asks the stores for them again ([restore]) - running and queued ones carry on, paused ones
+ * come back paused.
+ */
+object SavedQueue {
+    private const val TAG = "StoreDownloads"
+    private const val FILE = "store-queue.json"
+
+    private class Wanted(val item: CatalogItem, val root: File?)
+
+    private val wanted = HashMap<String, Wanted>()
+    private val writer = Executors.newSingleThreadExecutor { r -> Thread(r, "store-queue-save") }
+    @Volatile private var app: Context? = null
+    private var restored = false
+
+    private fun key(item: CatalogItem) = "${item.store.id}:${item.id}"
+
+    /** An install is asked for: what to ask the store for again after a restart. */
+    @Synchronized
+    fun remember(context: Context, item: CatalogItem, root: File?) {
+        app = context.applicationContext
+        wanted[key(item)] = Wanted(item, root)
+    }
+
+    /** The active rows, in queue order, as they are now. Any thread; written off it. */
+    fun save(entries: List<DownloadEntry>) {
+        val context = app ?: return
+        val rows = synchronized(this) {
+            entries.filter { it.isActive }.mapNotNull { e -> wanted[e.key]?.let { e to it } }
+        }
+        val out = JSONArray()
+        for ((e, w) in rows) out.put(JSONObject().apply {
+            put("paused", e.state == DownloadState.PAUSED)
+            put("root", w.root?.absolutePath ?: "")
+            put("item", itemJson(w.item))
+        })
+        writer.execute {
+            runCatching {
+                val f = File(context.filesDir, FILE)
+                val tmp = File(context.filesDir, "$FILE.tmp")
+                tmp.writeText(out.toString())
+                tmp.renameTo(f)
+            }.onFailure { Log.w(TAG, "could not save the queue", it) }
+        }
+    }
+
+    /** Once per process: queues again what was in the queue when the app last closed. */
+    fun restore(context: Context) {
+        synchronized(this) { if (restored) return; restored = true }
+        val app = context.applicationContext
+        // Read before anything may write it: an install started at once must not save over it.
+        val rows = runCatching { JSONArray(File(app.filesDir, FILE).readText()) }.getOrNull()
+        this.app = app
+        rows ?: return
+        Thread({
+            val back = (0 until rows.length()).mapNotNull { i ->
+                runCatching {
+                    val o = rows.getJSONObject(i)
+                    Triple(itemOf(o.getJSONObject("item")), o.optString("root").takeIf { it.isNotEmpty() }?.let(::File), o.optBoolean("paused"))
+                }.getOrNull()
+            }
+            if (back.isEmpty()) return@Thread
+            StoresState.post {
+                for ((item, root, paused) in back) {
+                    if (DownloadQueue.entry(key(item)) != null) continue
+                    if (paused) DownloadQueue.holdPaused(key(item))
+                    StoresState.install(app, item, root)
+                }
+            }
+        }, "store-queue-restore").start()
+    }
+
+    private fun itemJson(i: CatalogItem) = JSONObject().apply {
+        put("store", i.store.id); put("id", i.id); put("title", i.title)
+        put("image", i.imageUrl ?: ""); put("tall", i.tallImageUrl ?: "")
+        put("tags", i.tags); put("developer", i.developer); put("description", i.description)
+        put("size", i.sizeBytes); put("owned", i.owned)
+        put("extra", JSONObject(i.extra))
+    }
+
+    private fun itemOf(o: JSONObject): CatalogItem {
+        val extra = o.optJSONObject("extra")
+        return CatalogItem(
+            store = Store.byId(o.getString("store")) ?: error("unknown store"),
+            id = o.getString("id"), title = o.getString("title"),
+            imageUrl = o.optString("image").ifEmpty { null }, tallImageUrl = o.optString("tall").ifEmpty { null },
+            tags = o.optString("tags"), developer = o.optString("developer"), description = o.optString("description"),
+            owned = o.optBoolean("owned", true), sizeBytes = o.optLong("size"),
+            extra = extra?.keys()?.asSequence()?.associateWith { extra.getString(it) } ?: emptyMap(),
+        )
+    }
+}

app/src/main/java/com/droiddeck/launcher/stores/epic/EpicAchievements.kt

@@ -0,0 +1,91 @@
+package com.droiddeck.launcher.stores.epic
+
+import android.content.Context
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoreAchievements
+import com.droiddeck.launcher.stores.StoreNet
+import org.json.JSONObject
+
+/** Epic's GraphQL: the sandbox's achievements, then the player's records in it. */
+object EpicAchievements : StoreAchievements(Store.EPIC.id, Store.EPIC.shortLabel) {
+    private const val GRAPHQL = "https://launcher.store.epicgames.com/graphql"
+    private const val USER_AGENT = "EpicGamesLauncher/14.0.8-22004686+++Portal+Release-Live"
+
+    override fun request(context: Context, game: Game): Result {
+        val namespace = game.extra["namespace"].orEmpty()
+        if (namespace.isEmpty()) return Result.Failed(Reason.NO_SERVICE)
+        val token = EpicCredentialStore.getValidAccessToken(context) ?: return Result.Failed(Reason.SIGNED_OUT)
+        val account = EpicCredentialStore.load(context)?.accountId.orEmpty()
+        val defs = query(token, GAME_ACHIEVEMENTS, JSONObject().put("sandboxId", namespace).put("locale", locale()))
+            ?: return Result.Failed(Reason.UNREACHABLE)
+        val list = defs.optJSONObject("data")?.optJSONObject("Achievement")?.optJSONObject("productAchievementsRecordBySandbox")
+            ?.optJSONArray("achievements") ?: return Result.Found(emptyList())
+        val unlocked = if (account.isEmpty()) emptyMap() else unlockTimes(token, account, namespace)
+        val out = ArrayList<Achievement>()
+        for (i in 0 until list.length()) {
+            val a = list.optJSONObject(i)?.optJSONObject("achievement") ?: continue
+            val id = a.optString("name")
+            if (id.isEmpty()) continue
+            val at = unlocked[id]
+            val done = at != null
+            out += Achievement(
+                id = id,
+                name = (if (done) a.optString("unlockedDisplayName") else a.optString("lockedDisplayName"))
+                    .ifEmpty { a.optString("unlockedDisplayName") }.ifEmpty { id },
+                description = (if (done) a.optString("unlockedDescription") else a.optString("lockedDescription"))
+                    .ifEmpty { a.optString("unlockedDescription") },
+                hidden = a.optBoolean("hidden"),
+                unlocked = done,
+                unlockedAt = at ?: 0,
+                icon = a.optString("unlockedIconLink").ifEmpty { null },
+                iconLocked = a.optString("lockedIconLink").ifEmpty { null },
+            )
+        }
+        return Result.Found(out)
+    }
+
+    /** Achievement name to unlock time, for the ones the player has. */
+    private fun unlockTimes(token: String, account: String, namespace: String): Map<String, Long> {
+        val out = HashMap<String, Long>()
+        val records = query(token, PLAYER_ACHIEVEMENTS, JSONObject().put("epicAccountId", account).put("sandboxId", namespace))
+            ?.optJSONObject("data")?.optJSONObject("PlayerAchievement")?.optJSONObject("playerAchievementGameRecordsBySandbox")
+            ?.optJSONArray("records") ?: return out
+        for (r in 0 until records.length()) {
+            val player = records.optJSONObject(r)?.optJSONArray("playerAchievements") ?: continue
+            for (i in 0 until player.length()) {
+                val pa = player.optJSONObject(i)?.optJSONObject("playerAchievement") ?: continue
+                if (pa.optBoolean("unlocked")) out[pa.optString("achievementName")] = epochSeconds(pa.optString("unlockDate"))
+            }
+        }
+        return out
+    }
+
+    private fun query(token: String, query: String, variables: JSONObject): JSONObject? =
+        StoreNet.postJson(GRAPHQL, JSONObject().put("query", query).put("variables", variables).toString(), bearer = token, userAgent = USER_AGENT)
+            ?.let(::JSONObject)
+
+    private val GAME_ACHIEVEMENTS = """
+        query Achievement(${'$'}sandboxId: String!, ${'$'}locale: String!) {
+          Achievement {
+            productAchievementsRecordBySandbox(sandboxId: ${'$'}sandboxId, locale: ${'$'}locale) {
+              achievements {
+                achievement {
+                  name hidden unlockedDisplayName lockedDisplayName unlockedDescription lockedDescription
+                  unlockedIconLink lockedIconLink XP
+                }
+              }
+            }
+          }
+        }
+    """.trimIndent()
+
+    private val PLAYER_ACHIEVEMENTS = """
+        query PlayerAchievement(${'$'}epicAccountId: String!, ${'$'}sandboxId: String!) {
+          PlayerAchievement {
+            playerAchievementGameRecordsBySandbox(epicAccountId: ${'$'}epicAccountId, sandboxId: ${'$'}sandboxId) {
+              records { playerAchievements { playerAchievement { achievementName unlocked unlockDate XP } } }
+            }
+          }
+        }
+    """.trimIndent()
+}

app/src/main/java/com/droiddeck/launcher/stores/epic/EpicDownloadManager.java

@@ -548,10 +548,10 @@ public final class EpicDownloadManager {
         try {
             JSONObject root = new JSONObject(new String(bytes, StandardCharsets.UTF_8));
             int manifestVersion = 0;
-            try { manifestVersion = Integer.parseInt(root.optString("ManifestFileVersion", "0")); } catch (NumberFormatException ignored) {}
+            try { manifestVersion = (int) blobToNum(root.optString("ManifestFileVersion", "0")); } catch (NumberFormatException ignored) {}
             Manifest m = new Manifest();
             m.chunkDir = manifestVersion >= 15 ? "ChunksV4" : manifestVersion >= 6 ? "ChunksV3" : manifestVersion >= 3 ? "ChunksV2" : "ChunksV4";
-            m.launchExe = root.optString("LaunchExe", "").replace('\\', '/');
+            m.launchExe = root.optString("LaunchExeString", root.optString("LaunchExe", "")).replace('\\', '/');
             m.launchCommand = root.optString("LaunchCommand", "");
             m.buildVersion = root.optString("BuildVersionString", "");
             m.prereqName = root.optString("PrereqName", "");
@@ -568,10 +568,9 @@ public final class EpicDownloadManager {
                 if (guidHex.length() < 32) continue;
                 ChunkInfo c = new ChunkInfo();
                 for (int k = 0; k < 4; k++) c.guid[k] = (int) Long.parseLong(guidHex.substring(k * 8, k * 8 + 8), 16);
-                String hashHex = chunkHashList.getString(guidHex);
-                if (hashHex != null && hashHex.length() >= 16) { try { c.hash = Long.parseUnsignedLong(hashHex.substring(0, 16), 16); } catch (Exception ignored) {} }
-                if (dataGroupList != null) { try { c.groupNum = Integer.parseInt(dataGroupList.optString(guidHex, "0")); } catch (NumberFormatException ignored) {} }
-                if (chunkFilesizeList != null) { try { c.fileSize = Long.parseLong(chunkFilesizeList.optString(guidHex, "0"), 16); } catch (NumberFormatException ignored) {} }
+                try { c.hash = blobToNum(chunkHashList.getString(guidHex)); } catch (NumberFormatException ignored) {}
+                if (dataGroupList != null) { try { c.groupNum = (int) blobToNum(dataGroupList.optString(guidHex, "0")); } catch (NumberFormatException ignored) {} }
+                if (chunkFilesizeList != null) { try { c.fileSize = blobToNum(chunkFilesizeList.optString(guidHex, "0")); } catch (NumberFormatException ignored) {} }
                 chunkMap.put(guidHex, c);
             }
             JSONArray fileList = root.optJSONArray("FileManifestList");
@@ -589,8 +588,8 @@ public final class EpicDownloadManager {
                     ChunkPart part = new ChunkPart();
                     String g = po.optString("Guid", "");
                     if (g.length() >= 32) for (int k = 0; k < 4; k++) part.guid[k] = (int) Long.parseLong(g.substring(k * 8, k * 8 + 8), 16);
-                    try { part.offset = Integer.parseInt(po.optString("Offset", "0")); } catch (NumberFormatException ignored) {}
-                    try { part.size = Integer.parseInt(po.optString("Size", "0")); } catch (NumberFormatException ignored) {}
+                    try { part.offset = (int) blobToNum(po.optString("Offset", "0")); } catch (NumberFormatException ignored) {}
+                    try { part.size = (int) blobToNum(po.optString("Size", "0")); } catch (NumberFormatException ignored) {}
                     fi.parts.add(part);
                 }
                 files.add(fi);
@@ -604,6 +603,24 @@ public final class EpicDownloadManager {
         }
     }
 
+    /**
+     * A JSON manifest writes every number as a "blob": each byte as three decimal digits, least
+     * significant first ("013000000000" = 13), as Legendary's blob_to_num reads it. Bits past 64
+     * are dropped; a group that is not digits throws.
+     */
+    static long blobToNum(String blob) {
+        long num = 0;
+        for (int i = 0, shift = 0; i < blob.length(); i += 3, shift += 8) {
+            String group = blob.substring(i, Math.min(i + 3, blob.length()));
+            for (int k = 0; k < group.length(); k++) {
+                char ch = group.charAt(k);
+                if (ch < '0' || ch > '9') throw new NumberFormatException("not a blob: " + blob);
+            }
+            if (shift < 64) num += Long.parseLong(group) << shift;
+        }
+        return num;
+    }
+
     public static String readFString(ByteBuffer buf) {
         int length = buf.getInt();
         if (length == 0) return "";

app/src/main/java/com/droiddeck/launcher/stores/gog/GogAchievements.kt

@@ -0,0 +1,83 @@
+package com.droiddeck.launcher.stores.gog
+
+import android.content.Context
+import android.util.Log
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoreAchievements
+import com.droiddeck.launcher.stores.StoreLog
+import com.droiddeck.launcher.stores.StoreNet
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.zip.InflaterInputStream
+
+/** gameplay.gog.com, with a token scoped to the game's own client. */
+object GogAchievements : StoreAchievements(Store.GOG.id, Store.GOG.shortLabel) {
+    private const val TAG = "GogAchievements"
+
+    override fun request(context: Context, game: Game): Result {
+        val galaxy = GogAuth.validToken(context) ?: return Result.Failed(Reason.SIGNED_OUT)
+        val (clientId, clientSecret) = client(context, game.id, galaxy) ?: return Result.Failed(Reason.NO_SERVICE)
+        val scoped = GogAuth.gameToken(context, clientId, clientSecret) ?: return Result.Failed(Reason.UNREACHABLE)
+        val body = StoreNet.get(
+            "https://gameplay.gog.com/clients/$clientId/users/${scoped.userId}/achievements",
+            bearer = scoped.accessToken, userAgent = GogAuth.GALAXY_UA, headers = mapOf("X-Gog-Lc" to locale()),
+        ) ?: return Result.Failed(Reason.UNREACHABLE)
+        val items = body.takeIf { it.isNotBlank() }?.let(::JSONObject)?.optJSONArray("items") ?: return Result.Found(emptyList())
+        val out = ArrayList<Achievement>()
+        for (i in 0 until items.length()) {
+            val item = items.optJSONObject(i) ?: continue
+            val id = item.optString("achievement_key").ifEmpty { item.optString("achievement_id") }
+            if (id.isEmpty()) continue
+            val date = item.optString("date_unlocked").takeIf { it.isNotBlank() && it != "null" }
+            out += Achievement(
+                id = id,
+                name = item.optString("name").ifEmpty { id },
+                description = item.optString("description"),
+                hidden = !item.optBoolean("visible", true),
+                unlocked = date != null,
+                unlockedAt = date?.let(::epochSeconds) ?: 0,
+                icon = item.optString("image_url_unlocked").ifEmpty { item.optString("image_url_locked") }.ifEmpty { null },
+                iconLocked = item.optString("image_url_locked").ifEmpty { null },
+            )
+        }
+        return Result.Found(out)
+    }
+
+    /** The game's client id and secret: saved at install, else from the newest build's manifest. */
+    private fun client(context: Context, productId: String, token: String): Pair<String, String>? {
+        val prefs = GogPrefs.get(context)
+        val savedId = prefs.getString("client_id_$productId", null)?.ifEmpty { null }
+        val savedSecret = prefs.getString("client_secret_$productId", null)?.ifEmpty { null }
+        if (savedId != null && savedSecret != null) return savedId to savedSecret
+        val builds = StoreNet.get("https://content-system.gog.com/products/$productId/os/windows/builds?generation=2", bearer = token)
+            ?.let(::JSONObject) ?: return null
+        val link = builds.optJSONArray("items")?.optJSONObject(0)?.optString("link")?.ifEmpty { null } ?: return null
+        val manifest = bytes(link, token)?.let { JSONObject(inflate(it)) } ?: return null
+        val id = manifest.optString("clientId").ifEmpty { return null }
+        val secret = manifest.optString("clientSecret").ifEmpty { return null }
+        prefs.edit().putString("client_id_$productId", id).putString("client_secret_$productId", secret).apply()
+        return id to secret
+    }
+
+    private fun bytes(url: String, bearer: String): ByteArray? {
+        var conn: HttpURLConnection? = null
+        return try {
+            conn = (URL(url).openConnection() as HttpURLConnection).apply {
+                connectTimeout = 20_000; readTimeout = 20_000
+                setRequestProperty("Authorization", "Bearer $bearer")
+            }
+            if (conn.responseCode !in 200..299) null else conn.inputStream.use { it.readBytes() }
+        } catch (e: Exception) {
+            Log.w(TAG, "GET failed ${StoreLog.redactUrl(url)}: ${e.javaClass.simpleName}")
+            null
+        } finally {
+            runCatching { conn?.disconnect() }
+        }
+    }
+
+    /** Gen2 manifests are zlib-compressed; plain JSON passes through. */
+    private fun inflate(data: ByteArray): String =
+        if (data.isNotEmpty() && data[0] == '{'.code.toByte()) String(data, Charsets.UTF_8)
+        else InflaterInputStream(data.inputStream()).use { String(it.readBytes(), Charsets.UTF_8) }
+}

app/src/main/java/com/droiddeck/launcher/stores/gog/GogAuth.kt

@@ -33,7 +33,12 @@ object GogAuth {
     fun isSignedIn(context: Context): Boolean = StoreAccounts.read(context, Store.GOG)?.optString("access_token", "")?.isNotEmpty() == true
 
     /** Saves a fresh sign-in and looks the account's name up for the chip. Blocking. */
-    fun saveLogin(context: Context, accessToken: String, refreshToken: String?, userId: String?) {
+    fun saveLogin(context: Context, accessToken: String, refreshToken: String?, userId: String?) = GogComet.replaceAccount {
+        saveAccount(context, accessToken, refreshToken, userId)
+    }
+
+    @Synchronized
+    private fun saveAccount(context: Context, accessToken: String, refreshToken: String?, userId: String?) {
         var username = ""
         runCatching {
             val body = StoreNet.get("https://embed.gog.com/userData.json", bearer = accessToken, userAgent = GALAXY_UA)
@@ -52,6 +57,7 @@ object GogAuth {
 
     /** A usable access token, refreshed when the recorded login time says it has expired; null when signed out or the refresh failed. */
     @JvmStatic
+    @Synchronized
     fun validToken(context: Context): String? {
         val json = StoreAccounts.read(context, Store.GOG) ?: return null
         val token = json.optString("access_token", "").ifEmpty { return null }
@@ -63,6 +69,7 @@ object GogAuth {
 
     /** Refreshes the access token; the new one, or null on any failure. Blocking. */
     @JvmStatic
+    @Synchronized
     fun refresh(context: Context): String? {
         val json = StoreAccounts.read(context, Store.GOG) ?: return null
         val refreshToken = json.optString("refresh_token", "").ifEmpty { return null }
@@ -87,6 +94,51 @@ object GogAuth {
         }
     }
 
+    /** A complete companion snapshot. Never exported through the guest request channel. */
+    @Synchronized
+    fun cometCredentials(context: Context): JSONObject? {
+        val access = validToken(context) ?: return null
+        val saved = StoreAccounts.read(context, Store.GOG) ?: return null
+        val refresh = saved.optString("refresh_token").ifEmpty { return null }
+        var user = saved.optString("user_id")
+        var username = saved.optString("username")
+        if (!user.matches(Regex("[0-9]+")) || username.isEmpty()) {
+            val body = StoreNet.get("https://embed.gog.com/userData.json", bearer = access, userAgent = GALAXY_UA, timeoutMs = 5_000) ?: return null
+            val info = runCatching { JSONObject(body) }.getOrNull() ?: return null
+            user = info.optString("galaxyUserId", info.optString("userId", user))
+            username = info.optString("username", username)
+            if (!user.matches(Regex("[0-9]+")) || username.isEmpty()) return null
+            saved.put("user_id", user).put("username", username)
+            StoreAccounts.write(context, Store.GOG, saved)
+        }
+        return JSONObject().put("access_token", access).put("refresh_token", refresh)
+            .put("user_id", user).put("username", username)
+    }
+
+    class GameToken(val accessToken: String, val userId: String)
+
+    /** The Galaxy refresh token exchanged for one scoped to a game's own client. Blocking. */
+    fun gameToken(context: Context, clientId: String, clientSecret: String): GameToken? {
+        val json = StoreAccounts.read(context, Store.GOG) ?: return null
+        val refresh = json.optString("refresh_token", "").ifEmpty { return null }
+        var conn: HttpURLConnection? = null
+        return try {
+            val enc = { s: String -> java.net.URLEncoder.encode(s, "UTF-8") }
+            conn = (URL("https://auth.gog.com/token?client_id=${enc(clientId)}&client_secret=${enc(clientSecret)}&grant_type=refresh_token&refresh_token=${enc(refresh)}")
+                .openConnection() as HttpURLConnection).apply { connectTimeout = 15_000; readTimeout = 15_000 }
+            conn.setRequestProperty("User-Agent", "GOG Galaxy")
+            if (conn.responseCode != 200) { Log.w(TAG, "game token: HTTP ${conn.responseCode}"); return null }
+            val o = JSONObject(conn.inputStream.bufferedReader().readText())
+            val access = o.optString("access_token").ifEmpty { return null }
+            GameToken(access, o.optString("user_id").ifEmpty { json.optString("user_id") })
+        } catch (e: Exception) {
+            Log.w(TAG, "game token failed: ${e.javaClass.simpleName}")
+            null
+        } finally {
+            runCatching { conn?.disconnect() }
+        }
+    }
+
     /** Hosts the GOG login page hands off to for a social sign-in; they refuse an embedded browser's identity. */
     fun isIdentityProviderHost(host: String?): Boolean {
         val h = host?.lowercase() ?: return false

app/src/main/java/com/droiddeck/launcher/stores/gog/GogComet.kt

@@ -0,0 +1,189 @@
+package com.droiddeck.launcher.stores.gog
+
+import android.content.Context
+import android.os.Environment
+import android.util.Log
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.session.SessionEvents
+import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.AchievementNotifications
+import com.droiddeck.launcher.stores.StoreAchievements
+import com.droiddeck.launcher.stores.StoreAccounts
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import com.droiddeck.launcher.stores.StoreInstallRoot
+import com.droiddeck.launcher.stores.StoresState
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/** Owns one Galaxy companion; only its structured, secret-free events reach Android logs. */
+object GogComet {
+    private const val TAG = "GogComet"
+    private const val BIN = "/usr/local/lib/droiddeck-comet/comet"
+    private val lock = Any()
+    @Volatile private var process: Process? = null
+    private var pid = -1
+    private var started: String? = null
+    private var account = ""
+    private var session: String? = null
+    private var accepting = false
+    private var generation: String? = null
+    @Volatile private var gamesByClient: Map<String, StoreGameSidecar> = emptyMap()
+    var status by mutableStateOf("off")
+        private set
+
+    fun enabled(context: Context) = GogPrefs.get(context).getBoolean("achievements", false)
+
+    fun setEnabled(context: Context, on: Boolean) {
+        GogPrefs.get(context).edit().putBoolean("achievements", on).apply()
+
+    }
+
+    fun begin() = synchronized(lock) {
+        stopLocked()
+        accepting = true
+        generation = SessionState.sessionId
+        AchievementNotifications.begin(generation)
+    }
+
+    /** Account replacement and launch preparation use the same lock, preventing stale restarts. */
+    fun replaceAccount(change: () -> Unit) = synchronized(lock) {
+        stopLocked()
+        AchievementNotifications.begin(generation)
+        change()
+    }
+
+    fun stop() = synchronized(lock) {
+        stopLocked()
+    }
+
+    fun end(expected: String?) = synchronized(lock) {
+        if (generation == expected) {
+            accepting = false
+            stopLocked()
+            AchievementNotifications.end(expected)
+            generation = null
+        }
+    }
+
+    private fun report(value: String) {
+        StoresState.post { status = value }
+        Log.i(TAG, value)
+        SessionEvents.record("gog.achievements", mapOf("status" to value))
+    }
+
+    private fun publishPolicy(context: Context): File {
+        val dir = File(context.filesDir, "gog-achievements").apply { mkdirs() }
+        val games = if (!enabled(context)) emptyMap() else StoreInstallRoot.gameFolders(context).mapNotNull { folder ->
+            val game = StoreGameSidecar.read(folder) ?: return@mapNotNull null
+            if (game.store != Store.GOG || !game.achievements) return@mapNotNull null
+            val client = GogPrefs.get(context).getString("client_id_${game.id}", null)
+                ?: runCatching { JSONObject(File(folder, "goggame-${game.id}.info").readText()).optString("clientId") }.getOrNull()
+            client?.takeIf { it.matches(Regex("[0-9]+")) }?.let { it to game }
+        }.toMap()
+        gamesByClient = games
+        val file = File(dir, "clients.json")
+        val tmp = File(dir, "clients.json.tmp")
+        tmp.writeText(org.json.JSONArray(games.keys.toList()).toString())
+        check(tmp.renameTo(file))
+        return file
+    }
+
+    /** No arbitrary paths or credentials from the guest are accepted. */
+    fun prepare(context: Context, id: String): JSONObject = synchronized(lock) {
+        fun reply(ready: Boolean, reason: String): JSONObject {
+            report(reason)
+            return JSONObject().put("ok", ready).put("ready", ready).put("reason", reason)
+        }
+        if (!accepting || !SessionState.running || generation != SessionState.sessionId) return reply(false, "no-session")
+        val folder = StoreInstallRoot.gameFolders(context).firstOrNull { f -> StoreGameSidecar.read(f)?.let { it.store == Store.GOG && it.id == id } == true }
+        val sidecar = folder?.let { StoreGameSidecar.read(it) }
+        if (sidecar?.store != Store.GOG || sidecar.id != id) return reply(false, "no-game")
+        val policy = publishPolicy(context)
+        if (!enabled(context) || !sidecar.achievements) return reply(false, "off")
+        val credentials = GogAuth.cometCredentials(context) ?: return reply(false,
+            if (StoreAccounts.isUnavailable(Store.GOG)) "credentials-unavailable"
+            else if (StoreAccounts.read(context, Store.GOG)?.optString("refresh_token").isNullOrEmpty()) "sign-in-needed" else "credentials-unavailable")
+        if (!SessionState.running || generation != SessionState.sessionId) return reply(false, "no-session")
+        val user = credentials.getString("user_id")
+        if (process?.isAlive == true && account == user && session == SessionState.sessionId && identity(pid) == started) {
+            return JSONObject().put("ok", true).put("ready", true).put("reason", "ready")
+        }
+        stopLocked()
+        if (!File(LinuxRuntime.rootDir(context), BIN.removePrefix("/")).isFile) return reply(false, "not-installed")
+        val data = File(context.filesDir, "gog-achievements").apply { mkdirs() }
+        val ready = CountDownLatch(1)
+        val command = LinuxRuntime.command(context, null, null, Environment.getExternalStorageDirectory(),
+            listOf("/usr/bin/env", "HOME=/root", "XDG_DATA_HOME=${data.path}/data", "XDG_CONFIG_HOME=${data.path}/config", "COMET_LOG=off", "COMET_ALLOWED_CLIENTS=${policy.path}", BIN, "--credentials-stdin"))
+        val pb = ProcessBuilder(command).redirectErrorStream(true)
+        pb.environment().apply {
+            remove("LD_PRELOAD"); remove("LD_AUDIT"); remove("LD_LIBRARY_PATH")
+            put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path)
+            put("PROOT_TMP_DIR", context.cacheDir.path)
+            if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1")
+            LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) }
+        }
+        try {
+            val child = pb.start()
+            process = child; account = user; session = SessionState.sessionId
+            Thread({
+                runCatching { child.inputStream.bufferedReader().useLines { lines -> lines.forEach { line ->
+                    // Raw upstream errors/payloads can contain tokens. Never forward them.
+                    when {
+                        line.startsWith("DROIDDECK_COMET_READY:") -> {
+                            val childPid = line.substringAfter(':').toIntOrNull() ?: -1
+                            if (childPid > 1 && process === child) {
+                                pid = childPid; started = identity(childPid); ready.countDown()
+                            }
+                        }
+                        line.startsWith("DROIDDECK_COMET_UNLOCKED:") -> if (process === child) {
+                            val event = runCatching { JSONObject(line.substringAfter(':')) }.getOrNull()
+                            val game = event?.optString("client_id")?.let { gamesByClient[it] }
+                            val unlock = event?.let { AchievementNotifications.parse(it, game?.title.orEmpty()) }
+                            val owner = session
+                            if (game != null && unlock != null && owner != null && owner == SessionState.sessionId && SessionState.running) {
+                                report("unlocked-locally")
+                                AchievementNotifications.unlock(owner, unlock)
+                                SessionEvents.record("achievement.unlocked", mapOf("store" to "gog", "gameId" to game.id, "achievementId" to unlock.id))
+                            }
+                        }
+                        line == "DROIDDECK_COMET_PENDING" -> if (process === child) report("pending-upload")
+                        line.startsWith("DROIDDECK_COMET_UPLOADED:") -> if (process === child && line.substringAfter(':').toIntOrNull()?.let { it > 0 } == true) { report("uploaded"); StoresState.post { StoreAchievements.invalidate() } }
+                    }
+                } } }
+                if (process === child) report("service-unavailable")
+                ready.countDown()
+            }, "gog-comet-output").start()
+            child.outputStream.bufferedWriter().use { it.write(credentials.toString()) }
+            if (!ready.await(5, TimeUnit.SECONDS) || pid <= 1 || started == null || !child.isAlive) {
+                stopLocked(); return reply(false, "service-unavailable")
+            }
+            reply(true, "ready")
+        } catch (e: Exception) {
+            stopLocked()
+            reply(false, "service-unavailable")
+        }
+    }
+
+    private fun identity(pid: Int): String? = if (pid <= 1) null else runCatching {
+        File("/proc/$pid/stat").readText().substringAfterLast(") ").split(' ')[19]
+    }.getOrNull()
+
+    private fun stopLocked() {
+        val child = process ?: return
+        // Signal the announced daemon, not proot; start time prevents signalling a reused PID.
+        if (started != null && identity(pid) == started) android.os.Process.sendSignal(pid, 2)
+        if (!child.waitFor(5, TimeUnit.SECONDS)) {
+            if (started != null && identity(pid) == started) android.os.Process.sendSignal(pid, 15)
+            child.destroy()
+        }
+        process = null; pid = -1; started = null; account = ""; session = null
+        report("stopped")
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/AchievementNotificationOverlay.kt

@@ -0,0 +1,96 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coil.compose.AsyncImage
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.session.SessionEvents
+import com.droiddeck.launcher.stores.AchievementNotifications
+import kotlinx.coroutines.delay
+
+@Composable
+internal fun AchievementNotificationOverlay() {
+    val unlock = AchievementNotifications.pending.firstOrNull()
+    var visible by remember(unlock) { mutableStateOf(false) }
+    LaunchedEffect(unlock) {
+        if (unlock == null) return@LaunchedEffect
+        visible = true
+        SessionEvents.record("achievement.notification-shown", mapOf("achievementId" to unlock.id))
+        delay(5_000)
+        visible = false
+        delay(Motion.ms(220).toLong())
+        AchievementNotifications.dismiss(unlock)
+    }
+    Box(Modifier.fillMaxSize().padding(20.dp), contentAlignment = Alignment.BottomEnd) {
+        AnimatedVisibility(
+            visible, enter = fadeIn(Motion.tw(220)) + slideInVertically(Motion.tw(300)) { it / 2 },
+            exit = fadeOut(Motion.tw(180)) + slideOutVertically(Motion.tw(220)) { it / 3 },
+        ) { if (unlock != null) AchievementNotificationCard(unlock) }
+    }
+}
+
+@Composable
+private fun AchievementNotificationCard(unlock: AchievementNotifications.Unlock) {
+    val pal = LocalPalette.current
+    val shape = RoundedCornerShape(16.dp)
+    Row(
+        Modifier.widthIn(max = 360.dp).clip(shape).background(pal.surface.copy(alpha = 0.97f))
+            .border(1.dp, pal.signal.copy(alpha = 0.65f), shape).padding(14.dp)
+            .testTag("achievement-notification"),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Box(Modifier.size(48.dp).clip(RoundedCornerShape(10.dp)).background(pal.surfaceVariant), contentAlignment = Alignment.Center) {
+            Trophy(26.dp, description = null)
+            if (unlock.icon != null) AsyncImage(unlock.icon, null, contentScale = ContentScale.Crop, modifier = Modifier.fillMaxSize())
+        }
+        Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) {
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(5.dp)) {
+                Trophy(13.dp, description = null)
+                Text(stringResource(R.string.achievement_unlocked).uppercase(), fontSize = 10.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 0.8.sp, color = pal.signal)
+            }
+            Text(unlock.name, color = pal.onBackground, fontSize = 15.sp, fontWeight = FontWeight.Bold, maxLines = 2, overflow = TextOverflow.Ellipsis)
+            if (unlock.game.isNotBlank()) Text(unlock.game, color = pal.onSurfaceVariant, fontSize = 12.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
+        }
+    }
+}
+
+@Preview(widthDp = 420, heightDp = 150)
+@Composable
+private fun AchievementNotificationPreview() = DroidDeckTheme {
+    Box(Modifier.padding(20.dp)) {
+        AchievementNotificationCard(AchievementNotifications.Unlock("1", "first", "First Steps", "", null, "Hollow Valley"))
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt

@@ -0,0 +1,455 @@
+package com.droiddeck.launcher.ui
+
+import android.os.Build
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.MutableTransitionState
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.expandHorizontally
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.LocalIndication
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.outlined.Apps
+import androidx.compose.material.icons.outlined.DesktopWindows
+import androidx.compose.material.icons.outlined.Storefront
+import androidx.compose.material.icons.outlined.Terminal
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.blur
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.zIndex
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coil.compose.AsyncImage
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.core.FileUtils
+import com.droiddeck.launcher.frontend.Library
+import com.droiddeck.launcher.runtime.UserApps
+import com.droiddeck.launcher.session.SessionService
+import com.droiddeck.launcher.store.UserAppsState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+// The Desktop tab in the Steam tab's shape: a tilted wall of little windows behind the word and
+// one big Open desktop, with Play's lip and lifted sheet under it (Display, Controls, Session and
+// Files). Under the hero the page scrolls to two shelves - the apps that run in the desktop, and
+// what can be added - and the hero folds into a slim header as it goes.
+
+/** The desktop's own chips: its session settings, then Files. */
+private val DESKTOP_TABS = modeSheetTabs(steam = false) + SheetTab.FILES
+
+@Composable
+internal fun DesktopPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier, onSelect: (String) -> Unit) {
+    val ctx = LocalContext.current
+    val density = LocalDensity.current
+    val narrow = LocalNarrowPane.current
+    val colors = MaterialTheme.colorScheme
+    LaunchedEffect(Unit) { UserAppsState.refresh(ctx) }
+    // Flathub's installed apps sit with the others on the dock.
+    LaunchedEffect(s.ready) { com.droiddeck.launcher.store.StoreState.refresh(ctx) }
+    val installed = s.emulators.filter { it.installed }
+    val apps = UserAppsState.items
+    var adding by rememberSaveable { mutableStateOf(false) }
+    val mode = SessionService.MODE_DESKTOP
+    val tabs = DESKTOP_TABS.map { it to sheetTabLabel(it) }
+    val open = if (s.desktopInstalled) stringResource(R.string.content_open_desktop) else stringResource(R.string.content_install_open_desktop)
+    // Opened from a card: the page floods out of it, its picture on the tile.
+    fun openFrom(at: Rect?, art: Any?, page: String) {
+        at?.let { PageOrigin.mark(Origin(it, 16f * density.density, art = art)) }
+        onSelect(page)
+    }
+
+    // The Steam tab's shape, the whole pane: the dock of apps along the top of the wall, the word
+    // and Open desktop at the foot, and nothing under the settings sheet but the hero itself.
+    LiftHero(
+        key = "desktop", tabs = tabs,
+        onOpen = a.onDesktopSettings, onPrimary = a.onDesktop,
+        modifier = modifier.clipToBounds(),
+        start = if (narrow) 20.dp else 44.dp, bottom = if (narrow) 20.dp else 44.dp,
+        background = {
+            DesktopWall(installed.map { it.iconRes } + apps.mapNotNull { it.icon })
+        },
+        scrim = { lifted ->
+            WallFade()
+            // Over the fades, so the cards read at full strength; gone as the sheet lifts, so
+            // nothing but the wall is behind it.
+            Box(Modifier.graphicsLayer { val v = lifted(); alpha = 1f - v; translationY = -12.dp.toPx() * v }) {
+                DesktopDock(s, a, installed, apps, openFrom = ::openFrom)
+            }
+        },
+        words = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                // The word at the wordmark's size.
+                Text(
+                    stringResource(R.string.rail_desktop), fontSize = if (narrow) 30.sp else 42.sp, lineHeight = if (narrow) 34.sp else 46.sp,
+                    fontWeight = FontWeight.Black, color = colors.onBackground,
+                )
+                BusyChip(s)
+            }
+        },
+        button = { click ->
+            // Enabled without a runtime or the desktop: the session's loading screen installs them first.
+            PrimaryButton(open, enabled = !s.busy, main = true, large = true, icon = Icons.Outlined.DesktopWindows, onClick = click)
+        },
+        beside = {
+            // Flathub, whose apps run in the desktop: its storefront floods out of this button.
+            HeroIconButton(Icons.Outlined.Storefront, stringResource(R.string.flathub_name), FlathubTeal, "desktop:flathub") { at -> openFrom(at, null, "store") }
+            // Add your own app or game.
+            HeroIconButton(Icons.Filled.Add, stringResource(R.string.user_apps_add), null, "desktop:add") { if (!s.busy) adding = true }
+        },
+        rows = { tab ->
+            if (tab == SheetTab.FILES) DesktopFiles(s, a)
+            else a.modeSheet(mode, tab, SheetExtras())
+        },
+    )
+    if (adding && !s.busy) AddAppDialog(s.ready, onDismiss = { adding = false }) { request, label -> UserAppsState.add(ctx, request, label) }
+}
+
+/**
+ * The dock along the top of the Desktop hero: what runs in the desktop (emulators installed, apps
+ * added, Flathub's installed apps), then the emulators that can be added - one
+ * row of cards that scrolls sideways, over the wall. It sinks back with the wall as the sheet lifts.
+ */
+@Composable
+private fun DesktopDock(
+    s: FrontEndState, a: FrontEndActions, installed: List<Library.Emulator>, apps: List<UserApps.App>,
+    openFrom: (Rect?, Any?, String) -> Unit,
+) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val narrow = LocalNarrowPane.current
+    val available = s.emulators.filter { !it.installed }
+    val flatpaks = com.droiddeck.launcher.store.StoreState.installed
+    val keys = installed.map { "emu:${it.id}" } + apps.map { "user:${it.key}" } + flatpaks.map { "flatpak:${it.id}" }
+    // Where the last of your apps sits, for a new emulator's dot to land after it.
+    var lastAt by remember { mutableStateOf<Rect?>(null) }
+    var dockAt by remember { mutableStateOf<Rect?>(null) }
+    val seen = remember { mutableSetOf<String>() }
+    val mounted = remember { booleanArrayOf(false) }
+    LaunchedEffect(Unit) { mounted[0] = true }
+    val scroll = rememberScrollState()
+    // Nothing yet (the emulators' catalog still on its way): no heading over an empty row.
+    if (keys.isEmpty() && available.isEmpty() && UserAppsState.working == null && UserAppsState.lastError == null) return
+    Column(Modifier.fillMaxWidth().padding(top = if (narrow) 14.dp else 22.dp)) {
+        Text(
+            stringResource(R.string.user_apps_section).uppercase(), fontSize = 11.sp, fontWeight = FontWeight.Bold, letterSpacing = 1.6.sp,
+            color = colors.onSurfaceVariant, modifier = Modifier.padding(start = if (narrow) 20.dp else 44.dp, bottom = 8.dp),
+        )
+        Row(
+            horizontalArrangement = Arrangement.spacedBy(10.dp), verticalAlignment = Alignment.Top,
+            modifier = Modifier.fillMaxWidth().onGloballyPositioned { dockAt = it.boundsInRoot() }
+                .edgeFade(scroll).horizontalScroll(scroll).padding(start = if (narrow) 20.dp else 44.dp, end = 20.dp, top = 2.dp, bottom = 4.dp),
+        ) {
+            keys.forEachIndexed { i, k ->
+                key(k) {
+                    // A card that arrives after the dock is up (an emulator just installed) opens in.
+                    val state = remember { MutableTransitionState(!mounted[0] || k in seen) }.apply { targetState = true }
+                    LaunchedEffect(Unit) { seen += k }
+                    AnimatedVisibility(state, enter = expandHorizontally(Motion.sp(0.75f)) + fadeIn(Motion.tw(300, 80))) {
+                        Box(if (i == keys.lastIndex) Modifier.onGloballyPositioned { lastAt = it.boundsInRoot() } else Modifier) {
+                            val e = installed.firstOrNull { "emu:${it.id}" == k }
+                            val flatpak = flatpaks.firstOrNull { "flatpak:${it.id}" == k }
+                            val app = apps.firstOrNull { "user:${it.key}" == k }
+                            if (e != null) {
+                                val system = if (e.systemRes != 0) stringResource(e.systemRes) else e.system.replaceFirstChar { c -> c.uppercase() }
+                                DesktopCard(
+                                    k, e.name,
+                                    if (e.id == "retroarch") system else "$system · " + pluralStringResource(R.plurals.mode_added_count, e.games.size, e.games.size),
+                                    art = e.iconRes, first = i == 0,
+                                ) { at -> openFrom(at, e.iconRes, k) }
+                            } else if (flatpak != null) DesktopCard(
+                                k, flatpak.name, flatpak.summary ?: stringResource(R.string.flathub_name),
+                                art = flatpak.icon ?: com.droiddeck.launcher.store.FlathubApi.iconUrl(flatpak.id), first = i == 0,
+                            ) { at ->
+                                // Its page on Flathub: open, update or remove it there.
+                                com.droiddeck.launcher.store.StoreState.openRequest = flatpak.id
+                                openFrom(at, flatpak.icon, "store")
+                            } else if (app != null) DesktopCard(k, app.name, stringResource(app.kind.label()), art = app.icon, fallback = if (app.kind == UserApps.Kind.SCRIPT) Icons.Outlined.Terminal else Icons.Outlined.Apps, first = i == 0) { at ->
+                                openFrom(at, app.icon, k)
+                            }
+                        }
+                    }
+                }
+            }
+            // Between yours and what can be added: a thin rule.
+            if (keys.isNotEmpty()) Box(Modifier.padding(horizontal = 4.dp).width(1.dp).height(120.dp).background(pal.line2))
+            available.forEach { e ->
+                key(e.id) {
+                    val pkg = Library.packageId(e.id)?.let { id -> s.packages?.firstOrNull { it.id == id } }
+                    val busyHere = pkg != null && s.packageBusyId == pkg.id
+                    val canGet = pkg != null && !s.busy && s.packageBusyId == null && s.ready && !s.packageCatalogLoading && !s.sessionRunning
+                    val system = if (e.systemRes != 0) stringResource(e.systemRes) else e.system.replaceFirstChar { c -> c.uppercase() }
+                    DesktopCard(
+                        "emu:${e.id}", e.name, if (busyHere) (s.packageStage ?: stringResource(R.string.store_installing)) else system,
+                        art = e.iconRes, badge = if (busyHere) null else stringResource(R.string.comp_get),
+                        progress = if (busyHere) s.packagePercent else null, first = keys.isEmpty() && e == available.first(),
+                    ) { at ->
+                        // Get installs it there and then, and a dot flies to where its card will be;
+                        // when it cannot (no runtime, a session running), its page says why.
+                        if (canGet && pkg != null && at != null) {
+                            a.onInstallPackage(pkg.id)
+                            val end = lastAt
+                            val row = dockAt
+                            Flights.fly(Flight(at, to = {
+                                val r = row ?: return@Flight null
+                                Offset((end?.right ?: r.left) + 70.dp.toPx(), r.center.y)
+                            }))
+                        } else openFrom(at, e.iconRes, "emu:${e.id}")
+                    }
+                }
+            }
+        }
+        if (UserAppsState.working != null || UserAppsState.lastError != null) {
+            Box(Modifier.padding(start = if (narrow) 20.dp else 44.dp, end = 20.dp, top = 6.dp)) { UserAppsProgressLine() }
+        }
+    }
+}
+
+/**
+ * A square button the big one's height beside it on the hero: an icon in [tint] (the palette's
+ * signal when null). [onClick] gets its bounds, for a page to flood out of.
+ */
+@Composable
+private fun HeroIconButton(icon: androidx.compose.ui.graphics.vector.ImageVector, description: String, tint: Color?, id: String, onClick: (Rect?) -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val pressed by src.collectIsPressedAsState()
+    val scale by animateFloatAsState(if (pressed) 0.95f else if (hot) 1.04f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "heroIcon")
+    val shape = RoundedCornerShape(12.dp)
+    val accent = tint ?: pal.signal
+    var at by remember { mutableStateOf<Rect?>(null) }
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = Modifier.size(56.dp).paneItem("btn:$id").onGloballyPositioned { at = it.boundsInRoot() }
+            .graphicsLayer { scaleX = scale; scaleY = scale }
+            .clip(shape).background(if (hot) accent.copy(alpha = 0.18f) else colors.surface.copy(alpha = 0.92f))
+            .glideBorder(hot, shape, accent, pal.line2)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button) { onClick(at) }
+            .controllerConfirm { onClick(at) }
+            .semantics { contentDescription = description },
+    ) { Icon(icon, null, tint = accent, modifier = Modifier.size(26.dp)) }
+}
+
+/**
+ * The hero's wall: little windows tilted and drifting as Steam's capsules do, each a window with a
+ * bar along its foot and an emulator's or app's icon inside; blank windows when there are none.
+ */
+@Composable
+private fun DesktopWall(icons: List<Any>) {
+    val pal = LocalPalette.current
+    val ground = remember(pal) { Brush.linearGradient(listOf(pal.surfaceVariant, pal.surface)) }
+    TiltedWall(icons.size, if (icons.isEmpty()) 75_000 else 50_000, capW = 132.dp, capH = 84.dp, gap = 14.dp, corner = 8.dp) { i ->
+        WallCapsule(ground, edge = pal.line2, icon = icons.getOrNull(i), bar = pal.background.copy(alpha = 0.7f))
+    }
+}
+
+/**
+ * One thing that runs in the desktop: its icon over a blurred, darkened copy of itself, a status on
+ * the art (Get, or how far an install is), and under it its name on up to two lines and what it
+ * is. [onClick] gets the art's bounds, for a page to flood out of or a dot to fly from.
+ */
+@Composable
+private fun DesktopCard(
+    key: String, name: String, detail: String, art: Any?,
+    fallback: androidx.compose.ui.graphics.vector.ImageVector = Icons.Outlined.Apps,
+    first: Boolean = false, badge: String? = null, progress: Int? = null, accent: Boolean = false, tint: Color? = null,
+    onClick: (Rect?) -> Unit,
+) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val pressed by src.collectIsPressedAsState()
+    val scale by animateFloatAsState(if (pressed) 0.96f else if (hot) 1.03f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "deskCard")
+    val shape = RoundedCornerShape(16.dp)
+    var artAt by remember { mutableStateOf<Rect?>(null) }
+    val width = if (LocalNarrowPane.current) 116.dp else 132.dp
+    val artH = width * 0.62f
+    val ground = tint?.copy(alpha = 0.25f) ?: if (accent) pal.signal.copy(alpha = 0.12f) else colors.surfaceVariant
+    Column(
+        Modifier.width(width).paneItem("tile:desktop:$key").then(if (first) Modifier.firstTile() else Modifier)
+            .graphicsLayer { scaleX = scale; scaleY = scale }
+            .clip(shape).background(if (hot) pal.signal.copy(alpha = 0.10f) else colors.surface)
+            .glideBorder(hot, shape, pal.signal, pal.line)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button) { onClick(artAt) }
+            .controllerConfirm { onClick(artAt) }
+            .semantics { contentDescription = name },
+    ) {
+        Box(
+            contentAlignment = Alignment.Center,
+            modifier = Modifier.fillMaxWidth().height(artH).onGloballyPositioned { artAt = it.boundsInRoot() }
+                .clip(RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp)).background(ground),
+        ) {
+            when (art) {
+                is Int -> {
+                    Image(
+                        painterResource(art), null, contentScale = ContentScale.Crop,
+                        modifier = Modifier.fillMaxSize().graphicsLayer { scaleX = 1.8f; scaleY = 1.8f; alpha = 0.5f }
+                            .then(if (Build.VERSION.SDK_INT >= 31) Modifier.blur(18.dp) else Modifier),
+                    )
+                    Box(Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.35f)))
+                    Image(painterResource(art), null, modifier = Modifier.size(artH * 0.6f))
+                }
+                null -> Icon(fallback, null, tint = tint ?: if (accent) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(artH * 0.42f))
+                else -> {
+                    AsyncImage(
+                        model = art, contentDescription = null, contentScale = ContentScale.Crop,
+                        modifier = Modifier.fillMaxSize().graphicsLayer { scaleX = 1.8f; scaleY = 1.8f; alpha = 0.5f }
+                            .then(if (Build.VERSION.SDK_INT >= 31) Modifier.blur(18.dp) else Modifier),
+                    )
+                    Box(Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.35f)))
+                    AsyncImage(model = art, contentDescription = null, contentScale = ContentScale.Fit, modifier = Modifier.size(artH * 0.6f))
+                }
+            }
+            Box(Modifier.align(Alignment.TopEnd).padding(6.dp)) {
+                if (progress != null) Box(Modifier.clip(RoundedCornerShape(99.dp)).background(Color.Black.copy(alpha = 0.55f)).padding(4.dp)) {
+                    if (progress >= 0) CircularProgressIndicator(progress = { progress / 100f }, strokeWidth = 2.dp, color = pal.signal, trackColor = pal.signal.copy(alpha = 0.25f), modifier = Modifier.size(16.dp))
+                    else CircularProgressIndicator(strokeWidth = 2.dp, color = pal.signal, modifier = Modifier.size(16.dp))
+                }
+                else if (badge != null) Text(
+                    badge, fontSize = 11.sp, fontWeight = FontWeight.Bold, color = pal.onSignal, maxLines = 1,
+                    modifier = Modifier.clip(RoundedCornerShape(99.dp)).background(pal.signal).padding(horizontal = 8.dp, vertical = 2.dp),
+                )
+            }
+        }
+        Column(Modifier.fillMaxWidth().padding(start = 10.dp, end = 10.dp, top = 8.dp, bottom = 10.dp)) {
+            Text(name, fontSize = 13.5.sp, fontWeight = FontWeight.SemiBold, lineHeight = 17.sp, color = colors.onBackground, maxLines = 2, overflow = TextOverflow.Ellipsis)
+            Text(detail, fontSize = 12.sp, lineHeight = 15.sp, color = colors.onSurfaceVariant, minLines = 2, maxLines = 2, overflow = TextOverflow.Ellipsis, modifier = Modifier.padding(top = 3.dp))
+        }
+    }
+}
+
+/**
+ * The desktop sheet's Files chip: the file manager and the ROMs folder (both from Setup's old
+ * tools), how much the desktop takes, and Uninstall - its only home - which asks in red first.
+ */
+@Composable
+private fun DesktopFiles(s: FrontEndState, a: FrontEndActions) {
+    val ctx = LocalContext.current
+    SettingsGroup(stringResource(R.string.setup_tool_files)) {
+        SettingsRow(stringResource(R.string.setup_tool_files), stringResource(R.string.setup_tool_files_hint)) {
+            SecondaryButton(stringResource(R.string.store_open), compact = true, onClick = a.onFiles)
+        }
+        SettingsRow(stringResource(R.string.setup_tool_roms), s.romsDir ?: stringResource(R.string.setup_tool_roms_hint)) {
+            SecondaryButton(stringResource(R.string.setup_choose), compact = true, onClick = a.onRoms)
+        }
+    }
+    if (s.desktopPresent) SettingsGroup(stringResource(R.string.content_linux_desktop)) {
+        val size by produceState<Long?>(null) { value = withContext(Dispatchers.IO) { runCatching { com.droiddeck.launcher.runtime.DesktopCatalog.desktopSize(ctx) }.getOrNull() } }
+        SettingsRow(stringResource(R.string.desktop_size), size?.let { FileUtils.sizeToString(it) } ?: "…") {}
+        SettingsRow(stringResource(R.string.desktop_remove_title), stringResource(R.string.desktop_remove_text)) {
+            UninstallDesktop(enabled = !s.runtimeActionsBlocked, onUninstall = a.onRemoveDesktop)
+        }
+    }
+}
+
+/** Uninstall the desktop: are you sure steps out of it in red, Keep first and focused. */
+@Composable
+private fun UninstallDesktop(enabled: Boolean, onUninstall: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val label = stringResource(R.string.common_uninstall)
+    val title = stringResource(R.string.desktop_uninstall_title)
+    val note = stringResource(R.string.desktop_remove_text)
+    val keep = stringResource(R.string.flathub_keep)
+    var at by remember { mutableStateOf<Rect?>(null) }
+    Box(Modifier.onGloballyPositioned { at = it.boundsInRoot() }) {
+        SecondaryButton(label, enabled = enabled, compact = true) {
+            val from = at ?: return@SecondaryButton
+            Steps.ask(StepAsk(
+                anchor = from, side = StepSide.Left, accent = colors.error, pillCorner = 12.dp, items = 3,
+                handle = { Text(label, fontSize = 12.sp, fontWeight = FontWeight.SemiBold, color = colors.error, maxLines = 1) },
+            ) {
+                StepTitle(title)
+                Text(note, fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.stepItem(1).padding(start = 4.dp, bottom = 12.dp))
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End), modifier = Modifier.fillMaxWidth().stepItem(2)) {
+                    StepChoice(keep, enabled = open, modifier = Modifier.focusRequester(first)) { Steps.fold() }
+                    StepChoice(label, danger = true, enabled = open) { Steps.fold(); onUninstall() }
+                }
+            })
+        }
+    }
+}
+
+/** The add or remove under way, or why the last one failed. */
+@Composable
+private fun UserAppsProgressLine() {
+    val colors = MaterialTheme.colorScheme
+    val working = UserAppsState.working
+    Column(verticalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp)) {
+        if (working != null) {
+            val stage = UserAppsState.stage ?: stringResource(R.string.user_apps_starting)
+            val percent = UserAppsState.percent
+            Text(
+                if (percent >= 0) stringResource(R.string.user_apps_progress_percent, working, stage, percent) else stringResource(R.string.user_apps_progress, working, stage),
+                fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis,
+            )
+            if (percent >= 0) androidx.compose.material3.LinearProgressIndicator(progress = { percent / 100f }, modifier = Modifier.fillMaxWidth().height(4.dp))
+            else androidx.compose.material3.LinearProgressIndicator(modifier = Modifier.fillMaxWidth().height(4.dp))
+        } else UserAppsState.lastError?.let { Note(it) }
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/DriverPage.kt

@@ -3,6 +3,7 @@ package com.droiddeck.launcher.ui
 import com.droiddeck.launcher.R
 import androidx.compose.ui.res.stringResource
 import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.background
 import androidx.compose.foundation.hoverable
 import androidx.compose.foundation.interaction.MutableInteractionSource
@@ -42,6 +43,11 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.input.InputMode
+import androidx.compose.ui.platform.LocalInputModeManager
+import androidx.compose.runtime.snapshotFlow
+import kotlinx.coroutines.flow.first
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
@@ -84,11 +90,19 @@ fun DriverPage(
     // D-pad: up from the first driver lands on refresh; the page opens with the driver in use focused.
     val refreshFocus = remember { FocusRequester() }
     val selectedFocus = remember { FocusRequester() }
-    LaunchedEffect(Unit) { runCatching { selectedFocus.requestFocus() } }
+    val inputMode = LocalInputModeManager.current
+    var pageFocused by remember { mutableStateOf(false) }
+    LaunchedEffect(inputMode.inputMode) {
+        if (inputMode.inputMode != InputMode.Keyboard) return@LaunchedEffect
+        // The chooser holds controller focus until its closing animation finishes.
+        snapshotFlow { Steps.step }.first { it == null }
+        focusWithinFrames({ pageFocused }) { selectedFocus }
+    }
     val refreshSrc = remember { MutableInteractionSource() }
     val refreshHot = refreshSrc.collectIsFocusedAsState().value || refreshSrc.collectIsHoveredAsState().value
     SettingsPage(
         host, title = title, onBack = onBack, lede = "$hint\n$status",
+        modifier = Modifier.onFocusChanged { pageFocused = it.hasFocus }.focusGroup(),
         action = {
             Box(
                 contentAlignment = Alignment.Center,

app/src/main/java/com/droiddeck/launcher/ui/FocusGlide.kt

@@ -3,7 +3,6 @@ package com.droiddeck.launcher.ui
 import android.view.View
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.AnimationSpec
 import androidx.compose.animation.core.FastOutSlowInEasing
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Box
@@ -23,6 +22,7 @@ import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.geometry.CornerRadius
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Rect
@@ -58,6 +58,8 @@ internal class GlideSource {
     var shape: Shape by mutableStateOf<Shape>(androidx.compose.ui.graphics.RectangleShape)
     var color by mutableStateOf(Color.Transparent)
     var width by mutableStateOf(2.dp)
+    /** Focuses the control again: a step-out hands focus back to the control it came out of. */
+    val requester = androidx.compose.ui.focus.FocusRequester()
 }
 
 internal class FocusGlide(val view: View) {
@@ -135,15 +137,18 @@ internal fun Modifier.glideBorder(
         onDispose { glide.release(src) }
     }
     val base = if (restColor.alpha > 0f) border(restWidth, restColor, shape) else this
-    return base.onGloballyPositioned { src.coords = it; glide.moved(src) }
+    return base.focusRequester(src.requester).onGloballyPositioned { src.coords = it; glide.moved(src) }
 }
 
 /** Leading edge on a focus move: quick and a little loose. */
-private fun lead(): AnimationSpec<Float> = Motion.sp(0.62f, 700f)
+/** A spring an edge chases its target on: damping ratio and stiffness, as Compose's. */
+private class Edge(val damping: Float, val stiffness: Float)
+
+private fun lead() = Edge(0.62f, 700f)
 /** Trailing edge: slower, settles without a bounce to speak of. */
-private fun trail(): AnimationSpec<Float> = Motion.sp(0.78f, 360f)
+private fun trail() = Edge(0.78f, 360f)
 /** Following a control that moves under the ring (a scroll): tight, no wobble. */
-private fun follow(): AnimationSpec<Float> = Motion.sp(1f, 2400f)
+private fun follow() = Edge(1f, 2400f)
 
 /** How long after a focus move the ring keeps its stretchy springs and keeps checking where it is. */
 private const val SETTLE_MS = 450L
@@ -152,6 +157,9 @@ private const val STILL_MS = 120L
 /** The longest the ring keeps checking after a move, for a control that never stands still. */
 private const val TRACK_MAX_MS = 2_000L
 
+/** How strongly the ring tints what it holds. */
+private const val RING_FILL = 0.14f
+
 /** Moves closer together than this are a held direction: the ring runs along as one, no stretch. */
 private const val REPEAT_MS = 180L
 
@@ -174,8 +182,16 @@ internal fun FocusGlideHost(modifier: Modifier = Modifier, content: @Composable
     val solid = remember { Animatable(0f) }
     val alpha = remember { Animatable(0f) }
     val scope = rememberCoroutineScope()
-    // An edge each, the corner, and a droplet carrying all of them.
-    val jobs = remember { arrayOfNulls<Job>(6) }
+    // An edge each, the corner, a droplet carrying all of them, its solid fill, and the chase.
+    val jobs = remember { arrayOfNulls<Job>(8) }
+    // The chase: each edge on a spring of its own toward where focus is now. A new target only
+    // moves where it is heading - restarting an animation on every focus move started it from
+    // its first frame (which does not move), so a held direction over a busy page (each rail item
+    // swaps the page) left the ring standing while focus ran on ahead.
+    val target = remember { FloatArray(4) }
+    val vel = remember { FloatArray(4) }
+    val springs = remember { Array(4) { follow() } }
+    val startAt = remember { LongArray(4) }
     val cur = glide.current
     var lastColor by remember { mutableStateOf(Color.Transparent) }
     if (cur != null) lastColor = cur.color
@@ -186,20 +202,53 @@ internal fun FocusGlideHost(modifier: Modifier = Modifier, content: @Composable
     LaunchedEffect(glide, Motion.scale) {
         var shown: GlideSource? = null
         var movedAt = 0L
-        var dirSpecs: List<AnimationSpec<Float>> = List(4) { follow() }
+        var dirSpecs: List<Edge> = List(4) { follow() }
         var delays = LongArray(4)
         var lastMove = 0L
-        fun go(i: Int, v: Float, spec: AnimationSpec<Float>, wait: Long) {
+        fun go(i: Int, v: Float, spec: Edge, wait: Long) {
             // A drop cut short by another move turns back into an outline on the way.
-            if (jobs[5]?.isActive == true || solid.targetValue > 0f) scope.launch { solid.animateTo(0f, Motion.tw(120)) }
-            jobs[5]?.cancel()
-            // Picks up the speed it is going at: restarting from rest on every step of a held
-            // direction is what made it stutter.
-            val speed = edges[i].velocity
-            jobs[i]?.cancel()
-            jobs[i] = scope.launch {
-                if (wait > 0) delay(Motion.ms(wait.toInt()).toLong())
-                edges[i].animateTo(v, spec, initialVelocity = if (wait > 0) 0f else speed)
+            if (jobs[5]?.isActive == true || solid.targetValue > 0f) {
+                jobs[5]?.cancel()
+                jobs[6]?.cancel()
+                jobs[6] = scope.launch { solid.animateTo(0f, Motion.tw(120)) }
+            }
+            val chasing = jobs[7]?.isActive == true
+            // An edge some other animation was moving (the appear, a drop's opening) is taken over
+            // at the speed it was going.
+            jobs[i]?.let { if (it.isActive) { it.cancel(); vel[i] = edges[i].velocity } }
+            if (!chasing) for (j in 0..3) if (jobs[j]?.isActive != true) vel[j] = edges[j].velocity
+            target[i] = v
+            springs[i] = spec
+            startAt[i] = System.nanoTime() + Motion.ms(wait.toInt()) * 1_000_000L
+            if (chasing) return
+            jobs[7] = scope.launch {
+                var last = withFrameNanos { it }
+                while (true) {
+                    val frame = withFrameNanos { it }
+                    // Real time, however long the frame took, in small steps so a stiff spring holds.
+                    val dt = ((frame - last) / 1e9f).coerceAtMost(0.1f) / Motion.scale.coerceAtLeast(0.01f)
+                    last = frame
+                    val now = System.nanoTime()
+                    var settled = true
+                    for (j in 0..3) {
+                        if (now < startAt[j]) { settled = false; continue }
+                        val k = springs[j].stiffness
+                        val c = 2f * springs[j].damping * kotlin.math.sqrt(k)
+                        var x = edges[j].value
+                        var u = vel[j]
+                        var left = dt
+                        while (left > 0f) {
+                            val h = minOf(left, 0.004f)
+                            u += (-k * (x - target[j]) - c * u) * h
+                            x += u * h
+                            left -= h
+                        }
+                        if (abs(x - target[j]) < 0.3f && abs(u) < 3f) { x = target[j]; u = 0f } else settled = false
+                        vel[j] = u
+                        edges[j].snapTo(x)
+                    }
+                    if (settled) break
+                }
             }
         }
         /** Pinch into a solid dot where it is, carry it over, and open it into [b] as it arrives. */
@@ -270,6 +319,8 @@ internal fun FocusGlideHost(modifier: Modifier = Modifier, content: @Composable
                 // Focus passing between two controls can let go of one a moment before the next
                 // takes it: wait a beat, so that reads as a move and not a fade out and back in.
                 delay(60)
+                jobs.forEach { it?.cancel() }
+                solid.snapTo(0f)
                 scope.launch { alpha.animateTo(0f, Motion.tw(140)) }
                 shown = null
                 return@collectLatest
@@ -296,7 +347,7 @@ internal fun FocusGlideHost(modifier: Modifier = Modifier, content: @Composable
                         val grown = listOf(b.left - out, b.top - out, b.right + out, b.bottom + out)
                         jobs.forEach { it?.cancel() }
                         scope.launch { solid.snapTo(0f); edges.forEachIndexed { i, e -> e.snapTo(grown[i]) } }.join()
-                        dirSpecs = List(4) { Motion.sp(0.6f, 700f) }
+                        dirSpecs = List(4) { Edge(0.6f, 700f) }
                         delays = LongArray(4)
                         cornerTo(src, b, snap = true)
                         scope.launch { alpha.animateTo(1f, Motion.tw(140)) }
@@ -315,8 +366,8 @@ internal fun FocusGlideHost(modifier: Modifier = Modifier, content: @Composable
                         if (dropped) droplet(src, b)
                         else {
                             // A held direction runs along as one piece; a single press stretches.
-                            dirSpecs = if (held) List(4) { Motion.sp(0.9f, 900f) }
-                                else List(4) { i -> when (i) { leadIdx -> lead(); trailIdx -> trail(); else -> Motion.sp(0.7f, 520f) } }
+                            dirSpecs = if (held) List(4) { Edge(0.9f, 900f) }
+                                else List(4) { i -> when (i) { leadIdx -> lead(); trailIdx -> trail(); else -> Edge(0.7f, 520f) } }
                             delays = LongArray(4) { i -> if (i == trailIdx && !held) 30L else 0L }
                             cornerTo(src, b, snap = false)
                         }
@@ -359,10 +410,18 @@ internal fun FocusGlideHost(modifier: Modifier = Modifier, content: @Composable
                     color, topLeft = Offset(l, t), size = Size(r - l, b - t),
                     cornerRadius = CornerRadius(corner.value), alpha = a * f,
                 )
-                if (f < 0.99f) drawRoundRect(
-                    color, topLeft = Offset(l + w / 2f, t + w / 2f), size = Size(sw, sh),
-                    cornerRadius = CornerRadius(rad), style = Stroke(w), alpha = a,
-                )
+                if (f < 0.99f) {
+                    // The ring's own infill: the only fill a pad sees, so it is always exactly what
+                    // the ring holds and moves with it (a row's own sliding fill trailed it).
+                    drawRoundRect(
+                        color, topLeft = Offset(l + w / 2f, t + w / 2f), size = Size(sw, sh),
+                        cornerRadius = CornerRadius(rad), alpha = a * (1f - f) * RING_FILL,
+                    )
+                    drawRoundRect(
+                        color, topLeft = Offset(l + w / 2f, t + w / 2f), size = Size(sw, sh),
+                        cornerRadius = CornerRadius(rad), style = Stroke(w), alpha = a,
+                    )
+                }
             },
     ) {
         CompositionLocalProvider(LocalFocusGlide provides glide) { content() }

app/src/main/java/com/droiddeck/launcher/ui/FrontEndArt.kt

@@ -56,9 +56,21 @@ import androidx.compose.ui.unit.sp
 import androidx.compose.ui.zIndex
 import coil.compose.AsyncImage
 import java.io.File
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
 
 // Cover art: posters, the art grid and its tiles.
 
+/** Where each art tile sits, root px, by its key: a page opened from one floods out of it. */
+internal object TileBounds {
+    val at = HashMap<String, androidx.compose.ui.geometry.Rect>()
+
+    /** The page about to open came from tile [key] (its art or icon for the flood), if it is on screen. */
+    fun mark(key: String, art: Any?, corner: Float) {
+        at[key]?.let { PageOrigin.mark(Origin(it, corner, art = art)) }
+    }
+}
+
 internal class Tile(
     val title: String, val sub: String?, val art: File?, val key: String,
     val iconRes: Int? = null, val dim: Boolean = false, val iconBitmap: Bitmap? = null,
@@ -102,6 +114,7 @@ internal fun ArtGrid(tiles: List<Tile>, wide: Boolean = false) {
                         val src = remember { MutableInteractionSource() }
                         val hot = rememberHot(src)
                         val track = Modifier.paneItem("tile:" + t.key).then(if (t === tiles.first()) Modifier.firstTile() else Modifier)
+                            .onGloballyPositioned { TileBounds.at[t.key] = it.boundsInRoot() }
                         Box(modifier = Modifier.width(tileWidth).zIndex(if (hot) 1f else 0f)) { GameTile(t, wide, square, src, hot, track) }
                     }
                 }

app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt

@@ -76,6 +76,8 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.blur
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.layout.boundsInRoot
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
@@ -124,15 +126,30 @@ internal fun Pane(
         val paneAt = remember { arrayOf(Offset.Zero) }
         val livePage by rememberUpdatedState(s.pageKey)
         // Picking another game changes the detail beside the list, not the whole page.
-        val target = if (page != null && s.pageKey != null) s.pageKey else if (selected.startsWith("app:")) "games" else selected
+        val railContent = if (selected.startsWith("app:")) "games" else selected
+        val target = if (page != null && s.pageKey != null) s.pageKey else railContent
         // The game the Games page shows. It must outlive the selection: while the page animates out,
         // drawing it with what is selected now (another rail item) turned it into a copy of that page.
         val gameShown = remember { arrayOf("games") }
         if (selected == "games" || selected.startsWith("app:")) gameShown[0] = selected
+        // What the pane showed before this change: the content a page opened over belongs to it.
+        val before = remember { arrayOf(target) }
         if (page != null && s.pageKey != null) {
             pages[s.pageKey] = page
-            if (s.pageKey !in origins) PageOrigin.take()?.let { origins[s.pageKey] = it.translate(-paneAt[0]) }
+            if (s.pageKey !in origins) PageOrigin.take()?.let { o ->
+                // A hop's page came out of its own rail item, and is that item's content.
+                origins[s.pageKey] = inPane(o.translate(-paneAt[0])).let { if (it.owner == null) it.ownedBy(railContent) else it }
+            }
+        } else if (target != before[0] && target !in origins) {
+            // A section's own page opened from a control in it (an emulator's card, a ROM's) floods
+            // out of that control and belongs to what was showing; a hop's comes out of its rail item.
+            PageOrigin.take()?.let { o -> origins[target] = inPane(o.translate(-paneAt[0])).let { if (it.owner == null) it.ownedBy(before[0]) else it } }
         }
+        before[0] = target
+        val targetNow by rememberUpdatedState(target)
+        // A page leaving through a hop's link is not coming back to its control.
+        val leave = if (Hops.linking) PageLeave.Link else PageLeave.Ordinary
+        LaunchedEffect(target) { Hops.linking = false }
         AnimatedContent(
             targetState = target,
             modifier = Modifier.onGloballyPositioned { paneAt[0] = it.positionInRoot() },
@@ -143,9 +160,14 @@ internal fun Pane(
                         .togetherWith(fadeOut(Motion.tw(320, 80)) + scaleOut(Motion.tw(480), targetScale = 0.95f))
                         .apply { targetContentZIndex = 1f }
                     // Back out of it: the flood draws back into the control as the pane comes forward again.
-                    initialState in origins -> (fadeIn(Motion.tw(300, 100)) + scaleIn(Motion.tw(460, 40), initialScale = 0.95f))
-                        .togetherWith(ExitTransition.None)
-                        .apply { targetContentZIndex = -1f }
+                    initialState in origins && pageExit(origins[initialState]?.owner, targetState, leave) == PageExit.Drain ->
+                        (fadeIn(Motion.tw(300, 100)) + scaleIn(Motion.tw(460, 40), initialScale = 0.95f))
+                            .togetherWith(ExitTransition.None)
+                            .apply { targetContentZIndex = -1f }
+                    // Away to something else: the control is not coming back, so the page sinks with the pane.
+                    initialState in origins -> (fadeIn(Motion.tw(300, 80)) + slideInVertically(Motion.tw(420, 80)) { it / 24 })
+                        .togetherWith(fadeOut(Motion.tw(170)) + scaleOut(Motion.tw(170), targetScale = 0.95f))
+                        .apply { targetContentZIndex = 1f }
                     else -> (fadeIn(Motion.tw(300, 80)) + slideInVertically(Motion.tw(420, 80)) { it / 24 })
                         .togetherWith(fadeOut(Motion.tw(170)) + slideOutVertically(Motion.tw(170)) { -it / 40 })
                         .apply { targetContentZIndex = 1f }
@@ -153,26 +175,51 @@ internal fun Pane(
             },
             label = "pane",
         ) { key ->
-            val shown = if (page != null && key == s.pageKey) page else pages[key]
-            if (shown != null) {
-                DisposableEffect(key) { onDispose { if (key != livePage) { pages.remove(key); origins.remove(key) } } }
+            val drawn = (if (page != null && key == s.pageKey) page else pages[key])
+                ?: { Content(s, if (key == "games") gameShown[0] else key, a, Modifier.fillMaxSize(), onSelect, onAndroidAppClick, onOpenDeveloperOptions, onRequestWirelessAdb) }
+            // A hop leaving this content: it sinks back as the dot leaves it (and comes forward
+            // again, freshly drawn, when the hop is undone).
+            val hopSink by androidx.compose.animation.core.animateFloatAsState(
+                if (Hops.sinking == key) 1f else 0f, Motion.tw(260), label = "hopSink",
+            )
+            val shown: @Composable () -> Unit = {
+                Box(Modifier.fillMaxSize().graphicsLayer { val k = 1f - 0.05f * hopSink; scaleX = k; scaleY = k; alpha = 1f - 0.35f * hopSink }) { drawn() }
+            }
+            run {
+                DisposableEffect(key) { onDispose { if (key != livePage && key != targetNow) { pages.remove(key); origins.remove(key) } } }
                 val from = origins[key]
                 if (from == null) shown()
                 else {
+                    // The control's own picture (a card's art, an emulator's icon) on the tile as it grows.
+                    val art = when (val m = from.art) {
+                        null -> null
+                        is Int -> androidx.compose.ui.res.painterResource(m)
+                        else -> coil.compose.rememberAsyncImagePainter(m)
+                    }
+                    val leaving = transition.targetState == EnterExitState.PostExit
+                    // Settled as the page starts to leave, from what is coming in, not from where it came in.
+                    val drains = remember(leaving) { !leaving || pageExit(from.owner, target, leave) == PageExit.Drain }
                     // Keeps a leaving page on screen while its flood draws back into the control.
                     transition.animateFloat(
-                        transitionSpec = { if (targetState == EnterExitState.PostExit) Motion.tw(PAGE_RETURN_MS) else snap() },
+                        transitionSpec = { if (targetState == EnterExitState.PostExit && drains) Motion.tw(PAGE_RETURN_MS) else snap() },
                         label = "pageReturn",
                     ) { if (it == EnterExitState.PostExit) 1f else 0f }
-                    PageFlood(from, leaving = transition.targetState == EnterExitState.PostExit) { shown() }
+                    PageFlood(from, leaving = leaving, art = art, sinks = !drains) { shown() }
                 }
             }
-            else Content(s, if (key == "games") gameShown[0] else key, a, Modifier.fillMaxSize(), onSelect, onAndroidAppClick, onOpenDeveloperOptions, onRequestWirelessAdb)
         }
       }
     }
 }
 
+/**
+ * An origin left of the pane (a rail item a hop flew to) starts half inside it, at the item's
+ * height: the page swells out of the pane's edge beside the item. Wholly outside, its tile was a
+ * bar that raced across from the far edge.
+ */
+internal fun inPane(o: Origin): Origin =
+    if (o.bounds.right > 0f) o else o.translate(Offset(-o.bounds.right + o.bounds.width / 2f, 0f))
+
 @Composable
 private fun Backdrop(art: File?) {
     val colors = MaterialTheme.colorScheme
@@ -207,6 +254,7 @@ private fun Content(
     val colors = MaterialTheme.colorScheme
     val detailPosterWidth = if (LocalConfiguration.current.screenHeightDp < 600) 72.dp else 120.dp
     val narrow = LocalNarrowPane.current
+    val density = androidx.compose.ui.platform.LocalDensity.current.density
     val padH = if (narrow) 16.dp else 22.dp
     val padV = if (narrow) 12.dp else 18.dp
     // Setup scrolls inside itself, under its tabs.
@@ -226,12 +274,12 @@ private fun Content(
         return
     }
     // The Store scrolls and navigates inside itself (its tabs and an app's page).
-    if (selected == "store" && s.storeEnabled) {
+    if (selected == "store") {
         StorePage(s, a, modifier)
         return
     }
     // Stores (GOG, Epic, Amazon) takes the whole pane: chips, shelves and a game's page inside it.
-    if (selected == "stores" && s.gameStoresEnabled) {
+    if (selected == "stores") {
         StoresPage(s, a, modifier)
         return
     }
@@ -240,6 +288,11 @@ private fun Content(
         GamesPage(s, a, selected, onSelect, modifier)
         return
     }
+    // Desktop is the Steam tab's shape: a hero with its lifted sheet, and shelves under it.
+    if (selected == "desktop") {
+        DesktopPage(s, a, modifier, onSelect)
+        return
+    }
     // Every other page scrolls as one - header, hero and grid - so a short screen reaches the grid
     // instead of showing a sliver of it under a fixed hero. A focused tile scrolls itself into view.
     Column(modifier = modifier.verticalScroll(rememberScrollState()).padding(horizontal = padH, vertical = padV)) {
@@ -260,37 +313,6 @@ private fun Content(
                     })
                 }
             }
-            selected == "desktop" -> {
-                val installed = s.emulators.filter { it.installed }
-                val available = s.emulators.filter { !it.installed }
-                val ctx = LocalContext.current
-                LaunchedEffect(Unit) { UserAppsState.refresh(ctx) }
-                val apps = UserAppsState.items
-                var adding by rememberSaveable { mutableStateOf(false) }
-                Rise(0) {
-                    PageHeader(stringResource(R.string.drawer_desktop)) {
-                        if (s.desktopInstalled) Chip(stringResource(R.string.content_desktop_installed), ok = true) else Chip(stringResource(R.string.content_desktop_first_open), ok = false)
-                    }
-                }
-                Rise(2) { DesktopCard(s, a) }
-                // Add closes the last grid: the installable emulators, or the installed ones once none are left.
-                val ready = installed.map { GridItem.Emu(it) } + apps.map { GridItem.User(it) }
-                val addAfterReady = available.isEmpty()
-                if (ready.isNotEmpty() || addAfterReady) {
-                    Rise(3) { SectionTitle(stringResource(R.string.user_apps_section), ready.size.takeIf { it > 0 }?.toString()) }
-                    Rise(4) {
-                        LauncherGrid(if (addAfterReady) ready + GridItem.Add else ready, first = true, onSelect = onSelect, onAdd = { if (!s.busy) adding = true })
-                    }
-                }
-                if (UserAppsState.working != null || UserAppsState.lastError != null) Rise(5) { UserAppsProgress() }
-                if (!addAfterReady) {
-                    Rise(5) { SectionTitle(stringResource(R.string.content_available), available.size.toString()) }
-                    Rise(6) {
-                        LauncherGrid(available.map { GridItem.Emu(it) } + GridItem.Add, first = ready.isEmpty(), onSelect = onSelect, onAdd = { if (!s.busy) adding = true })
-                    }
-                }
-                if (adding && !s.busy) AddAppDialog(s.ready, onDismiss = { adding = false }) { request, label -> UserAppsState.add(ctx, request, label) }
-            }
             selected.startsWith("user:") -> {
                 val app = UserAppsState.items.firstOrNull { "user:${it.key}" == selected }
                 if (app == null) Note(stringResource(R.string.user_apps_gone)) else UserAppPage(app, s, a, onSelect)
@@ -300,21 +322,26 @@ private fun Content(
                 if (e == null) Note(stringResource(R.string.content_not_installed)) else {
                     val pkgId = Library.packageId(e.id)
                     val pkg = pkgId?.let { id -> s.packages?.firstOrNull { it.id == id } }
-                    Rise(0) {
-                        BackLink(stringResource(R.string.drawer_desktop)) { onSelect("desktop") }
-                    }
+                    // Out of its card on Desktop, with the card's icon; B draws it back in.
                     Rise(1) {
                         Row(
-                            verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp),
-                            modifier = Modifier.padding(top = 12.dp, bottom = 12.dp),
+                            verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(16.dp),
+                            modifier = Modifier.padding(top = 4.dp, bottom = 12.dp),
                         ) {
-                            Image(painterResource(e.iconRes), null, modifier = Modifier.size(52.dp))
+                            Image(painterResource(e.iconRes), null, modifier = Modifier.size(64.dp))
                             Column {
-                                Text(e.name, fontSize = if (narrow) 22.sp else 26.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
+                                Text(e.name, fontSize = if (narrow) 24.sp else 30.sp, fontWeight = FontWeight.Black, color = colors.onBackground)
                                 Text(
                                     systemLabel(e).let { if (e.installed) it else stringResource(R.string.content_not_installed_suffix, it) },
                                     fontSize = 14.sp, color = colors.onSurfaceVariant,
                                 )
+                                if (e.installed) Text(
+                                    listOfNotNull(
+                                        pluralStringResource(R.plurals.mode_added_count, e.games.size, e.games.size).takeIf { e.id != "retroarch" || e.games.isNotEmpty() },
+                                        s.romsDir,
+                                    ).joinToString(" · "),
+                                    fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis,
+                                )
                             }
                         }
                     }
@@ -339,7 +366,24 @@ private fun Content(
                             )
                         }
                         else Rise(5, Modifier.fillMaxWidth()) {
-                            ArtGrid(e.games.mapIndexed { index, g -> Tile(g.name, if (g.art != null) stringResource(R.string.content_rom_installed) else g.hostPath.extension.uppercase().ifEmpty { stringResource(R.string.content_rom_folder) }, g.art, "rom:${e.id}:$index", e.iconRes) { onSelect("rom:${e.id}:$index") } }, wide = e.games.none { it.art != null })
+                            Column {
+                                // RetroArch's games come from many systems: chips filter them, one
+                                // selection gliding between them.
+                                val systems = remember(e.games) { e.games.map { romSystem(it) }.distinct() }
+                                var system by rememberSaveable(e.id) { mutableStateOf<String?>(null) }
+                                if (systems.size > 1) Box(Modifier.padding(top = 10.dp)) {
+                                    val labels = listOf(stringResource(R.string.desktop_all_systems)) + systems
+                                    SheetChips(labels, if (system == null) 0 else systems.indexOf(system) + 1) { i -> system = if (i == 0) null else systems[i - 1] }
+                                }
+                                val shown = e.games.withIndex().filter { system == null || romSystem(it.value) == system }
+                                ArtGrid(shown.map { (index, g) ->
+                                    val key = "rom:${e.id}:$index"
+                                    Tile(g.name, if (g.art != null) stringResource(R.string.content_rom_installed) else g.hostPath.extension.uppercase().ifEmpty { stringResource(R.string.content_rom_folder) }, g.art, key, e.iconRes) {
+                                        TileBounds.mark(key, g.art ?: e.iconRes, 12f * density)
+                                        onSelect(key)
+                                    }
+                                }, wide = e.games.none { it.art != null })
+                            }
                         }
                     } else {
                         if (pkg != null) Rise(2) {
@@ -381,12 +425,7 @@ private fun Content(
                 val pair = romFor(s, selected)
                 if (pair == null) Note(stringResource(R.string.content_rom_gone)) else {
                     val (e, g) = pair
-                    Rise(0) {
-                        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
-                            BackLink(e.name) { onSelect("emu:${e.id}") }
-                            Eyebrow(stringResource(R.string.content_desktop_system, systemLabel(e)))
-                        }
-                    }
+                    Rise(0) { Eyebrow(stringResource(R.string.content_desktop_system, systemLabel(e))) }
                     Rise(1) { Title(g.name) }
                     Rise(2) {
                         Row {
@@ -408,7 +447,10 @@ private fun Content(
                         Rise(4, Modifier.fillMaxWidth()) {
                             ArtGrid(others.map { x ->
                                 val index = e.games.indexOf(x)
-                                Tile(x.name, if (x.art != null) stringResource(R.string.content_rom_installed) else x.hostPath.extension.uppercase().ifEmpty { stringResource(R.string.content_rom_folder) }, x.art, "rom:${e.id}:$index", e.iconRes) { onSelect("rom:${e.id}:$index") }
+                                Tile(x.name, if (x.art != null) stringResource(R.string.content_rom_installed) else x.hostPath.extension.uppercase().ifEmpty { stringResource(R.string.content_rom_folder) }, x.art, "rom:${e.id}:$index", e.iconRes) {
+                                    TileBounds.mark("rom:${e.id}:$index", x.art ?: e.iconRes, 12f * density)
+                                    onSelect("rom:${e.id}:$index")
+                                }
                             }, wide = others.none { it.art != null })
                         }
                     }
@@ -419,122 +461,6 @@ private fun Content(
     }
 }
 
-/** The Linux desktop itself, above the emulators that run in it. */
-@Composable
-private fun DesktopCard(s: FrontEndState, a: FrontEndActions) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    var confirmRemove by rememberSaveable { mutableStateOf(false) }
-    if (confirmRemove) ConfirmDialog(
-        stringResource(R.string.desktop_remove_title), stringResource(R.string.desktop_remove_text),
-        stringResource(R.string.common_uninstall), a.onRemoveDesktop, { confirmRemove = false },
-    )
-    val actions: @Composable () -> Unit = {
-        Actions {
-            // Enabled without a runtime or the desktop: the session's loading screen installs them first.
-            PrimaryButton(if (s.desktopInstalled) stringResource(R.string.content_open_desktop) else stringResource(R.string.content_install_open_desktop), enabled = !s.busy, main = true, onClick = a.onDesktop)
-            Cog(onClick = a.onDesktopSettings)
-            if (s.desktopPresent) SecondaryButton(stringResource(R.string.common_uninstall),
-                enabled = !s.runtimeActionsBlocked) { confirmRemove = true }
-            BusyChip(s)
-        }
-    }
-    // The button goes under the title unless the card is wide enough for both side by side: in some
-    // languages its label alone takes half a small phone's pane.
-    BoxWithConstraints(Modifier.fillMaxWidth()) {
-        val narrow = LocalNarrowPane.current || maxWidth < DesktopCardInlineWidth
-        Column(
-            verticalArrangement = Arrangement.spacedBy(14.dp),
-            modifier = Modifier.fillMaxWidth().clip(Shape16).background(colors.surface).border(1.dp, pal.line, Shape16).padding(16.dp),
-        ) {
-            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp)) {
-                Box(
-                    contentAlignment = Alignment.Center,
-                    modifier = Modifier.size(52.dp).clip(Shape14).background(colors.surfaceVariant).border(1.dp, pal.line2, Shape14),
-                ) { Icon(Icons.Outlined.DesktopWindows, contentDescription = null, tint = colors.onBackground, modifier = Modifier.size(26.dp)) }
-                Column(modifier = Modifier.weight(1f)) {
-                    Text(stringResource(R.string.content_linux_desktop), fontSize = 18.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)
-                    Text(stringResource(R.string.content_linux_desktop_hint), fontSize = 14.sp, color = colors.onSurfaceVariant, maxLines = 2, overflow = TextOverflow.Ellipsis)
-                }
-                if (!narrow) actions()
-            }
-            if (narrow) actions()
-        }
-    }
-}
-
-/** How wide the desktop card must be to keep its button beside the title. */
-private val DesktopCardInlineWidth = 640.dp
-
-/** What the Desktop page's grids hold: emulators, the user's own apps, and Add at the end. */
-private sealed class GridItem(val key: String) {
-    class Emu(val e: Library.Emulator) : GridItem("emu:${e.id}")
-    class User(val app: UserApps.App) : GridItem("user:${app.key}")
-    data object Add : GridItem("add")
-}
-
-/** Wide tiles - three across, two on a small phone, or a list on a narrow page. */
-@Composable
-private fun LauncherGrid(items: List<GridItem>, first: Boolean, onSelect: (String) -> Unit, onAdd: () -> Unit = {}) {
-    BoxWithConstraints(Modifier.fillMaxWidth()) {
-        // A tile holds an icon, a name and an Install button: one much under 230dp wide leaves the
-        // name no room at all.
-        val columns = when {
-            LocalNarrowPane.current -> 1
-            maxWidth < 720.dp -> 2
-            else -> 3
-        }
-        Column(verticalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth().padding(top = 4.dp, bottom = 8.dp)) {
-            items.chunked(columns).forEachIndexed { r, row ->
-                Row(horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min)) {
-                    row.forEachIndexed { i, item ->
-                        key(item.key) {
-                            val m = Modifier.weight(1f).fillMaxHeight()
-                            val isFirst = first && r == 0 && i == 0
-                            when (item) {
-                                is GridItem.Emu -> EmulatorTile(item.e, m, isFirst) { onSelect(item.key) }
-                                is GridItem.User -> UserAppTile(item.app, m, isFirst) { onSelect(item.key) }
-                                GridItem.Add -> AddTile(m, isFirst, onAdd)
-                            }
-                        }
-                    }
-                    repeat(columns - row.size) { Spacer(Modifier.weight(1f)) }
-                }
-            }
-        }
-    }
-}
-
-/** A grid tile's frame: the emulator tiles' look, focus glide and press. */
-@Composable
-private fun TileFrame(id: String, modifier: Modifier, isFirst: Boolean, filled: Boolean, onClick: () -> Unit, content: @Composable RowScope.() -> Unit) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    val src = remember { MutableInteractionSource() }
-    val hot = rememberHot(src)
-    val pressed by src.collectIsPressedAsState()
-    val scale by animateFloatAsState(if (pressed) 0.97f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "tileScale")
-    Row(
-        verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp),
-        modifier = modifier.paneItem("tile:$id").then(if (isFirst) Modifier.firstTile() else Modifier)
-            .graphicsLayer { scaleX = scale; scaleY = scale }
-            .clip(Shape14)
-            .background(if (hot) pal.signal.copy(alpha = 0.10f) else if (filled) colors.surface else Color.Transparent)
-            .glideBorder(hot, Shape14, pal.signal, pal.line)
-            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick)
-            .padding(horizontal = 12.dp, vertical = 10.dp),
-    ) { content() }
-}
-
-@Composable
-private fun TileText(title: String, detail: String, modifier: Modifier) {
-    val colors = MaterialTheme.colorScheme
-    Column(modifier = modifier) {
-        Text(title, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
-        Text(detail, fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
-    }
-}
-
 internal fun UserApps.Kind.label() = when (this) {
     UserApps.Kind.SCRIPT -> R.string.user_apps_kind_script
     UserApps.Kind.APPIMAGE -> R.string.user_apps_kind_appimage
@@ -556,26 +482,6 @@ private fun UserAppIcon(app: UserApps.App, size: Int) {
     }
 }
 
-@Composable
-private fun UserAppTile(app: UserApps.App, modifier: Modifier, isFirst: Boolean, onClick: () -> Unit) =
-    TileFrame("user:${app.key}", modifier, isFirst, filled = true, onClick = onClick) {
-        UserAppIcon(app, 44)
-        TileText(app.name, stringResource(app.kind.label()), Modifier.weight(1f))
-    }
-
-/** The grid's last tile: opens the Add dialog. */
-@Composable
-private fun AddTile(modifier: Modifier, isFirst: Boolean, onClick: () -> Unit) {
-    val pal = LocalPalette.current
-    TileFrame("add", modifier, isFirst, filled = false, onClick = onClick) {
-        Box(
-            contentAlignment = Alignment.Center,
-            modifier = Modifier.size(44.dp).clip(Shape12).background(pal.signal.copy(alpha = 0.12f)).border(1.dp, pal.signal.copy(alpha = 0.35f), Shape12),
-        ) { Icon(Icons.Filled.Add, null, tint = pal.signal, modifier = Modifier.size(24.dp)) }
-        TileText(stringResource(R.string.user_apps_add), stringResource(R.string.user_apps_add_detail), Modifier.weight(1f))
-    }
-}
-
 /** The add or remove under way, or why the last one failed. */
 @Composable
 private fun UserAppsProgress() {
@@ -595,20 +501,17 @@ private fun UserAppsProgress() {
     }
 }
 
-/** An added app's page: open it, change its name and icon, update one added from GitHub, or remove it (pressed twice). */
+/** An added app's page: open it, change its name and icon, update one added from GitHub, or remove it (asked first). */
 @Composable
 private fun UserAppPage(app: UserApps.App, s: FrontEndState, a: FrontEndActions, onSelect: (String) -> Unit) {
     val colors = MaterialTheme.colorScheme
     val ctx = LocalContext.current
     val narrow = LocalNarrowPane.current
-    var confirm by remember(app.key) { mutableStateOf(false) }
     var editing by rememberSaveable(app.key) { mutableStateOf(false) }
     val x86 = (app.arch == "x86_64" || app.arch == "i386") && app.fex != com.droiddeck.launcher.runtime.LinuxFex.OFF
     val fexReady by produceState<Boolean?>(null, app.key, x86, s.sessionRunning) {
         value = if (x86) kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { com.droiddeck.launcher.runtime.LinuxFex.ready(ctx) } else true
     }
-    LaunchedEffect(confirm) { if (confirm) { kotlinx.coroutines.delay(4000); confirm = false } }
-    Rise(0) { BackLink(stringResource(R.string.user_apps_back)) { onSelect("desktop") } }
     Rise(1) {
         Row(
             verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp),
@@ -631,12 +534,8 @@ private fun UserAppPage(app: UserApps.App, s: FrontEndState, a: FrontEndActions,
             BusyChip(s)
             SecondaryButton(stringResource(R.string.user_apps_edit), enabled = UserAppsState.working == null) { editing = true }
             if (app.repo != null) UpdateButton(app, s)
-            SecondaryButton(
-                stringResource(if (confirm) R.string.user_apps_remove_confirm else R.string.user_apps_remove),
-                enabled = !s.busy && !s.sessionRunning && UserAppsState.working == null,
-            ) {
-                if (!confirm) confirm = true
-                else { confirm = false; UserAppsState.remove(ctx, app); onSelect("desktop") }
+            RemoveAppButton(app, enabled = !s.busy && !s.sessionRunning && UserAppsState.working == null) {
+                UserAppsState.remove(ctx, app); onSelect("desktop")
             }
             if (s.sessionRunning) ActionChip(stringResource(R.string.user_apps_stop_session), ok = false)
         }
@@ -657,6 +556,31 @@ private fun UserAppPage(app: UserApps.App, s: FrontEndState, a: FrontEndActions,
     }
 }
 
+/** Remove, which asks first: are you sure steps out of it in red, Keep first and focused. */
+@Composable
+private fun RemoveAppButton(app: UserApps.App, enabled: Boolean, onRemove: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val label = stringResource(R.string.user_apps_remove)
+    val title = stringResource(R.string.flathub_remove_title, app.name)
+    val keep = stringResource(R.string.flathub_keep)
+    var at by remember { mutableStateOf<androidx.compose.ui.geometry.Rect?>(null) }
+    Box(Modifier.onGloballyPositioned { at = it.boundsInRoot() }) {
+        SecondaryButton(label, enabled = enabled) {
+            val from = at ?: return@SecondaryButton
+            Steps.ask(StepAsk(
+                anchor = from, side = StepSide.Right, accent = colors.error, pillCorner = 12.dp, items = 2,
+                handle = { Text(label, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.error, maxLines = 1) },
+            ) {
+                StepTitle(title)
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.stepItem(1)) {
+                    StepChoice(keep, enabled = open, modifier = Modifier.focusRequester(first)) { Steps.fold() }
+                    StepChoice(label, danger = true, enabled = open) { Steps.fold(); onRemove() }
+                }
+            })
+        }
+    }
+}
+
 /** Looks up a newer release of an app added from GitHub, then installs it. */
 @Composable
 private fun UpdateButton(app: UserApps.App, s: FrontEndState) {
@@ -688,21 +612,5 @@ private fun UpdateButton(app: UserApps.App, s: FrontEndState) {
 private fun systemLabel(e: Library.Emulator): String =
     if (e.systemRes != 0) stringResource(e.systemRes) else e.system.replaceFirstChar { it.uppercase() }
 
-@Composable
-private fun EmulatorTile(e: Library.Emulator, modifier: Modifier, isFirst: Boolean, onClick: () -> Unit) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    val system = systemLabel(e)
-    val detail = if (e.installed && e.id != "retroarch") "$system · " + pluralStringResource(R.plurals.mode_added_count, e.games.size, e.games.size) else system
-    TileFrame("emu:${e.id}", modifier, isFirst, filled = e.installed, onClick = onClick) {
-        Image(painterResource(e.iconRes), contentDescription = null, modifier = Modifier.size(if (e.installed) 44.dp else 36.dp))
-        Column(modifier = Modifier.weight(1f)) {
-            Text(e.name, fontSize = if (e.installed) 15.sp else 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
-            Text(detail, fontSize = if (e.installed) 13.sp else 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
-        }
-        if (!e.installed) Text(
-            stringResource(R.string.setup_install), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = pal.signal,
-            modifier = Modifier.clip(RoundedCornerShape(8.dp)).border(1.dp, pal.line2, RoundedCornerShape(8.dp)).padding(horizontal = 10.dp, vertical = 6.dp),
-        )
-    }
-}
+/** The system a ROM belongs to: the folder it sits in under the ROMs folder. */
+private fun romSystem(rom: Library.Rom): String = rom.hostPath.parentFile?.name.orEmpty()

app/src/main/java/com/droiddeck/launcher/ui/FrontEndRail.kt

@@ -77,6 +77,9 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.ui.layout.boundsInParent
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
 import com.droiddeck.launcher.core.PhantomProcessLimit
 
 // The front end's side rail: the page list and the resume entry under it.
@@ -103,27 +106,53 @@ internal fun SideRail(
         modifier = modifier.width(if (iconOnly) 64.dp else 92.dp).background(colors.surface).padding(vertical = if (compact) 8.dp else 12.dp),
     ) {
         // Every section on screen at once: items shrink (to 44dp, still a touch target) before the rail scrolls.
-        val count = 6 + (if (s.storeEnabled) 1 else 0) + (if (s.gameStoresEnabled) 1 else 0) + (if (s.isHomeApp) 1 else 0)
+        val count = 6 + (if (s.gameStoresEnabled) 1 else 0) + (if (s.isHomeApp) 1 else 0)
         BoxWithConstraints(Modifier.weight(1f).fillMaxWidth()) {
         val fit = (maxHeight / count - 4.dp).coerceIn(44.dp, if (iconOnly) 48.dp else if (compact) 52.dp else 60.dp)
+        // A hop in flight moves the selection ahead of the page it is bringing.
+        val shown = Hops.railPreview ?: selected
+        val keys = buildList {
+            add("steam"); add("games")
+            if (s.gameStoresEnabled) add("stores")
+            add("desktop")
+            add("components")
+            if (s.isHomeApp) add("android-apps")
+            add("setup"); add("updates")
+        }
+        // Where each item sits in the column, for the selection that glides between them.
+        val bounds = remember { androidx.compose.runtime.mutableStateMapOf<String, androidx.compose.ui.geometry.Rect>() }
+        val tint = androidx.compose.runtime.rememberUpdatedState(LocalPalette.current.signal)
+        var railAt by remember { mutableStateOf(androidx.compose.ui.geometry.Offset.Zero) }
+        Box(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).onGloballyPositioned { railAt = it.boundsInRoot().topLeft }) {
+        // One selection for the whole rail, under the items: it glides from item to item as the
+        // chips' does, its leading edge first, and a jump of more than one item goes as a drop.
+        if (shown in keys) ChipGlide(keys.indexOf(shown), bounds[shown]?.translate(-railAt), tint, GlideAxis.Vertical, corner = 14.dp, fill = 0.14f, outline = 0f)
         Column(
             horizontalAlignment = Alignment.CenterHorizontally,
             verticalArrangement = Arrangement.spacedBy(4.dp),
-            modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState()),
+            modifier = Modifier.fillMaxWidth(),
         ) {
-            RailItem(stringResource(R.string.rail_steam), Icons.Outlined.SportsEsports, "steam", selected == "steam", compact, iconOnly, fit, onFocus = { onFocusSelect("steam") }) { onSelect("steam") }
+            val place: (String) -> Modifier = { key ->
+                // In root px: an item that comes and goes sits in its own wrapper, not the column.
+                Modifier.onGloballyPositioned {
+                    bounds[key] = it.boundsInRoot()
+                    Hops.railBounds[key] = it.boundsInRoot()
+                }
+            }
+            RailItem(stringResource(R.string.rail_steam), Icons.Outlined.SportsEsports, "steam", shown == "steam", compact, iconOnly, fit, place = place, onFocus = { onFocusSelect("steam") }) { onSelect("steam") }
             // Always there, so the items below it never move; an empty library says how to fill it.
-            RailItem(stringResource(R.string.rail_games), Icons.Outlined.VideoLibrary, "games", selected == "games", compact, iconOnly, fit, onFocus = { onFocusSelect("games") }) { onSelect("games") }
+            RailItem(stringResource(R.string.rail_games), Icons.Outlined.VideoLibrary, "games", shown == "games", compact, iconOnly, fit, place = place, onFocus = { onFocusSelect("games") }) { onSelect("games") }
             // The game stores, right under Games: what they install lands there. Its badge counts
             // the downloads in flight, so a download started here is never out of sight.
-            if (s.gameStoresEnabled) RailItem(stringResource(R.string.rail_stores), Icons.Outlined.LocalMall, "stores", selected == "stores", compact, iconOnly, fit, count = s.storeDownloadsActive, onFocus = { onFocusSelect("stores") }) { onSelect("stores") }
-            RailItem(stringResource(R.string.rail_desktop), Icons.Outlined.DesktopWindows, "desktop", selected == "desktop", compact, iconOnly, fit, onFocus = { onFocusSelect("desktop") }) { onSelect("desktop") }
-            if (s.storeEnabled) RailItem(stringResource(R.string.rail_store), Icons.Outlined.Storefront, "store", selected == "store", compact, iconOnly, fit, onFocus = { onFocusSelect("store") }) { onSelect("store") }
-            RailItem(stringResource(R.string.rail_components), Icons.Outlined.Layers, "components", selected == "components", compact, iconOnly, fit, onFocus = { onFocusSelect("components") }) { onSelect("components") }
+            // A section switched on in Setup comes in as the rail's own entrance; off, it folds away.
+            if (s.gameStoresEnabled) RailItem(stringResource(R.string.rail_stores), Icons.Outlined.LocalMall, "stores", shown == "stores", compact, iconOnly, fit, count = s.storeDownloadsActive, place = place, onFocus = { onFocusSelect("stores") }) { onSelect("stores") }
+            RailItem(stringResource(R.string.rail_desktop), Icons.Outlined.DesktopWindows, "desktop", shown == "desktop", compact, iconOnly, fit, place = place, onFocus = { onFocusSelect("desktop") }) { onSelect("desktop") }
+            RailItem(stringResource(R.string.rail_components), Icons.Outlined.Layers, "components", shown == "components", compact, iconOnly, fit, place = place, onFocus = { onFocusSelect("components") }) { onSelect("components") }
             // Home mode's extra section goes last, so it shifts nothing above it.
-            if (s.isHomeApp) RailItem(stringResource(R.string.rail_apps), Icons.Outlined.Apps, "android-apps", selected == "android-apps", compact, iconOnly, fit, onFocus = { onFocusSelect("android-apps") }) { onSelect("android-apps") }
-            RailItem(stringResource(R.string.rail_setup), Icons.Outlined.Tune, "setup", selected == "setup", compact, iconOnly, fit, badge = setupNeedsAttention, onFocus = { onFocusSelect("setup") }) { onSelect("setup") }
-            RailItem(stringResource(R.string.rail_updates), Icons.Outlined.SystemUpdate, "updates", selected == "updates", compact, iconOnly, fit, badge = s.updates.hasUpdate, onFocus = { onFocusSelect("updates") }) { onSelect("updates") }
+            if (s.isHomeApp) RailItem(stringResource(R.string.rail_apps), Icons.Outlined.Apps, "android-apps", shown == "android-apps", compact, iconOnly, fit, place = place, onFocus = { onFocusSelect("android-apps") }) { onSelect("android-apps") }
+            RailItem(stringResource(R.string.rail_setup), Icons.Outlined.Tune, "setup", shown == "setup", compact, iconOnly, fit, badge = setupNeedsAttention, place = place, onFocus = { onFocusSelect("setup") }) { onSelect("setup") }
+            RailItem(stringResource(R.string.rail_updates), Icons.Outlined.SystemUpdate, "updates", shown == "updates", compact, iconOnly, fit, badge = s.updates.hasUpdate, place = place, onFocus = { onFocusSelect("updates") }) { onSelect("updates") }
+        }
         }
         }
         var lastRunning by remember { mutableStateOf("") }
@@ -142,6 +171,8 @@ private fun RailItem(
     badge: Boolean = false,
     /** A number on the item (downloads in flight); 0 shows nothing. */
     count: Int = 0,
+    /** Reports where the item sits, for the rail's gliding selection and a hop's dot. */
+    place: (String) -> Modifier = { Modifier },
     onFocus: () -> Unit = {}, onClick: () -> Unit,
 ) {
     val colors = MaterialTheme.colorScheme
@@ -162,8 +193,9 @@ private fun RailItem(
         if (current) pal.signal else if (focused || hovered) colors.onBackground else colors.onSurfaceVariant,
         Motion.tw(220), label = "railFg",
     )
+    // The selected look is the rail's glide under the item, so the item draws only hover here.
     val fill by animateColorAsState(
-        if (current) pal.signal.copy(alpha = 0.14f) else if (focused || hovered) Color.White.copy(alpha = 0.05f) else Color.Transparent,
+        if (current) Color.Transparent else if (focused || hovered) Color.White.copy(alpha = 0.05f) else Color.Transparent,
         Motion.tw(220), label = "railFill",
     )
     val scale by animateFloatAsState(if (pressed) 0.95f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "railScale")
@@ -172,6 +204,9 @@ private fun RailItem(
         modifier = Modifier
             .then(if (frontFocus != null) Modifier.focusRequester(frontFocus.railFor(key)) else Modifier)
             .testTag("rail-$key")
+            .then(place(key))
+            // Pops as a hop's dot lands on it.
+            .landingPop(Hops.railLanded[key] ?: 0)
             .graphicsLayer { scaleX = scale; scaleY = scale }
             .size(width = if (iconOnly) 52.dp else 80.dp, height = height)
             .clip(Shape14)

app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt

@@ -70,6 +70,8 @@ import androidx.compose.ui.platform.LocalInputModeManager
 import androidx.compose.ui.input.InputMode
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInRoot
 import com.droiddeck.launcher.HomeApp
 import com.droiddeck.launcher.frontend.Library
 import com.droiddeck.launcher.gpu.FrameGen
@@ -132,10 +134,7 @@ class FrontEndState(
     val orientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE,
     val launcherFullscreen: Boolean = true,
     val animationsEnabled: Boolean = true,
-    /** The Flathub Store, a beta the user turns on in Setup. */
-    val storeEnabled: Boolean = false,
-    /** The Stores section (GOG, Epic Games, Amazon Games), turned on in Setup. */
-    val gameStoresEnabled: Boolean = false,
+    val gameStoresEnabled: Boolean = true,
     /** Setup › Stores: the download engine's speed tier (stores/download/StoreDownloadTier ids). */
     val gameStoresSpeedTier: String = "fast",
     /** Setup › Stores: the tab a signed-in store opens on (SessionPrefs.STORES_OPEN_LIBRARY / STORE). */
@@ -178,8 +177,12 @@ class FrontEndActions(
     val onUserApp: (com.droiddeck.launcher.runtime.UserApps.App) -> Unit = {},
     val onRom: (Library.Rom) -> Unit,
     val onResume: () -> Unit,
+    /** Reads Steam's session settings for its lifted sheet (under Play). */
     val onSteamSettings: () -> Unit,
+    /** Reads the desktop's session settings for its lifted sheet (under Open desktop). */
     val onDesktopSettings: () -> Unit,
+    /** A lifted sheet's rows for one tab of [mode]'s settings, as last read. */
+    val modeSheet: @Composable (mode: String, tab: String, extras: SheetExtras) -> Unit = { _, _, _ -> },
     val onRemoveDesktop: () -> Unit = {},
     val onInstallPackage: (String) -> Unit,
     val onRemovePackage: (String) -> Unit,
@@ -189,6 +192,8 @@ class FrontEndActions(
     val onProtons: () -> Unit,
     /** The Components page: FEX / DXVK / VKD3D-Proton per Proton. */
     val onComponents: (focusContent: Boolean) -> Unit,
+    /** The Components page on one layer ([GPU_TAB], a component id): a hop's destination. */
+    val onComponentsTab: (String) -> Unit = {},
     /** A game page's Manage saves: import a save zip into this game, or export its saves in a layout. */
     val onSaveImport: (Library.SteamGame) -> Unit = {},
     val onSaveExport: (Library.SteamGame, com.droiddeck.launcher.session.GameSaves.Layout) -> Unit = { _, _ -> },
@@ -208,7 +213,6 @@ class FrontEndActions(
     val onOrientation: (Int) -> Unit = {},
     val onLauncherFullscreen: (Boolean) -> Unit = {},
     val onAnimationsEnabled: (Boolean) -> Unit = {},
-    val onStoreEnabled: (Boolean) -> Unit = {},
     val onGameStoresEnabled: (Boolean) -> Unit = {},
     val onGameStoresSpeedTier: (String) -> Unit = {},
     val onStoresOpenTab: (String) -> Unit = {},
@@ -337,6 +341,8 @@ internal class FrontFocus {
 /** Down from this button goes to the first tile of the page's grid, when there is one. */
 @Composable
 internal fun Modifier.downToFirstTile(): Modifier {
+    // Sheet rows walk their settings; Desktop's dock stays composed behind the sheet.
+    if (LocalSheetBeat.current != null) return this
     val ff = LocalFrontFocus.current ?: return this
     return this.focusProperties { down = if (ff.firstTileAttached > 0) ff.firstTile else FocusRequester.Default }
 }
@@ -382,6 +388,18 @@ internal suspend fun focusWithinFrames(done: () -> Boolean, target: () -> FocusR
     }
 }
 
+/**
+ * Asks [target] for focus on the next frames until a request lands (a control can take focus only
+ * once it is laid out), for at most half a second; then leaves focus alone, so a press right after
+ * is never pulled back.
+ */
+internal suspend fun focusSoon(target: () -> FocusRequester) {
+    repeat(30) {
+        androidx.compose.runtime.withFrameNanos { }
+        if (runCatching { target().requestFocus() }.isSuccess) return
+    }
+}
+
 @Composable
 fun FrontEndScreen(s: FrontEndState, a: FrontEndActions, page: (@Composable () -> Unit)? = null) {
     val frontFocus = remember { FrontFocus() }
@@ -423,19 +441,27 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
             }
         }
     }
-    BackHandler(enabled = !processSettingsPageVisible && s.pageKey != null && page != null) { a.onPageBack() }
-    // Back (and B) from a ROM, an emulator or an added app steps out one level, as its "‹" link
-    // does, instead of leaving the app: a ROM -> its emulator, the others -> Desktop.
+    // A page reached by a hop goes back the way it came; any other page just closes.
+    val pageBack = { if (!Hops.back(a.onPageBack)) a.onPageBack() }
+    BackHandler(enabled = !processSettingsPageVisible && s.pageKey != null && page != null) { pageBack() }
+    // Left any other way, the hop's page has no way back to keep.
+    LaunchedEffect(s.pageKey, selected) { Hops.forget(s.pageKey ?: selected) }
+    // A section reached by a hop (Desktop's Flathub card to the Store) goes back the way it came.
+    BackHandler(enabled = !processSettingsPageVisible && s.pageKey == null && Hops.origin?.page == selected) {
+        val rail = Hops.origin?.rail ?: return@BackHandler
+        Hops.back { selected = rail }
+    }
+    val density = androidx.compose.ui.platform.LocalDensity.current.density
+    remember(density) { Hops.density = density; true }
+    // Back (and B) from a ROM, an emulator, an added app or Flathub steps out one level instead
+    // of leaving the app: a ROM -> its emulator, the others -> Desktop.
     BackHandler(
         enabled = !processSettingsPageVisible && (s.pageKey == null || page == null) &&
-            (selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:")),
+            (selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:") || selected == "store"),
     ) {
         selected = if (selected.startsWith("rom:")) "emu:" + selected.removePrefix("rom:").substringBefore(':') else "desktop"
     }
     LaunchedEffect(s.isHomeApp) { if (!s.isHomeApp && selected == "android-apps") selected = "steam" }
-    // The Store turned off in Setup takes its page with it; so does Stores.
-    LaunchedEffect(s.storeEnabled) { if (!s.storeEnabled && selected == "store") selected = "steam" }
-    LaunchedEffect(s.gameStoresEnabled) { if (!s.gameStoresEnabled && selected == "stores") selected = "games" }
     // The last game uninstalled leaves the Games tab on its empty state.
     LaunchedEffect(s.steamGames.isEmpty()) {
         if (s.steamGames.isEmpty() && selected.startsWith("app:")) selected = "games"
@@ -443,11 +469,14 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
     remember { Motion.refresh(ctx); true }
 
     val railSelection = when {
-        s.pageKey == "performance" || s.pageKey == "protons" || s.pageKey == "controller-mapping" -> "setup"
-        s.pageKey?.startsWith("settings:steam") == true -> "steam"
-        s.pageKey?.startsWith("settings:") == true -> "desktop"
+        // A hop's page belongs to the rail item it flew to.
+        Hops.origin != null && s.pageKey == Hops.origin?.page -> Hops.origin!!.dest
+        // Performance opens from Play's sheet, and is Steam's.
+        s.pageKey == "performance" -> "steam"
+        s.pageKey == "controller-mapping" -> "setup"
         selected.startsWith("app:") -> "games"
-        selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:") -> "desktop"
+        // Flathub is a page of Desktop's, as an emulator's is.
+        selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:") || selected == "store" -> "desktop"
         else -> s.pageKey ?: selected
     }
     // Bumped each time a rail item is picked, so a controller moves on into the new page.
@@ -458,6 +487,10 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
         if (key == "components") a.onComponents(focusContent)
         else {
             if (s.pageKey != null) a.onPageBack()
+            // Another section: no way back to keep, and no sheet to put back.
+            Hops.origin = null
+            Hops.restore = null
+            Hops.sinking = null
             selected = key
         }
     }
@@ -470,6 +503,7 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
     }
     val inputModeManager = LocalInputModeManager.current
     val window = LocalWindowInfo.current
+    val androidContext = androidx.compose.ui.platform.LocalContext.current
     var anyFocused by remember { mutableStateOf(false) }
     Box(
         modifier = Modifier.fillMaxSize().background(colors.background)
@@ -501,7 +535,15 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
             if (processSettingsPageVisible) return@LaunchedEffect
             // Past the old page's exit (170ms), then the first frame the new page takes focus.
             kotlinx.coroutines.delay(Motion.ms(PAGE_EXIT_MS).toLong())
-            if (anyFocused || inputModeManager.inputMode != InputMode.Keyboard) return@LaunchedEffect
+            if (inputModeManager.inputMode != InputMode.Keyboard) return@LaunchedEffect
+            if (s.pageKey == "performance") {
+                val back = "back:${androidContext.getString(R.string.mode_back)}"
+                focusWithinFrames({ frontFocus.last == back && anyFocused && frontFocus.focusedRail == null }) {
+                    frontFocus.items[back] ?: FocusRequester.Default
+                }
+                return@LaunchedEffect
+            }
+            if (anyFocused) return@LaunchedEffect
             focusWithinFrames({ anyFocused }) { if (frontFocus.primaryAttached > 0) frontFocus.primary else frontFocus.railFor(railSelection) }
         }
         // A rail item picked with a controller moves on into its page, once the page is in.
@@ -519,7 +561,22 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
         val railFocus = Modifier
             .focusProperties { enter = { frontFocus.railFor(railSelection) } }
             .focusGroup()
-        Row(modifier = Modifier.fillMaxSize()) {
+        // Back from a hop onto a surface that is not a sheet (a game's Components card, Desktop's
+        // Flathub card): focus
+        // goes back to the control that asked, once the page has gone.
+        LaunchedEffect(Hops.restore) {
+            val r = Hops.restore ?: return@LaunchedEffect
+            if (r.surface == HOP_SURFACE_SHEET) return@LaunchedEffect
+            Hops.restore = null
+            if (r.rail != selected && !(r.rail == "games" && selected.startsWith("app:"))) selected = r.rail
+            kotlinx.coroutines.delay(Motion.ms(PAGE_EXIT_MS).toLong())
+            if (inputModeManager.inputMode != InputMode.Keyboard) return@LaunchedEffect
+            frontFocus.last = r.control
+            focusWithinFrames({ frontFocus.last == r.control && anyFocused }) { frontFocus.items[r.control] ?: frontFocus.paneEntry() }
+        }
+        var screenAt by remember { mutableStateOf(Offset.Zero) }
+        CompositionLocalProvider(LocalShowSection provides { key -> selected = key }) {
+        Row(modifier = Modifier.fillMaxSize().onGloballyPositioned { screenAt = it.positionInRoot() }) {
             SideRail(s, railSelection, onRailSelect, onRailFocus, a, railFocus.fillMaxHeight())
             Box(Modifier.width(1.dp).fillMaxHeight().background(pal.line))
             Column(modifier = Modifier.weight(1f).fillMaxHeight()) {
@@ -535,6 +592,12 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
             }
         }
 
+        }
+        // Dots on their way somewhere: a hop to another section and back, a swap flying home.
+        FlightsLayer(screenAt)
+        // A confirm stepping out of the control that asked for it.
+        StepsLayer(screenAt)
+
         appToChooseDisplay?.let { app ->
             val secondaryDisplay = s.secondScreenDisplays.firstOrNull()
             ChooseAppDisplayDialog(
@@ -597,8 +660,10 @@ private fun FrontEndScreenBody(s: FrontEndState, a: FrontEndActions, page: (@Com
         }
     }
     val hasBackTarget = (s.pageKey != null && page != null) ||
+        // A section reached by a hop goes back to where it came from, not to the rail.
+        (s.pageKey == null && Hops.origin?.page == selected) ||
         ((s.pageKey == null || page == null) &&
-            (selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:")))
+            (selected.startsWith("emu:") || selected.startsWith("rom:") || selected.startsWith("user:") || selected == "store"))
     // At the top of a section, Back goes to the rail - the launcher itself is never backed out of.
     BackHandler(enabled = !processSettingsPageVisible && !hasBackTarget) {
         if (inputModeManager.inputMode != InputMode.Keyboard) inputModeManager.requestInputMode(InputMode.Keyboard)

app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt

@@ -71,6 +71,8 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
 import com.droiddeck.launcher.core.AppLanguage
 import com.droiddeck.launcher.core.DeviceSupport
 import com.droiddeck.launcher.core.PhantomProcessLimit
@@ -166,21 +168,26 @@ internal fun SetupPanel(
     var showLimitDetails by rememberSaveable { mutableStateOf(false) }
     var editSgdbKey by remember { mutableStateOf(false) }
     if (editSgdbKey) SgdbKeyDialog(s.sgdbUserKey, onSave = { a.onSgdbKey(it); editSgdbKey = false }, onDismiss = { editSgdbKey = false })
-    // Four tabs instead of one long scroll; LB and RB turn them from anywhere on the page. Build
-    // and credits are on the Updates page.
-    val tabs = listOf(stringResource(R.string.setup_tab_overview), stringResource(R.string.setup_tab_controller), stringResource(R.string.setup_tab_session), stringResource(R.string.setup_tab_launcher))
+    // Four tabs by scope, a chip row with one gliding selection; LB and RB turn them from
+    // anywhere on the page. Build and credits are on the Updates page.
+    val tabs = listOf(stringResource(R.string.setup_tab_overview), stringResource(R.string.setup_tab_controller), stringResource(R.string.setup_tab_launcher), stringResource(R.string.setup_tab_diagnostics))
     var tab by rememberSaveable { mutableStateOf(0) }
-    val tabFocus = remember { List(tabs.size) { FocusRequester() } }
+    val chipFocus = remember { List(4) { FocusRequester() } }
     var tabTurned by remember { mutableStateOf(false) }
     val pick: (Int) -> Unit = { i -> tab = i; tabTurned = true }
     val inputModeManager = LocalInputModeManager.current
-    // The control a controller was on went with the old tab: it lands on the new tab itself.
+    // The control a controller was on went with the old tab: it lands on the new tab's chip.
     LaunchedEffect(tab) {
         if (tabTurned && inputModeManager.inputMode == InputMode.Keyboard) {
             androidx.compose.runtime.withFrameNanos { }
-            runCatching { tabFocus[tab].requestFocus() }
+            runCatching { chipFocus[tab].requestFocus() }
         }
     }
+    val wide = !LocalNarrowPane.current
+    val runtimeOk = s.ready && !s.busy && !s.removalPending
+    val checks = listOf(gpuOk, runtimeOk, !limitBlocks, signedIn)
+    val passing = checks.count { it }
+    var showChecks by rememberSaveable { mutableStateOf(false) }
     Rise(0, Modifier.fillMaxSize()) {
         Column(
             modifier = Modifier.fillMaxSize().bumpers(
@@ -189,15 +196,12 @@ internal fun SetupPanel(
             ),
         ) {
             PageHeader(stringResource(R.string.setup_title)) {
-                TabStrip(tabs, tab, pick, Modifier.weight(1f), tabFocus)
+                Box(Modifier.weight(1f)) { SheetChips(tabs, tab, chipFocus, pick) }
             }
             Column(modifier = Modifier.weight(1f).fillMaxWidth().verticalScroll(rememberScrollState()).padding(bottom = 24.dp)) {
                 when (tab) {
                     0 -> {
-                        SectionTitle(stringResource(R.string.setup_system_check), null)
-                        // What Steam needs, one row each: green when done, one button when not. The
-                        // process-limit controls only open under their row.
-                        Column(modifier = Modifier.fillMaxWidth().clip(Shape14).background(colors.surface).border(1.dp, pal.line, Shape14)) {
+                        val gpuCheck: @Composable (Boolean) -> Unit = { divider ->
                             CheckRow(
                                 if (gpuOk) CheckState.OK else CheckState.WARN,
                                 when (gpu.support) {
@@ -210,7 +214,10 @@ internal fun SetupPanel(
                                     com.droiddeck.launcher.gpu.GpuInfo.Support.UNTESTED -> stringResource(R.string.setup_gpu_untested_detail, gpu.displayName(ctx), gpu.supportText(ctx).replaceFirstChar { it.lowercase() })
                                     else -> stringResource(R.string.setup_gpu_unsupported_detail, gpuName)
                                 },
+                                divider = divider,
                             )
+                        }
+                        val runtimeCheck: @Composable (Boolean) -> Unit = { divider ->
                             CheckRow(
                                 when { s.busy -> CheckState.BUSY; !s.ready -> CheckState.WARN; else -> CheckState.OK },
                                 stringResource(R.string.setup_runtime),
@@ -221,7 +228,7 @@ internal fun SetupPanel(
                                     s.available != null && s.available != s.installed -> stringResource(R.string.setup_runtime_update, s.installed ?: stringResource(R.string.setup_installed))
                                     else -> stringResource(R.string.setup_runtime_current, s.installed ?: stringResource(R.string.setup_installed))
                                 },
-                                divider = !s.busy,
+                                divider = divider && !s.busy,
                             ) { SecondaryButton(runtime, enabled = !s.busy && !s.runtimeActionsBlocked && !s.sessionRunning, compact = true, onClick = a.onRuntime) }
                             if (s.busy) {
                                 Column(modifier = Modifier.fillMaxWidth().padding(start = 12.dp, end = 12.dp, bottom = 10.dp)) {
@@ -232,8 +239,10 @@ internal fun SetupPanel(
                                     if (s.percent >= 0) LinearProgressIndicator(progress = { s.percent / 100f }, modifier = Modifier.fillMaxWidth().height(4.dp))
                                     else LinearProgressIndicator(modifier = Modifier.fillMaxWidth().height(4.dp))
                                 }
-                                Box(Modifier.fillMaxWidth().height(1.dp).background(pal.line))
+                                if (divider) Box(Modifier.fillMaxWidth().height(1.dp).background(pal.line))
                             }
+                        }
+                        val limitCheck: @Composable (Boolean) -> Unit = { divider ->
                             CheckRow(
                                 if (limitBlocks) CheckState.WARN else CheckState.OK,
                                 stringResource(R.string.setup_limit),
@@ -243,6 +252,7 @@ internal fun SetupPanel(
                                     PhantomProcessStatus.UNREADABLE -> stringResource(R.string.setup_limit_unknown)
                                     else -> PhantomProcessLimit.title(ctx, s.phantomProcessStatus)
                                 },
+                                divider = divider && !showLimitDetails,
                             ) {
                                 if (limitBlocks) PrimaryButton(if (showLimitDetails) stringResource(R.string.common_hide) else stringResource(R.string.setup_fix_it), compact = true) { showLimitDetails = !showLimitDetails }
                                 else if (s.phantomProcessStatus != PhantomProcessStatus.NOT_APPLICABLE) {
@@ -271,6 +281,9 @@ internal fun SetupPanel(
                                     processLimitMessage?.let { Text(it, fontSize = 14.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(vertical = 4.dp)) }
                                 }
                             }
+                            if (divider && showLimitDetails) Box(Modifier.fillMaxWidth().height(1.dp).background(pal.line))
+                        }
+                        val accountCheck: @Composable (Boolean) -> Unit = { divider ->
                             CheckRow(
                                 if (signedIn) CheckState.OK else CheckState.WARN,
                                 stringResource(R.string.setup_account),
@@ -281,11 +294,34 @@ internal fun SetupPanel(
                                         else -> stringResource(R.string.setup_signed_in, it)
                                     }
                                 } ?: stringResource(R.string.setup_sign_in),
-                                divider = false,
+                                divider = divider,
                             )
                         }
-                        SectionTitle(stringResource(R.string.setup_tools), null)
-                        ToolGrid(s, a)
+                        val all = listOf(gpuCheck, runtimeCheck, limitCheck, accountCheck)
+                        // Everything passes: one line says so, and Details opens the checks in place.
+                        ReadinessCard(
+                            passing, checks.size,
+                            listOfNotNull(
+                                gpu.displayName(ctx),
+                                s.installed?.let { stringResource(R.string.setup_ready_runtime, it) },
+                                stringResource(R.string.setup_ready_limit_off).takeIf { !limitBlocks },
+                                s.offlineAccount?.takeIf { it.isNotEmpty() }?.let { stringResource(R.string.setup_ready_signed_in, it) },
+                            ).joinToString(" · "),
+                            open = showChecks, onDetails = { showChecks = !showChecks },
+                        ) {
+                            val shownChecks = all.filterIndexed { i, _ -> checks[i] }
+                            shownChecks.forEachIndexed { i, check -> check(i < shownChecks.lastIndex) }
+                        }
+                        // Each check that warns is its own card, its Fix it as it always was.
+                        if (passing < checks.size) {
+                            SectionTitle(stringResource(R.string.setup_needs_you), null)
+                            Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {
+                                all.forEachIndexed { i, check ->
+                                    if (!checks[i]) Column(Modifier.fillMaxWidth().clip(Shape14).background(colors.surface).border(1.dp, AttentionAmber.copy(alpha = 0.5f), Shape14)) { check(false) }
+                                }
+                            }
+                        }
+                        SettingsGroup(stringResource(R.string.setup_runtime)) { runtimeCheck(false) }
                     }
                     1 -> {
                         val controller = s.controller
@@ -295,110 +331,80 @@ internal fun SetupPanel(
                         if (s.controller == null || a.controller == null) Note(stringResource(R.string.setup_controller_unavailable))
                     }
                     2 -> {
-                        SettingsGroup(stringResource(R.string.setup_session)) {
-                            ChoiceRow(
-                                host, "back-actions", stringResource(R.string.mode_back), stringResource(SessionPrefs.backActionsOrder(s.backActionsInverted)),
-                                listOf(
-                                    false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM),
-                                    true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU),
-                                ), s.backActionsInverted, onPick = a.onBackActionsInverted,
-                            )
-                            SettingsRow(stringResource(R.string.frame_gen_title), stringResource(R.string.frame_gen_hint)) {
-                                Box {
-                                    ValueChip(s.frameGenLabel, host.open == "fg") { host.open = if (host.open == "fg") null else "fg" }
-                                    FrameGenMenu(s, a, host)
+                        val look: @Composable () -> Unit = {
+                            SettingsGroup(stringResource(R.string.setup_group_look)) {
+                                SettingsRow(stringResource(R.string.setup_theme), stringResource(R.string.setup_theme_hint)) {
+                                    Box {
+                                        ValueChip(stringResource(Themes.byId(s.theme).label), host.open == "theme") { host.open = if (host.open == "theme") null else "theme" }
+                                        AnchoredMenu(host.open == "theme", onDismiss = { if (host.open == "theme") host.open = null }, title = stringResource(R.string.setup_theme)) { firstItemFocus ->
+                                            Themes.all.forEachIndexed { index, theme ->
+                                                MenuItem(stringResource(theme.label), checked = s.theme == theme.id, focusRequester = if (index == 0) firstItemFocus else null) {
+                                                    a.onTheme(theme.id)
+                                                    host.open = null
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
+                                ChoiceRow(
+                                    host, "app-scale", stringResource(R.string.setup_app_scale), stringResource(R.string.setup_app_scale_hint),
+                                    com.droiddeck.launcher.core.AppUiPrefs.scales.map { percent ->
+                                        percent to stringResource(
+                                            if (percent == com.droiddeck.launcher.core.AppUiPrefs.DEFAULT_SCALE) R.string.setup_app_scale_default
+                                            else R.string.ctrl_percent, percent,
+                                        )
+                                    }, s.appScale, onPick = a.onAppScale,
+                                )
+                                ToggleRow(host, "launcher-animations", stringResource(R.string.setup_animations), null,
+                                    s.animationsEnabled, onChange = a.onAnimationsEnabled)
+                                LanguageRow(host, s.language, a.onLanguage)
+                                ToggleRow(host, "show-stores", stringResource(R.string.setup_stores), null, s.gameStoresEnabled, onChange = a.onGameStoresEnabled)
                             }
+                        }
+                        val device: @Composable () -> Unit = {
+                            SettingsGroup(stringResource(R.string.setup_group_device)) {
+                                ToggleRow(
+                                    host, "home-screen", stringResource(R.string.setup_home),
+                                    if (s.homeScreenEnabled) stringResource(R.string.setup_home_on) else stringResource(R.string.setup_home_off),
+                                    s.homeScreenEnabled,
+                                ) { a.onHomeScreen(it) }
+                                if (s.homeScreenEnabled) {
+                                    ActionRow(stringResource(R.string.setup_default_home), s.defaultHomeLabel ?: stringResource(R.string.setup_choose_home), stringResource(R.string.setup_choose), a.onHomeApp)
+                                }
+                                ChoiceRow(
+                                    host, "orientation", stringResource(R.string.setup_orientation), null,
+                                    SessionPrefs.orientationOptions.map { (value, label) -> value to stringResource(label) },
+                                    s.orientation, onPick = a.onOrientation,
+                                )
+                                ToggleRow(
+                                    host, "launcher-fullscreen", stringResource(R.string.setup_fullscreen),
+                                    if (s.launcherFullscreen) stringResource(R.string.setup_fullscreen_on) else stringResource(R.string.setup_fullscreen_off),
+                                    s.launcherFullscreen,
+                                ) { a.onLauncherFullscreen(it) }
+                            }
+                        }
+                        val art: @Composable () -> Unit = {
+                            SettingsGroup(stringResource(R.string.setup_group_art)) {
+                                ToggleRow(host, "added-art", stringResource(R.string.mode_added_art), stringResource(R.string.mode_added_art_hint), s.addedGamesArt) { a.onAddedGamesArt(it) }
+                                ActionRow(
+                                    stringResource(R.string.mode_sgdb_key), if (s.sgdbUserKey) stringResource(R.string.mode_sgdb_key_yours) else null,
+                                    stringResource(R.string.mode_sgdb_edit), onClick = { editSgdbKey = true },
+                                )
+                            }
+                        }
+                        // Two columns on a wide page: how it looks; this device and the library's art.
+                        if (wide) Row(horizontalArrangement = Arrangement.spacedBy(16.dp), verticalAlignment = Alignment.Top) {
+                            Column(Modifier.weight(1f)) { look() }
+                            Column(Modifier.weight(1f)) { device(); art() }
+                        } else { look(); device(); art() }
+                    }
+                    3 -> {
+                        SettingsGroup(stringResource(R.string.setup_tab_diagnostics)) {
                             ToggleRow(host, "logs", stringResource(R.string.setup_logs), stringResource(R.string.setup_logs_hint), s.logsEnabled) { a.onLogs() }
                             ToggleRow(host, "agent-commands", stringResource(R.string.setup_agent_commands), null, s.agentCommands) { a.onAgentCommands() }
                             ActionRow(stringResource(R.string.setup_latest_logs), stringResource(R.string.drawer_logs_hint), stringResource(R.string.drawer_share_logs), a.onShareLogs,
                                 progress = com.droiddeck.launcher.session.SessionLogShare.progress)
                             ActionRow(stringResource(R.string.setup_saved_logs), stringResource(R.string.setup_saved_logs_hint, com.droiddeck.launcher.session.SessionPaths.KEEP_SESSIONS), stringResource(R.string.setup_clear_logs), a.onClearLogs)
-                            ToggleRow(
-                                host, "offline", stringResource(R.string.setup_offline),
-                                s.offlineAccount?.let { if (it.isEmpty()) stringResource(R.string.setup_signed_in_unnamed) else stringResource(R.string.setup_signed_in, it) } ?: stringResource(R.string.setup_sign_in_first),
-                                s.offline, enabled = s.offlineAccount != null,
-                            ) { a.onOffline() }
-                        }
-                    }
-                    3 -> {
-                        SettingsGroup(stringResource(R.string.setup_launcher)) {
-                            LanguageRow(host, s.language, a.onLanguage)
-                            ChoiceRow(
-                                host, "app-scale", stringResource(R.string.setup_app_scale), stringResource(R.string.setup_app_scale_hint),
-                                com.droiddeck.launcher.core.AppUiPrefs.scales.map { percent ->
-                                    percent to stringResource(
-                                        if (percent == com.droiddeck.launcher.core.AppUiPrefs.DEFAULT_SCALE) R.string.setup_app_scale_default
-                                        else R.string.ctrl_percent, percent,
-                                    )
-                                }, s.appScale, onPick = a.onAppScale,
-                            )
-                            SettingsRow(stringResource(R.string.setup_theme), stringResource(R.string.setup_theme_hint)) {
-                                Box {
-                                    ValueChip(stringResource(Themes.byId(s.theme).label), host.open == "theme") { host.open = if (host.open == "theme") null else "theme" }
-                                    AnchoredMenu(host.open == "theme", onDismiss = { if (host.open == "theme") host.open = null }, title = stringResource(R.string.setup_theme)) { firstItemFocus ->
-                                        Themes.all.forEachIndexed { index, theme ->
-                                            MenuItem(stringResource(theme.label), checked = s.theme == theme.id, focusRequester = if (index == 0) firstItemFocus else null) {
-                                                a.onTheme(theme.id)
-                                                host.open = null
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            ToggleRow(
-                                host, "home-screen", stringResource(R.string.setup_home),
-                                if (s.homeScreenEnabled) stringResource(R.string.setup_home_on) else stringResource(R.string.setup_home_off),
-                                s.homeScreenEnabled,
-                            ) { a.onHomeScreen(it) }
-                            ChoiceRow(
-                                host, "orientation", stringResource(R.string.setup_orientation), null,
-                                SessionPrefs.orientationOptions.map { (value, label) -> value to stringResource(label) },
-                                s.orientation, onPick = a.onOrientation,
-                            )
-                            ToggleRow(
-                                host, "launcher-fullscreen", stringResource(R.string.setup_fullscreen),
-                                if (s.launcherFullscreen) stringResource(R.string.setup_fullscreen_on) else stringResource(R.string.setup_fullscreen_off),
-                                s.launcherFullscreen,
-                            ) { a.onLauncherFullscreen(it) }
-                            ToggleRow(host, "launcher-animations", stringResource(R.string.setup_animations), null,
-                                s.animationsEnabled, onChange = a.onAnimationsEnabled)
-                            if (s.homeScreenEnabled) {
-                                ActionRow(stringResource(R.string.setup_default_home), s.defaultHomeLabel ?: stringResource(R.string.setup_choose_home), stringResource(R.string.setup_choose), a.onHomeApp)
-                            }
-                        }
-                        SettingsGroup(stringResource(R.string.setup_linux_apps)) {
-                            ToggleRow(
-                                host, "store-enabled", stringResource(R.string.setup_store),
-                                if (s.storeEnabled) stringResource(R.string.setup_store_on)
-                                else stringResource(R.string.setup_store_off),
-                                s.storeEnabled,
-                            ) { a.onStoreEnabled(it) }
-                        }
-                        SettingsGroup(stringResource(R.string.content_games)) {
-                            ToggleRow(host, "added-art", stringResource(R.string.mode_added_art), stringResource(R.string.mode_added_art_hint), s.addedGamesArt) { a.onAddedGamesArt(it) }
-                            ActionRow(
-                                stringResource(R.string.mode_sgdb_key), if (s.sgdbUserKey) stringResource(R.string.mode_sgdb_key_yours) else null,
-                                stringResource(R.string.mode_sgdb_edit), onClick = { editSgdbKey = true },
-                            )
-                        }
-                        SettingsGroup(stringResource(R.string.setup_stores)) {
-                            ToggleRow(
-                                host, "stores-enabled", stringResource(R.string.setup_stores_show),
-                                null, s.gameStoresEnabled,
-                            ) { a.onGameStoresEnabled(it) }
-                            // The same rows as the Stores page's own cog, for whoever looks here first.
-                            SettingsRow(stringResource(R.string.setup_stores_open_on), null) {
-                                SegmentedTabs(
-                                    listOf(SessionPrefs.STORES_OPEN_LIBRARY to stringResource(R.string.stores_tab_library), SessionPrefs.STORES_OPEN_STORE to stringResource(R.string.stores_tab_store)),
-                                    s.storesOpenTab,
-                                ) { a.onStoresOpenTab(it) }
-                            }
-                            ToggleRow(host, "stores-show-mature", stringResource(R.string.stores_show_mature), null, s.storesShowMature) { a.onStoresShowMature(it) }
-                            SettingsRow(stringResource(R.string.setup_stores_speed), null) {
-                                SegmentedTabs(StoreDownloadTier.ALL.map { it.id to stringResource(it.label) }, s.gameStoresSpeedTier) { a.onGameStoresSpeedTier(it) }
-                            }
-                            StoresEngineRow()
                         }
                     }
                 }
@@ -407,50 +413,43 @@ internal fun SetupPanel(
     }
 }
 
-/** The launcher's own tools as cards: four across, two by two on a narrow page. */
+/**
+ * The checks as one card while they all pass: a ring with how many pass, "Ready to play" and one
+ * line of what that means, and a Details chip that opens the checks themselves in place ([checks]).
+ */
 @Composable
-private fun ToolGrid(s: FrontEndState, a: FrontEndActions) {
-    val columns = if (LocalNarrowPane.current) 2 else 4
-    val tools = listOf(
-        ToolSpec(Icons.Outlined.Folder, stringResource(R.string.setup_tool_files), stringResource(R.string.setup_tool_files_hint), a.onFiles),
-        ToolSpec(Icons.Outlined.Extension, stringResource(R.string.setup_tool_protons), stringResource(R.string.setup_tool_protons_hint), a.onProtons),
-        ToolSpec(Icons.Outlined.Speed, stringResource(R.string.setup_tool_performance), stringResource(R.string.setup_tool_performance_hint), a.onPerformance),
-        ToolSpec(Icons.Outlined.VideogameAsset, stringResource(R.string.setup_tool_roms), s.romsDir ?: stringResource(R.string.setup_tool_roms_hint), a.onRoms),
-    )
-    Column(verticalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth()) {
-        for (row in tools.chunked(columns)) {
-            Row(horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min)) {
-                for (t in row) ToolCard(t, Modifier.weight(1f).fillMaxHeight())
-                repeat(columns - row.size) { Spacer(Modifier.weight(1f)) }
-            }
-        }
-    }
-}
-
-private class ToolSpec(val icon: ImageVector, val title: String, val detail: String, val onClick: () -> Unit)
-
-@Composable
-private fun ToolCard(t: ToolSpec, modifier: Modifier) {
+private fun ReadinessCard(passing: Int, total: Int, line: String, open: Boolean, onDetails: () -> Unit, checks: @Composable () -> Unit) {
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
-    val src = remember { MutableInteractionSource() }
-    val hot = rememberHot(src)
-    val pressed by src.collectIsPressedAsState()
-    val scale by animateFloatAsState(if (pressed) 0.97f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "toolScale")
-    Column(
-        verticalArrangement = Arrangement.spacedBy(4.dp),
-        modifier = modifier.paneItem("tool:${t.title}")
-            .graphicsLayer { scaleX = scale; scaleY = scale }
-            .clip(Shape14)
-            .background(if (hot) pal.signal.copy(alpha = 0.10f) else colors.surface)
-            .glideBorder(hot, Shape14, pal.signal, pal.line)
-            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = t.onClick)
-            .controllerConfirm(onClick = t.onClick)
-            .padding(horizontal = 14.dp, vertical = 12.dp),
-    ) {
-        Icon(t.icon, contentDescription = null, tint = if (hot) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(20.dp))
-        Text(t.title, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
-        Text(t.detail, fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 2, overflow = TextOverflow.Ellipsis)
+    val ready = passing == total
+    Column(Modifier.fillMaxWidth().padding(top = 8.dp).clip(Shape14).background(colors.surface).border(1.dp, pal.line, Shape14)) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp),
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 12.dp),
+        ) {
+            val tint = if (ready) pal.good else AttentionAmber
+            Box(contentAlignment = Alignment.Center, modifier = Modifier.size(52.dp)) {
+                androidx.compose.material3.CircularProgressIndicator(
+                    progress = { passing / total.toFloat().coerceAtLeast(1f) }, strokeWidth = 4.dp,
+                    color = tint, trackColor = tint.copy(alpha = 0.18f), modifier = Modifier.size(52.dp),
+                )
+                Text("$passing/$total", fontSize = 13.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
+            }
+            Column(Modifier.weight(1f)) {
+                Text(
+                    stringResource(if (ready) R.string.setup_ready else R.string.setup_not_ready),
+                    fontSize = 17.sp, fontWeight = FontWeight.Bold, color = colors.onBackground,
+                )
+                if (line.isNotEmpty()) Text(line, fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 2, overflow = TextOverflow.Ellipsis)
+            }
+            if (passing > 0) SecondaryButton(stringResource(if (open) R.string.common_hide else R.string.setup_details), compact = true, onClick = onDetails)
+        }
+        AnimatedVisibility(open, enter = expandVertically(Motion.sp(1f)) + fadeIn(Motion.sp(1f)), exit = shrinkVertically(Motion.sp(1f)) + fadeOut(Motion.sp(1f))) {
+            Column(Modifier.fillMaxWidth()) {
+                Box(Modifier.fillMaxWidth().height(1.dp).background(pal.line))
+                checks()
+            }
+        }
     }
 }
 
@@ -472,14 +471,19 @@ internal fun LaunchSettings(s: FrontEndState, a: FrontEndActions, host: MenuHost
     val inputMode = androidx.compose.ui.platform.LocalInputModeManager.current
     // The game's prefix is compatdata/<id>, as droiddeck-game-env reads it: a Steam title's appid, an
     // added game's shortcut appid (unsigned). Recommended scans the game's own folder either way.
-    val wincompKey = game?.let {
-        if (it.library == com.droiddeck.launcher.frontend.Library.ADDED) Integer.toUnsignedString(it.appId)
-        else it.appId.takeIf { id -> id > 0 }?.toString()
-    }
+    val wincompKey = game?.takeIf { it.library == com.droiddeck.launcher.frontend.Library.ADDED || it.appId > 0 }?.profileKey
     var wincompOpen by remember(wincompKey) { mutableStateOf<Boolean?>(null) }
     val wincompPicks = remember(wincompKey, wincompOpen) { wincompKey?.let { com.droiddeck.launcher.session.WinComponents.picks(context, it) }.orEmpty() }
     val cards = buildList<@Composable (Modifier) -> Unit> {
-        add { m -> SettingCard(stringResource(R.string.setup_card_components), stringResource(R.string.setup_card_components_hint), "card:components", m) { a.onComponents(true) } }
+        add { m ->
+            val back = stringResource(R.string.hop_from_games)
+            // Components is its own section: the card hops there, and B on it comes back here.
+            SettingCard(stringResource(R.string.setup_card_components), stringResource(R.string.setup_card_components_hint), "card:components", m.hopSource("card:components")) {
+                val at = Hops.sources["card:components"]
+                if (at == null) a.onComponents(true)
+                else Hops.go(HopOrigin("games", HOP_SURFACE_GAMES, null, "card:components", at, back, dest = "components", page = "components")) { a.onComponents(true) }
+            }
+        }
         add { m ->
             Box(m) {
                 SettingCard(stringResource(R.string.frame_gen_title), s.frameGenLabel, "card:fg", Modifier.fillMaxSize()) {
@@ -491,8 +495,8 @@ internal fun LaunchSettings(s: FrontEndState, a: FrontEndActions, host: MenuHost
         if (controller != null) add { m -> SettingCard(stringResource(R.string.setup_card_controls), stringResource(R.string.setup_card_controls_hint), "card:controls", m, controller.onMapping) }
         // An Epic game's own launch choices, kept in its sidecar so a launch from the Steam client
         // honours them too (droiddeck-store-launch reads the same file).
-        // Epic's launch choices; cloud saves live in the game's Cloud saves view, so a GOG game has no card.
-        val cardStore = com.droiddeck.launcher.stores.Store.byId(game?.source.orEmpty())?.takeIf { it == com.droiddeck.launcher.stores.Store.EPIC }
+        // Store launch choices; cloud saves have their own view.
+        val cardStore = com.droiddeck.launcher.stores.Store.byId(game?.source.orEmpty())?.takeIf { it == com.droiddeck.launcher.stores.Store.EPIC || it == com.droiddeck.launcher.stores.Store.GOG }
         if (cardStore != null && game?.gameFiles != null) add { m ->
             Box(m) {
                 StoreLaunchCard(host, game.gameFiles!!, cardStore)
@@ -533,7 +537,14 @@ private fun StoreLaunchCard(host: MenuHost, folder: java.io.File, store: com.dro
     val options = sidecar?.epic ?: com.droiddeck.launcher.stores.EpicOptions()
     val epic = store == com.droiddeck.launcher.stores.Store.EPIC
     val key = "store-" + store.id
-    val value = buildList {
+    val value = if (!epic) stringResource(when {
+        !com.droiddeck.launcher.stores.gog.GogComet.enabled(appContext) || sidecar?.achievements == false -> R.string.gog_achievements_off
+        com.droiddeck.launcher.stores.gog.GogComet.status == "sign-in-needed" -> R.string.gog_achievements_signin
+        com.droiddeck.launcher.stores.gog.GogComet.status in listOf("service-unavailable", "credentials-unavailable", "not-installed") -> R.string.gog_achievements_unavailable
+        com.droiddeck.launcher.stores.gog.GogComet.status == "uploaded" -> R.string.gog_achievements_uploaded
+        com.droiddeck.launcher.stores.gog.GogComet.status == "pending-upload" || com.droiddeck.launcher.stores.gog.GogComet.status == "unlocked-locally" -> R.string.gog_achievements_pending
+        else -> R.string.gog_achievements_on
+    }) else buildList {
         if (epic && options.offline) add(stringResource(R.string.epic_card_offline))
         else if (epic && options.eos) add(stringResource(R.string.epic_card_eos))
     }.ifEmpty { listOf(stringResource(R.string.epic_card_none)) }.joinToString(" · ")
@@ -552,6 +563,16 @@ private fun StoreLaunchCard(host: MenuHost, folder: java.io.File, store: com.dro
         host.open = if (host.open == key) null else key
     }
     AnchoredMenu(host.open == key, onDismiss = { if (host.open == key) host.open = null }, title = store.shortLabel) { first ->
+        if (!epic) {
+            MenuItem(stringResource(R.string.gog_achievements), checked = sidecar?.achievements != false, focusRequester = first,
+                detail = if (!com.droiddeck.launcher.stores.gog.GogComet.enabled(appContext)) stringResource(R.string.gog_achievements_enable_store) else null) {
+                val on = sidecar?.achievements == false
+                Thread({
+                    val written = runCatching { com.droiddeck.launcher.stores.StoreGameSidecar.updateAchievements(folder, on) }.getOrNull()
+                    com.droiddeck.launcher.stores.StoresState.post { sidecar = written ?: sidecar }
+                }, "gog-game-achievements").start()
+            }
+        }
         if (epic) {
             MenuItem(stringResource(R.string.epic_eos), checked = options.eos, focusRequester = first) { set { it.copy(eos = !it.eos) } }
             MenuItem(stringResource(R.string.epic_offline), checked = options.offline) { set { it.copy(offline = !it.offline) } }

app/src/main/java/com/droiddeck/launcher/ui/GameEnvironmentEditor.kt

@@ -52,7 +52,11 @@ import kotlinx.coroutines.withContext
 // dialog, with each variable's actions in a menu off its value as everywhere else.
 
 @Composable
-fun GameEnvironmentRow(modifier: Modifier = Modifier, showHint: Boolean = true) {
+fun GameEnvironmentRow(
+    modifier: Modifier = Modifier,
+    showHint: Boolean = true,
+    initialScope: String = "",
+) {
     var open by remember { mutableStateOf(false) }
     // Opened with a pad, the editor starts with focus in it; the dialog is a window of its own and
     // would otherwise give the pad nothing to move from.
@@ -64,7 +68,7 @@ fun GameEnvironmentRow(modifier: Modifier = Modifier, showHint: Boolean = true)
             open = true
         }
     }
-    if (open) GameEnvironmentEditor(byPad) { open = false }
+    if (open) GameEnvironmentEditor(byPad, initialScope) { open = false }
 }
 
 /** With a pad driving, focus [target] once the dialog is laid out, and keep the dialog in pad mode. */
@@ -81,19 +85,19 @@ internal fun PadFocus(byPad: Boolean, target: FocusRequester) {
 }
 
 @Composable
-private fun GameEnvironmentEditor(byPad: Boolean, onClose: () -> Unit) {
+internal fun GameEnvironmentEditor(byPad: Boolean, initialScope: String = "", onClose: () -> Unit) {
     val context = LocalContext.current
     val coroutine = rememberCoroutineScope()
     val shown = rememberShown(onClose)
     val close = { shown.targetState = false }
     var config by remember { mutableStateOf<GameEnvironment.Config?>(null) }
     var games by remember { mutableStateOf(emptyList<Pair<String, String>>()) }
-    var scope by remember { mutableStateOf("") }
+    var scope by remember { mutableStateOf(initialScope) }
     var otherId by remember { mutableStateOf<String?>(null) }
     var menu by remember { mutableStateOf<String?>(null) }
     var busy by remember { mutableStateOf(false) }
     var error by remember { mutableStateOf(false) }
-    var editing by remember { mutableStateOf<Pair<String, String>?>(null) }
+    var editing by remember { mutableStateOf<EnvironmentVariableEdit?>(null) }
     val preset = SessionPrefs.fexPreset(context)
     val forceSsbs = SessionPrefs.forceSsbs(context)
     val firstFocus = remember { FocusRequester() }
@@ -168,7 +172,7 @@ private fun GameEnvironmentEditor(byPad: Boolean, onClose: () -> Unit) {
                     VariableRow(
                         name, value, inherited = !own.containsKey(name), open = menu == "var:$name", enabled = !busy,
                         onToggle = { menu = if (menu == "var:$name") null else "var:$name" }, onDismiss = { if (menu == "var:$name") menu = null },
-                        onEdit = { menu = null; editByPad = dialogInput.inputMode == InputMode.Keyboard; editing = name to (value ?: "") },
+                        onEdit = { menu = null; editByPad = dialogInput.inputMode == InputMode.Keyboard; editing = EnvironmentVariableEdit(scope, profileName, name, value ?: "") },
                         // A value set here or inherited can be switched off for this profile; one set here can go back to inheriting.
                         onUnset = if (value != null) ({ menu = null; save(current.withEntries(scope, own + (name to null))) }) else null,
                         onRestore = if (own.containsKey(name)) ({ menu = null; save(current.withEntries(scope, own - name)) }) else null,
@@ -185,9 +189,9 @@ private fun GameEnvironmentEditor(byPad: Boolean, onClose: () -> Unit) {
                 SecondaryButton(stringResource(R.string.game_env_add), enabled = !busy) { menu = if (menu == "add") null else "add" }
                 AnchoredMenu(menu == "add", onDismiss = { if (menu == "add") menu = null }, title = stringResource(R.string.game_env_add)) { first ->
                     for ((i, option) in GameEnvironmentOptions.all.withIndex()) MenuItem(option.name, checked = false, focusRequester = if (i == 0) first else null) {
-                        menu = null; editByPad = dialogInput.inputMode == InputMode.Keyboard; editing = option.name to option.value
+                        menu = null; editByPad = dialogInput.inputMode == InputMode.Keyboard; editing = EnvironmentVariableEdit(scope, profileName, option.name, option.value)
                     }
-                    MenuItem(stringResource(R.string.game_env_custom), checked = false) { menu = null; editByPad = dialogInput.inputMode == InputMode.Keyboard; editing = "" to "" }
+                    MenuItem(stringResource(R.string.game_env_custom), checked = false) { menu = null; editByPad = dialogInput.inputMode == InputMode.Keyboard; editing = EnvironmentVariableEdit(scope, profileName, "", "") }
                 }
             }
             if (current != null && current.entries(scope).isNotEmpty()) FocusText(stringResource(R.string.game_env_reset), LocalPalette.current.signal) {
@@ -197,19 +201,21 @@ private fun GameEnvironmentEditor(byPad: Boolean, onClose: () -> Unit) {
             PrimaryButton(stringResource(R.string.game_env_done), enabled = !busy, onClick = close)
         }
     }
-    editing?.let { (name, value) ->
-        VariableDialog(name, value, profileName, editByPad, onDismiss = { editing = null }) { key, content ->
+    editing?.let { edit ->
+        VariableDialog(edit.name, edit.value, edit.profileName, editByPad, onDismiss = { editing = null }) { key, content ->
             config?.let {
-                val entries = it.entries(scope).toMutableMap()
-                if (name.isNotEmpty() && name != key) entries[name] = null
+                val entries = it.entries(edit.scope).toMutableMap()
+                if (edit.name.isNotEmpty() && edit.name != key) entries[edit.name] = null
                 entries[key] = content
-                save(it.withEntries(scope, entries))
+                save(it.withEntries(edit.scope, entries))
             }
             editing = null
         }
     }
 }
 
+private data class EnvironmentVariableEdit(val scope: String, val profileName: String, val name: String, val value: String)
+
 /** The panel the profile and the variables sit in, as a settings group does. */
 @Composable
 private fun Panel(content: @Composable androidx.compose.foundation.layout.ColumnScope.() -> Unit) =

app/src/main/java/com/droiddeck/launcher/ui/GpuDriversPanel.kt

@@ -57,6 +57,10 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 
 /** One matched driver pair in the list (DriverPairs), and what this device makes of it. */
 class PairRow(
@@ -119,155 +123,38 @@ class GpuDriversActions(
 )
 
 /**
- * The GPU drivers tab: this GPU, and the drivers it draws with - a runtime (Linux) driver for the
- * games and a display (Android) driver for the screen, set together as one matched pair. Auto keeps
- * the pair recommended for the GPU installed and current; Manual picks a pair from the list; the
- * two lists each on their own, and imports, are under Advanced.
+ * Everything about the chip - SoC, GPU, CPU, memory, system, the phone's own Vulkan driver, the
+ * drivers in use - gathered once, off the main thread, with a button that copies it for a bug
+ * report. Stepped out of the Components page's device chip; [first] is where a pad starts.
  */
 @Composable
-internal fun GpuDriversPanel(s: GpuDriversState, a: GpuDriversActions, onAdvanced: (String) -> Unit) {
+internal fun DeviceDetails(first: FocusRequester) {
     val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    var showAll by rememberSaveable { mutableStateOf(false) }
-    Column(verticalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth().padding(top = 12.dp)) {
-        DeviceCard(s)
-        if (!s.unsupported) {
-            Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
-                ModeCard(Icons.Outlined.AutoAwesome, stringResource(R.string.common_auto), stringResource(R.string.gpu_auto_hint), s.auto, Modifier.weight(1f)) { a.onAuto(true) }
-                ModeCard(Icons.Outlined.Tune, stringResource(R.string.mode_suspend_manual), stringResource(R.string.gpu_manual_hint), !s.auto, Modifier.weight(1f)) { a.onAuto(false) }
-            }
-            if (s.auto) AutoCard(s)
-            else {
-                val shown = s.pairs.filter { it.suits || showAll }
-                if (shown.isEmpty()) Text(
-                    if (s.checking) stringResource(R.string.gpu_checking) else stringResource(R.string.gpu_none_listed),
-                    fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(vertical = 8.dp),
-                )
-                for (p in shown) PairLine(p, s.busy == p.key, s.percent, enabled = s.busy == null) { a.onPair(p.key) }
-                if (s.pairs.any { !it.suits }) FocusText(
-                    if (showAll) stringResource(R.string.gpu_hide_other) else stringResource(R.string.gpu_show_other), pal.signal,
-                ) { showAll = !showAll }
-            }
-        }
-        SettingsGroup(stringResource(R.string.gpu_advanced)) {
-            SettingsRow(stringResource(R.string.comp_runtime_driver), s.activeBundle?.let { stringResource(R.string.gpu_set_with_display, it) } ?: stringResource(R.string.gpu_runtime_hint)) {
-                DriverDropdown(s.linuxRows, s.linuxSelected, stringResource(R.string.gpu_runtime_default), a.onSelectLinux) { onAdvanced("rt") }
-            }
-            SettingsRow(stringResource(R.string.comp_display_driver), s.activeBundle?.let { stringResource(R.string.gpu_set_with_runtime, it) } ?: stringResource(R.string.gpu_display_hint)) {
-                DriverDropdown(s.androidRows, s.androidSelected, stringResource(R.string.gpu_auto_by_gpu), a.onSelectAndroid) { onAdvanced("panel") }
-            }
-        }
-    }
-}
-
-/**
- * One driver list as a drop-down: the installed drivers to pick from, and the full page for
- * downloading and deleting them. An Android + Linux bundle's row is tagged, and picking it sets both.
- */
-@Composable
-private fun DriverDropdown(rows: List<DriverRow>, selected: String, fallback: String, onSelect: (String) -> Unit, onManage: () -> Unit) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    var open by remember { mutableStateOf(false) }
-    Box {
-        SecondaryButton((rows.firstOrNull { it.id == selected }?.name ?: fallback) + "  ▾", compact = true) { open = true }
-        DropdownMenu(open, onDismissRequest = { open = false }, modifier = Modifier.heightIn(max = 360.dp)) {
-            for (row in rows) DropdownMenuItem(
-                leadingIcon = { Radio(row.id == selected) },
-                text = {
-                    Column {
-                        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-                            Text(row.name, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = if (row.id == selected) pal.signal else colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis)
-                            if (row.tag == DriverRow.BUNDLE) Text(driverTagLabel(row.tag), fontSize = 10.5.sp, fontWeight = FontWeight.Bold, letterSpacing = 1.sp, color = colors.onSurfaceVariant)
-                        }
-                        if (row.detail.isNotEmpty()) Text(row.detail, fontSize = 12.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
-                    }
-                },
-                onClick = { open = false; if (row.id != selected) onSelect(row.id) },
-            )
-            HorizontalDivider(color = pal.line)
-            DropdownMenuItem(text = { Text(stringResource(R.string.gpu_manage), fontSize = 14.sp, color = pal.signal) }, onClick = { open = false; onManage() })
-        }
-    }
-}
-
-/**
- * This GPU and how far it is supported. A tap (or A) opens the card onto everything about the chip -
- * SoC, GPU, CPU, memory, system, the phone's own Vulkan driver, the drivers in use - gathered once,
- * off the main thread, with a button that copies it for a bug report.
- */
-@Composable
-private fun DeviceCard(s: GpuDriversState) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
     val context = LocalContext.current
     val clipboard = LocalClipboardManager.current
-    val tint = when {
-        s.unsupported -> pal.error
-        s.supported -> pal.good
-        else -> AttentionAmber
-    }
-    var open by rememberSaveable { mutableStateOf(false) }
     var details by remember { mutableStateOf<List<DeviceInfo.Section>?>(null) }
     var copied by remember { mutableStateOf(false) }
-    LaunchedEffect(open) {
-        if (open && details == null) details = withContext(Dispatchers.IO) { DeviceInfo.collect(context) }
-    }
-    val src = remember { MutableInteractionSource() }
-    val hot = rememberHot(src)
-    val toggle = { open = !open; copied = false }
+    LaunchedEffect(Unit) { details = withContext(Dispatchers.IO) { DeviceInfo.collect(context) } }
     Column(
-        Modifier.fillMaxWidth().clip(Shape14).background(colors.surface)
-            .background(if (hot) pal.signal.copy(alpha = 0.10f) else Color.Transparent)
-            .glideBorder(hot, Shape14, pal.signal, pal.line),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
+        modifier = Modifier.fillMaxWidth().heightIn(max = 360.dp).verticalScroll(rememberScrollState()),
     ) {
-        Row(
-            verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(14.dp),
-            modifier = Modifier.fillMaxWidth().paneItem("gpu-device")
-                .hoverable(src).clickable(interactionSource = src, indication = null, role = Role.Button, onClick = toggle)
-                .controllerConfirm(onClick = toggle)
-                .padding(14.dp),
-        ) {
-            Box(contentAlignment = Alignment.Center, modifier = Modifier.size(44.dp).clip(Shape12).background(tint.copy(alpha = 0.14f))) {
-                Icon(Icons.Outlined.Memory, contentDescription = null, tint = tint, modifier = Modifier.size(24.dp))
-            }
-            Column(Modifier.weight(1f)) {
-                Text(s.gpuName, fontSize = 18.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
-                Text(listOf(s.soc, s.gpuFamily).filter { it.isNotEmpty() }.joinToString(" · "), fontSize = 13.sp, color = colors.onSurfaceVariant)
-            }
-            // The verdict shares the width with the GPU's name and wraps, rather than taking all it
-            // needs: a long one (in some languages) would squeeze the name to a letter a line.
-            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp), modifier = Modifier.weight(1f, fill = false)) {
-                Box(Modifier.size(7.dp).clip(CircleShape).background(tint))
-                Text(s.supportText, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = tint, maxLines = 3, overflow = TextOverflow.Ellipsis)
-            }
-            Icon(
-                if (open) Icons.Outlined.ExpandLess else Icons.Outlined.ExpandMore,
-                contentDescription = stringResource(if (open) R.string.device_info_hide else R.string.device_info_show),
-                tint = colors.onSurfaceVariant, modifier = Modifier.size(24.dp),
-            )
-        }
-        AnimatedVisibility(open) {
-            Column(verticalArrangement = Arrangement.spacedBy(12.dp), modifier = Modifier.fillMaxWidth().padding(start = 14.dp, end = 14.dp, bottom = 14.dp)) {
-                HorizontalDivider(color = pal.line)
-                val sections = details
-                if (sections == null) {
-                    Text(stringResource(R.string.device_info_loading), fontSize = 13.sp, color = colors.onSurfaceVariant)
-                    LinearProgressIndicator(Modifier.fillMaxWidth())
-                } else {
-                    for (section in sections) DeviceInfoSection(section)
-                    Row(verticalAlignment = Alignment.CenterVertically) {
-                        Text(
-                            stringResource(if (copied) R.string.device_info_copied else R.string.device_info_copy_hint),
-                            fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.weight(1f),
-                        )
-                        SecondaryButton(stringResource(R.string.device_info_copy), compact = true) {
-                            clipboard.setText(AnnotatedString(DeviceInfo.text(sections)))
-                            copied = true
-                        }
-                    }
+        val sections = details
+        if (sections == null) {
+            Text(stringResource(R.string.device_info_loading), fontSize = 13.sp, color = colors.onSurfaceVariant)
+            LinearProgressIndicator(Modifier.fillMaxWidth())
+        } else {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    stringResource(if (copied) R.string.device_info_copied else R.string.device_info_copy_hint),
+                    fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.weight(1f),
+                )
+                SecondaryButton(stringResource(R.string.device_info_copy), compact = true, modifier = Modifier.focusRequester(first)) {
+                    clipboard.setText(AnnotatedString(DeviceInfo.text(sections)))
+                    copied = true
                 }
             }
+            for (section in sections) DeviceInfoSection(section)
         }
     }
 }
@@ -288,115 +175,9 @@ private fun DeviceInfoSection(section: DeviceInfo.Section) {
         Text(section.title.uppercase(), fontSize = 11.5.sp, fontWeight = FontWeight.Bold, letterSpacing = 1.2.sp, color = colors.onSurfaceVariant)
         for ((label, value) in section.rows) {
             Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
-                Text(label, fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.width(190.dp))
+                Text(label, fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.width(150.dp))
                 Text(value, fontSize = 13.sp, fontWeight = FontWeight.Medium, color = colors.onBackground, modifier = Modifier.weight(1f))
             }
         }
     }
 }
-
-/** What Auto has set and what it is doing. */
-@Composable
-private fun AutoCard(s: GpuDriversState) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    val active = s.activePair
-    val recommended = s.pairs.firstOrNull { it.recommended }
-    Column(
-        verticalArrangement = Arrangement.spacedBy(4.dp),
-        modifier = Modifier.fillMaxWidth().clip(Shape14).background(colors.surface).border(1.dp, pal.line, Shape14).padding(14.dp),
-    ) {
-        Text(stringResource(R.string.gpu_in_use_caps), fontSize = 11.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 1.2.sp, color = colors.onSurfaceVariant)
-        Text(
-            active?.let { "${it.name} ${it.version}" } ?: s.activeBundle ?: stringResource(R.string.gpu_builtin),
-            fontSize = 16.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground,
-        )
-        Text(
-            if (active != null || s.activeBundle != null) stringResource(R.string.gpu_matched_pair)
-            else recommended?.let { stringResource(R.string.gpu_recommended_for, it.name) } ?: stringResource(R.string.gpu_refresh_hint),
-            fontSize = 13.sp, color = colors.onSurfaceVariant,
-        )
-        if (s.busy != null) {
-            LinearProgressIndicator(
-                progress = { (s.percent.coerceAtLeast(0)) / 100f },
-                modifier = Modifier.fillMaxWidth().padding(top = 8.dp).height(6.dp).clip(CircleShape),
-            )
-        }
-        if (s.autoStatus.isNotEmpty()) Text(s.autoStatus, fontSize = 13.sp, color = colors.onBackground, modifier = Modifier.padding(top = 4.dp))
-    }
-}
-
-@Composable
-private fun ModeCard(icon: ImageVector, title: String, hint: String, selected: Boolean, modifier: Modifier, onClick: () -> Unit) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    val src = remember { MutableInteractionSource() }
-    val hot = rememberHot(src)
-    // Selection is the radio; the ring is only ever focus.
-    val fill = if (hot) pal.signal.copy(alpha = 0.14f) else Color.Transparent
-    Row(
-        verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp),
-        modifier = modifier.paneItem("gpu-mode:$title").heightIn(min = 56.dp)
-            .clip(Shape14).background(colors.surface).background(fill)
-            .glideBorder(hot, Shape14, pal.signal, pal.line)
-            .hoverable(src).clickable(interactionSource = src, indication = null, role = Role.RadioButton, onClick = onClick)
-            .controllerConfirm(onClick = onClick)
-            .padding(horizontal = 14.dp, vertical = 10.dp),
-    ) {
-        Icon(icon, contentDescription = null, tint = if (selected) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(22.dp))
-        Column(Modifier.weight(1f)) {
-            Text(title, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)
-            Text(hint, fontSize = 12.5.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
-        }
-        Radio(selected)
-    }
-}
-
-@Composable
-private fun PairLine(p: PairRow, busy: Boolean, percent: Int, enabled: Boolean, onClick: () -> Unit) {
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    val src = remember { MutableInteractionSource() }
-    val hot = rememberHot(src)
-    val usable = enabled && p.complete && !p.active
-    val fill = if (hot) pal.signal.copy(alpha = 0.14f) else Color.Transparent
-    Row(
-        verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp),
-        modifier = Modifier.fillMaxWidth().paneItem("pair:${p.key}").heightIn(min = 56.dp)
-            .clip(Shape12).background(colors.surface).background(fill)
-            .glideBorder(hot, Shape12, pal.signal, pal.line)
-            .hoverable(src).clickable(interactionSource = src, indication = null, enabled = usable, role = Role.RadioButton, onClick = onClick)
-            .controllerConfirm(enabled = usable, onClick = onClick)
-            .padding(horizontal = 14.dp, vertical = 8.dp),
-    ) {
-        Radio(p.active)
-        Column(Modifier.weight(1f)) {
-            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-                Text(p.name, fontSize = 14.5.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false))
-                if (p.recommended) Text(
-                    stringResource(R.string.gpu_recommended_caps), fontSize = 10.5.sp, fontWeight = FontWeight.Bold, letterSpacing = 1.sp, color = pal.good,
-                    modifier = Modifier.clip(RoundedCornerShape(5.dp)).background(pal.good.copy(alpha = 0.12f)).padding(horizontal = 6.dp, vertical = 2.dp),
-                )
-            }
-            Text("${p.version} · ${p.detail}", fontSize = 12.5.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
-        }
-        when {
-            busy -> Column(horizontalAlignment = Alignment.End, modifier = Modifier.width(96.dp)) {
-                Text(if (percent >= 0) "$percent%" else "…", fontSize = 12.sp, color = colors.onSurfaceVariant)
-                LinearProgressIndicator(progress = { percent.coerceAtLeast(0) / 100f }, modifier = Modifier.fillMaxWidth().padding(top = 4.dp))
-            }
-            p.active -> Text(stringResource(R.string.comp_tag_in_use), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = pal.signal)
-            !p.complete -> Text(stringResource(R.string.gpu_unavailable), fontSize = 13.sp, color = colors.onSurfaceVariant)
-            p.installed -> Text(stringResource(R.string.common_use), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)
-            else -> Text(stringResource(R.string.common_download), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)
-        }
-    }
-}
-
-@Composable
-private fun Radio(selected: Boolean) {
-    val pal = LocalPalette.current
-    Box(contentAlignment = Alignment.Center, modifier = Modifier.size(20.dp).clip(CircleShape).border(2.dp, if (selected) pal.signal else pal.line2, CircleShape)) {
-        if (selected) Box(Modifier.size(10.dp).clip(CircleShape).background(pal.signal))
-    }
-}

app/src/main/java/com/droiddeck/launcher/ui/Hop.kt

@@ -0,0 +1,174 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.LocalIndication
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateMapOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.droiddeck.launcher.R
+
+// A link from a control in one section to a page in another (the Play sheet's Graphics drivers,
+// a game's Components card): the control squashes into a dot that flies to the destination's rail
+// item, the rail's selection glides there as it passes the top of its arc, and the page floods
+// out of the rail item once it lands. B on that page flies the dot back and puts the source
+// surface back as it was, focus on the control that asked.
+
+/**
+ * Where a hop came from: the rail item that was showing ([rail]), the surface on it (a sheet, the
+ * Games page) and its tab, the control's key and its root bounds, and the words for the way back.
+ * [page] is the page key the hop opened, so leaving it any other way forgets the way back.
+ */
+internal class HopOrigin(
+    val rail: String,
+    val surface: String,
+    val tab: String?,
+    val control: String,
+    val bounds: Rect,
+    val back: String,
+    val dest: String,
+    val page: String,
+)
+
+/** The surfaces a hop can start from and come back to. */
+internal const val HOP_SURFACE_GAMES = "games"
+internal const val HOP_SURFACE_DESKTOP = "desktop"
+internal const val HOP_SURFACE_SHEET = "sheet"
+
+internal object Hops {
+    /** The hop the page on screen was reached by, while B can still undo it. */
+    var origin by mutableStateOf<HopOrigin?>(null)
+
+    /** The pane content a hop is leaving (a rail key): it sinks back as the dot leaves it. */
+    var sinking by mutableStateOf<String?>(null)
+
+    /** Set while a hop's dot is flying: the rail item its selection has already glided to. */
+    var railPreview by mutableStateOf<String?>(null)
+
+    /**
+     * Set as a page leaves through a hop (either way), so the pane sinks it rather than draining
+     * it; the pane clears it once the change has started.
+     */
+    var linking by mutableStateOf(false)
+
+    /** A surface to put back as it was (a sheet re-lifted on its tab), once, and the control to focus. */
+    var restore by mutableStateOf<HopOrigin?>(null)
+
+    /** Per rail item, bumped when a dot lands on it: the item pops. */
+    val railLanded = mutableStateMapOf<String, Int>()
+
+    /** Bumped when a hop's page has flooded in: its target (a layer card) sends out one ring. */
+    var arrived by mutableIntStateOf(0)
+
+    /** Where each rail item sits, root px. */
+    val railBounds = HashMap<String, Rect>()
+
+    /** Where each control that can start a hop sits, root px. */
+    val sources = HashMap<String, Rect>()
+
+    /**
+     * Hops from the control at [origin].bounds to [origin].dest: [go] opens the page there once the dot lands.
+     * With animations off there is no dot and no flood, only the page.
+     */
+    fun go(origin: HopOrigin, go: () -> Unit) {
+        val railAt = railBounds[origin.dest]
+        val finish: () -> Unit = {
+            railPreview = null
+            this.origin = origin
+            if (railAt != null && Motion.scale != 0f) PageOrigin.mark(Origin(railAt, 14f * density, owner = origin.dest))
+            linking = true
+            go()
+            railLanded[origin.dest] = (railLanded[origin.dest] ?: 0) + 1
+            arrived++
+        }
+        if (railAt == null || Motion.scale == 0f) { finish(); return }
+        // The surface the control is on sinks as its dot leaves, and stays down as it goes.
+        sinking = origin.rail
+        Flights.fly(Flight(
+            origin.bounds, to = { railAt.center },
+            onHalf = { railPreview = origin.dest },
+            onLand = finish,
+        ))
+    }
+
+    /**
+     * B on a page reached by a hop: the page sinks, the source surface comes back as it was, and
+     * the dot flies home from the rail item to the control. False when there is no hop to undo.
+     */
+    fun back(close: () -> Unit): Boolean {
+        val o = origin ?: return false
+        origin = null
+        sinking = null
+        val railAt = railBounds[o.dest]
+        railPreview = if (railAt != null && Motion.scale != 0f) o.dest else null
+        restore = o
+        linking = true
+        close()
+        if (railAt == null || Motion.scale == 0f) { railPreview = null; return true }
+        Flights.fly(Flight(
+            railAt, to = { (sources[o.control] ?: o.bounds).center },
+            onHalf = { railPreview = null },
+        ))
+        return true
+    }
+
+    /** The page the hop opened has gone some other way: there is no way back to keep. */
+    fun forget(pageKey: String?) {
+        val o = origin ?: return
+        if (pageKey != o.page) { origin = null; sinking = null }
+    }
+
+    /** Screen density, for the rail item's corner; set by the front end. */
+    var density = 1f
+}
+
+/** Shows a rail section directly (no page closing, nothing forgotten): what a hop's way back calls. */
+internal val LocalShowSection = androidx.compose.runtime.staticCompositionLocalOf<(String) -> Unit> { {} }
+
+/** Remembers where this control sits, so a hop from it can fly from it and back to it. */
+internal fun Modifier.hopSource(key: String): Modifier = onGloballyPositioned { Hops.sources[key] = it.boundsInRoot() }
+
+/**
+ * "B · back to <source>" at the right of a page's header while it was reached by a hop; a tap is B.
+ * Nothing when it was not.
+ */
+@Composable
+internal fun HopBackChip(onBack: () -> Unit) {
+    val o = Hops.origin ?: return
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val shape = RoundedCornerShape(99.dp)
+    Text(
+        stringResource(R.string.hop_back, o.back), fontSize = 12.sp, fontWeight = FontWeight.SemiBold, maxLines = 1,
+        color = if (hot) colors.onBackground else colors.onSurfaceVariant,
+        modifier = Modifier.heightIn(min = 44.dp).padding(vertical = 6.dp).clip(shape)
+            .background(pal.signal.copy(alpha = if (hot) 0.16f else 0.08f))
+            .glideBorder(hot, shape, pal.signal, pal.line2)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onBack)
+            .controllerConfirm(onClick = onBack)
+            .padding(horizontal = 12.dp, vertical = 6.dp),
+    )
+}

app/src/main/java/com/droiddeck/launcher/ui/LiftSheet.kt

@@ -0,0 +1,848 @@
+package com.droiddeck.launcher.ui
+
+import android.view.KeyEvent
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.AnimationVector1D
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInHorizontally
+import androidx.compose.animation.slideOutHorizontally
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.LocalIndication
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.gestures.detectVerticalDragGestures
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsHoveredAsState
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.KeyboardArrowUp
+import androidx.compose.ui.platform.testTag
+import kotlinx.coroutines.Job
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateMapOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.foundation.layout.wrapContentHeight
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.zIndex
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.focus.FocusDirection
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.geometry.RoundRect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.lerp
+import androidx.compose.ui.input.InputMode
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.boundsInParent
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalInputModeManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.util.lerp
+import com.droiddeck.launcher.R
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
+
+// Play's settings, lifted out from under Play instead of opened on a page of their own. At rest a
+// lip tucks out under Play and says what it will do. Down (or a pull up, or a tap on the lip)
+// stretches the lip, the wall sinks back, and a sheet rises from the pane's foot with Play riding
+// its top edge as the handle - StepOut's move, with the pane for a box. B, Up from the chips or a
+// tap above folds it away; A on Play launches straight from it, the sheet folding into the pill
+// before the launch flood. Open desktop does the same with the desktop's settings.
+
+/** The sheets' tabs (their chips), by id. */
+internal object SheetTab {
+    const val DISPLAY = "display"
+    const val CONTROLS = "controls"
+    const val AUDIO = "audio"
+    const val SESSION = "session"
+    const val LIBRARY = "library"
+    const val STEAM = "steam"
+    const val FILES = "files"
+}
+
+/**
+ * Where the open sheet's top edge sits in a pane [paneH] tall (px), for a button [buttonH] tall
+ * riding it: 60dp down a 360dp pane, the same share of any other, and never so high that the
+ * button's top comes closer than [minAbove] to the pane's. [ride] is how far below the edge the
+ * button's centre sits.
+ */
+internal fun sheetTop(paneH: Float, buttonH: Float, minAbove: Float, ride: Float): Float =
+    maxOf(paneH * 60f / 360f, minAbove + buttonH / 2f - ride)
+
+/** A finger's hold on the sheet: where it started (0 rest, 1 open), where it is, whether it has it. */
+private class SheetDrag {
+    var from = 0f
+    var progress = 0f
+    var engaged = false
+}
+
+/** One piece of the sheet's rows fades and rises in on its own beat (a settings group asks for its index). */
+internal class SheetBeat(private val pieces: List<Animatable<Float, AnimationVector1D>>) {
+    private var next = 1
+    fun take(): Int = next++
+    fun value(i: Int): Float = pieces[i.coerceIn(0, pieces.lastIndex)].value
+}
+
+/** The sheet whose rows are being laid out, so each settings group can take its beat. */
+internal val LocalSheetBeat = staticCompositionLocalOf<SheetBeat?> { null }
+
+/** A settings group's piece of the sheet's entrance; nothing outside a sheet. */
+@Composable
+internal fun Modifier.sheetPiece(): Modifier {
+    val beat = LocalSheetBeat.current ?: return this
+    val i = remember { beat.take() }
+    return graphicsLayer {
+        val v = beat.value(i)
+        alpha = v
+        translationY = (1f - v) * 6.dp.toPx()
+    }
+}
+
+private val SheetInset = 12.dp
+private val SheetCorner = 18.dp
+private val ChipsTop = 14.dp
+private val RowsTop = 54.dp
+private const val PIECES = 12
+
+/**
+ * A hero with one big button and the sheet that lifts out from under it. [key] names the sheet
+ * (a hop comes back to it, the lip remembers what it said); [tabs] are its chips (id to label) and
+ * [rows] what each holds. [background] sinks and [words] fade as it opens. [button] draws the
+ * button itself with the click it should make; [onPrimary] is what that click does once the
+ * sheet is out of the way. [onOpen] reads the settings the rows show.
+ */
+@OptIn(ExperimentalComposeUiApi::class, androidx.compose.animation.ExperimentalAnimationApi::class)
+@Composable
+internal fun LiftHero(
+    key: String,
+    tabs: List<Pair<String, String>>,
+    onOpen: () -> Unit,
+    onPrimary: () -> Unit,
+    background: @Composable () -> Unit,
+    /**
+     * Drawn over [background] at the pane's own size: the wall's fades, which must not sink with
+     * it. Given how far the sheet is up (0 to 1), for anything there that should give way to it.
+     */
+    scrim: @Composable (lifted: () -> Float) -> Unit = {},
+    words: @Composable () -> Unit,
+    /**
+     * Buttons beside the big one (Desktop's Flathub and +). They stay where they are and fade as
+     * the sheet lifts: only the big button rides it.
+     */
+    beside: @Composable () -> Unit = {},
+    button: @Composable (onClick: () -> Unit) -> Unit,
+    rows: @Composable (tab: String) -> Unit,
+    modifier: Modifier = Modifier,
+    /**
+     * Down on the button lifts the sheet (Play). False: Down goes to the lip, which A lifts, and Down
+     * from the lip goes on past it to what is under the hero (Desktop's shelves).
+     */
+    downOpens: Boolean = true,
+    /** Told when the sheet starts to lift (true) and once it has gone (false). */
+    onOpenChange: (Boolean) -> Unit = {},
+    start: Dp = 44.dp,
+    bottom: Dp = 44.dp,
+) {
+    val density = LocalDensity.current
+    val inputMode = LocalInputModeManager.current
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val ff = LocalFrontFocus.current
+    val narrow = LocalNarrowPane.current
+    // Held as states too, so the sheet's focus rule reads what they are now, not at the last composition.
+    val openState = remember { mutableStateOf(false) }
+    var open by openState
+    var shown by remember { mutableStateOf(false) }
+    val launchingState = remember { mutableStateOf(false) }
+    var launching by launchingState
+    var tab by remember { mutableStateOf(0) }
+    var travel by remember { mutableStateOf(1) }
+    // The control to focus once a sheet put back by a hop's B has lifted, instead of the first chip.
+    var focusOnLift by remember { mutableStateOf<String?>(null) }
+    // Set as the sheet closes and Play lands: the lip may come back before the sheet has quite gone.
+    var lipBack by remember { mutableStateOf(false) }
+    // Set as a finger's drag lets go: the sheet is already where it is going.
+    var dragSettled by remember { mutableStateOf(false) }
+    val scope = androidx.compose.runtime.rememberCoroutineScope()
+    var dragJob by remember { mutableStateOf<Job?>(null) }
+    val onOpenNow = rememberUpdatedState(onOpen)
+    val pull = remember { Animatable(0f) }
+    val sink = remember { Animatable(0f) }
+    val lift = remember { Animatable(0f) }
+    val ride = remember { Animatable(0f) }
+    val hot = remember { Animatable(1f) }
+    val lipShow = remember { Animatable(0f) }
+    val lipGone = remember { Animatable(0f) }
+    val fold = remember { Animatable(0f) }
+    val foldTop = remember { Animatable(0f) }
+    val pieces = remember { List(PIECES) { Animatable(0f) } }
+    val chipFocus = remember(tabs.size) { List(tabs.size) { FocusRequester() } }
+    val playSrc = remember { MutableInteractionSource() }
+    val playHovered by playSrc.collectIsHoveredAsState()
+    var playFocused by remember { mutableStateOf(false) }
+    // Set as a pad leaves the sheet to the left for Play, which folds it once Play has focus.
+    val leftForPlay = remember { booleanArrayOf(false) }
+    var heroAt by remember { mutableStateOf(Offset.Zero) }
+    var rest by remember { mutableStateOf<Rect?>(null) }
+    fun focusPlay() { if (ff != null && inputMode.inputMode == InputMode.Keyboard) runCatching { ff.primary.requestFocus() } }
+    fun close() {
+        if (!open) return
+        // Focus leaves the rows before they go; the sheet lets it go once it is closing.
+        open = false
+        focusPlay()
+    }
+    // Back from a hop the sheet started (or a page it opened): put it back as it was.
+    LaunchedEffect(Unit) {
+        val r = Hops.restore ?: return@LaunchedEffect
+        if (r.surface != HOP_SURFACE_SHEET || r.rail != key) return@LaunchedEffect
+        Hops.restore = null
+        tab = tabs.indexOfFirst { it.first == r.tab }.coerceAtLeast(0)
+        focusOnLift = r.control
+        open = true
+    }
+    // Launched: the session covers the screen, and the sheet is put away under it.
+    val lifecycle = androidx.compose.ui.platform.LocalLifecycleOwner.current.lifecycle
+    DisposableEffect(lifecycle) {
+        val obs = androidx.lifecycle.LifecycleEventObserver { _, e ->
+            if (e == androidx.lifecycle.Lifecycle.Event.ON_STOP && (open || shown)) {
+                open = false; shown = false; launching = false
+            }
+        }
+        lifecycle.addObserver(obs)
+        onDispose { lifecycle.removeObserver(obs) }
+    }
+    LaunchedEffect(open, launching) {
+        if (!dragSettled) { dragJob?.cancel(); dragJob = null }
+        if (dragSettled) {
+            // A finger brought it here and has already animated it: only what opening needs.
+            dragSettled = false
+            if (open) {
+                if (inputMode.inputMode == InputMode.Keyboard) { withFrameNanos { }; runCatching { chipFocus[tab].requestFocus() } }
+            } else focusPlay()
+            return@LaunchedEffect
+        }
+        if (open && !launching) {
+            lipBack = false
+            shown = true
+            onOpen()
+            fold.snapTo(0f); foldTop.snapTo(0f)
+            coroutineScope {
+                // Pull: the lip stretches down as the wall sinks back and dims.
+                launch { pull.animateTo(24f, Motion.sp(0.7f, 380f)) }
+                launch { sink.animateTo(1f, Motion.tw(260)) }
+                // Lift: the sheet rises with Play riding its top edge; the lip lets go.
+                launch {
+                    delay(Motion.ms(120).toLong())
+                    launch { lipGone.animateTo(1f, Motion.tw(140)) }
+                    launch { pull.animateTo(0f, Motion.sp(1f, 500f)) }
+                    launch { lift.animateTo(1f, Motion.sp(0.7f, 380f)) }
+                    launch { ride.animateTo(1f, Motion.sp(0.7f, 380f)) }
+                    launch { hot.snapTo(1f); delay(Motion.ms(100).toLong()); hot.animateTo(0f, Motion.tw(200)) }
+                }
+                // Each piece on its beat from the Lift, as the reel has it: 260ms + 55ms a piece after it starts.
+                pieces.forEachIndexed { i, p -> launch { delay(Motion.ms(120 + 260 + i * 55).toLong()); p.animateTo(1f, Motion.tw(220)) } }
+                if (inputMode.inputMode == InputMode.Keyboard) launch {
+                    val control = focusOnLift
+                    focusOnLift = null
+                    delay(Motion.ms(if (control != null) 420 else 300).toLong())
+                    withFrameNanos { }
+                    val target = control?.let { ff?.items?.get(it) } ?: chipFocus[tab]
+                    runCatching { target.requestFocus() }
+                }
+            }
+        } else if (launching) {
+            // Play from the sheet: the rows go, the sheet folds into the pill, then the launch.
+            coroutineScope {
+                pieces.forEach { launch { it.animateTo(0f, Motion.tw(90)) } }
+                launch { delay(Motion.ms(60).toLong()); fold.animateTo(1f, Motion.sp(1f, 420f)) }
+                launch { delay(Motion.ms(160).toLong()); foldTop.animateTo(1f, Motion.sp(1f, 380f)) }
+            }
+            shown = false
+            onPrimary()
+            // The session covers the screen and the sheet is put away under it (ON_STOP). If
+            // nothing started, put it away anyway.
+            delay(3_000)
+            launching = false
+        } else if (shown) {
+            coroutineScope {
+                pieces.forEach { launch { it.animateTo(0f, Motion.tw(90)) } }
+                launch { delay(Motion.ms(60).toLong()); lift.animateTo(0f, Motion.sp(1f, 380f)) }
+                launch { delay(Motion.ms(100).toLong()); ride.animateTo(0f, Motion.sp(0.55f, 300f)) }
+                launch { sink.animateTo(0f, Motion.tw(300)) }
+                // The lip tucks back under Play as it lands, not once every spring has settled.
+                launch { delay(Motion.ms(420).toLong()); lipGone.snapTo(0f); lipBack = true }
+            }
+            shown = false
+            lipBack = false
+            lipGone.snapTo(0f)
+            hot.snapTo(1f)
+        } else {
+            // Snapped shut under a session: everything back at rest, no animation.
+            listOf(pull, sink, lift, ride, lipGone, fold, foldTop).forEach { it.snapTo(0f) }
+            pieces.forEach { it.snapTo(0f) }
+            hot.snapTo(1f)
+        }
+    }
+    BackHandler(enabled = open && !launching) { close() }
+    // The ring keeps out of the lift and the fold, and comes back on whatever has focus once
+    // they are done: Play rides the sheet on a layer, and the ring hung where Play had been.
+    if (ride.isRunning || (shown && !open)) VeilRing()
+    val openNow = open || shown
+    LaunchedEffect(openNow) { onOpenChange(openNow) }
+
+    // The lip: there while Play has a pad or a pointer on it, or always with touch alone.
+    val touchOnly = inputMode.inputMode == InputMode.Touch
+    val lipFocus = remember { FocusRequester() }
+    val settingsLabel = stringResource(R.string.drawer_page_settings)
+    var lipFocused by remember { mutableStateOf(false) }
+    val lipWanted = !open && (!shown || lipBack) && (playFocused || playHovered || touchOnly || lipFocused)
+    LaunchedEffect(lipWanted) {
+        if (lipWanted) {
+            // Back from the sheet it comes straight away; otherwise a beat after Play has focus.
+            if (!lipBack) delay(Motion.ms(160).toLong())
+            lipShow.animateTo(1f, Motion.tw(220))
+        } else {
+            delay(Motion.ms(140).toLong())
+            lipShow.animateTo(0f, Motion.tw(220))
+        }
+    }
+
+    // How far the sheet travels, for a finger's drag to follow: set once the hero is measured.
+    val travelPx = remember { floatArrayOf(1f) }
+    val drag = remember { SheetDrag() }
+    /** The sheet [p] of the way up (0 at rest, 1 open) under a finger. */
+    fun follow(p: Float) {
+        drag.progress = p
+        scope.launch {
+            lift.snapTo(p); ride.snapTo(p); sink.snapTo(p.coerceIn(0f, 1f)); hot.snapTo(0f)
+            lipGone.snapTo(1f)
+            pieces.forEach { it.snapTo(p.coerceIn(0f, 1f)) }
+        }
+    }
+    /** A finger takes the sheet where it is: up from rest, or down from open. */
+    fun beginDrag() {
+        dragJob?.cancel(); dragJob = null
+        dragSettled = false
+        drag.engaged = true
+        drag.from = if (open) 1f else 0f
+        drag.progress = drag.from
+        if (!open) {
+            shown = true
+            scope.launch { fold.snapTo(0f); foldTop.snapTo(0f) }
+            onOpenNow.value()
+        }
+    }
+    /**
+     * The finger lets go with [v] px/s (up negative): a flick goes the way it was flicked; a slow
+     * drag stays once it is a third of the way from where it started.
+     */
+    fun settleDrag(v: Float) {
+        drag.engaged = false
+        val flick = with(density) { 600.dp.toPx() }
+        val opens = when {
+            v < -flick -> true
+            v > flick -> false
+            drag.from > 0.5f -> drag.progress > 0.7f
+            else -> drag.progress > 0.3f
+        }
+        dragSettled = true
+        dragJob?.cancel()
+        dragJob = scope.launch {
+            val to = if (opens) 1f else 0f
+            coroutineScope {
+                launch { lift.animateTo(to, Motion.sp(if (opens) 0.7f else 1f, 380f)) }
+                launch { ride.animateTo(to, Motion.sp(if (opens) 0.7f else 0.55f, if (opens) 380f else 300f)) }
+                launch { sink.animateTo(to, Motion.tw(220)) }
+                pieces.forEachIndexed { i, piece -> launch { if (opens) delay(Motion.ms(i * 35).toLong()); piece.animateTo(to, Motion.tw(if (opens) 200 else 90)) } }
+            }
+            if (!opens) { shown = false; lipGone.snapTo(0f); hot.snapTo(1f); lipBack = false }
+        }
+        if (open != opens) open = opens else dragSettled = false
+    }
+    // Pulled down past the top of the rows, the sheet itself comes down with the finger; up again
+    // before letting go, it goes back up before the rows scroll.
+    val rowsPull = remember {
+        object : androidx.compose.ui.input.nestedscroll.NestedScrollConnection {
+            override fun onPreScroll(available: Offset, source: androidx.compose.ui.input.nestedscroll.NestedScrollSource): Offset {
+                if (!drag.engaged || available.y >= 0f) return Offset.Zero
+                val before = drag.progress
+                follow((before - available.y / travelPx[0]).coerceAtMost(1f))
+                return Offset(0f, (drag.progress - before) * -travelPx[0])
+            }
+            override fun onPostScroll(consumed: Offset, available: Offset, source: androidx.compose.ui.input.nestedscroll.NestedScrollSource): Offset {
+                if (available.y <= 0f || source != androidx.compose.ui.input.nestedscroll.NestedScrollSource.Drag || !openState.value || launchingState.value) return Offset.Zero
+                if (!drag.engaged) beginDrag()
+                follow((drag.progress - available.y / travelPx[0]).coerceIn(0f, 1f))
+                return available
+            }
+            override suspend fun onPreFling(available: androidx.compose.ui.unit.Velocity): androidx.compose.ui.unit.Velocity {
+                if (!drag.engaged) return androidx.compose.ui.unit.Velocity.Zero
+                settleDrag(available.y)
+                return available
+            }
+        }
+    }
+    BoxWithConstraints(
+        modifier.fillMaxSize().onGloballyPositioned { heroAt = it.boundsInRoot().topLeft }
+            // A swipe anywhere on the hero moves the sheet under the finger - up from rest, down
+            // when open - and lets go open or shut by how far it went and how fast. A swipe that
+            // starts the wrong way (down at rest) is left alone, for the page under it.
+            .pointerInput(Unit) {
+                val tracker = androidx.compose.ui.input.pointer.util.VelocityTracker()
+                var decided = false
+                detectVerticalDragGestures(
+                    onDragStart = { tracker.resetTracking(); decided = false; drag.engaged = false },
+                    onDragEnd = { if (drag.engaged) settleDrag(tracker.calculateVelocity().y) },
+                    onDragCancel = { if (drag.engaged) settleDrag(0f) },
+                ) { change, amount ->
+                    if (launching) return@detectVerticalDragGestures
+                    if (!decided) {
+                        decided = true
+                        // Up at rest opens; down when open closes. Anything else is not for the sheet.
+                        if (if (open) amount > 0f else amount < 0f) beginDrag()
+                    }
+                    if (!drag.engaged) return@detectVerticalDragGestures
+                    change.consume()
+                    tracker.addPosition(change.uptimeMillis, change.position)
+                    follow((drag.progress - amount / travelPx[0]).coerceIn(0f, 1.04f))
+                }
+            },
+    ) {
+        val w = constraints.maxWidth.toFloat()
+        val h = constraints.maxHeight.toFloat()
+        val inset = with(density) { SheetInset.toPx() }
+        val restRect = rest?.translate(-heroAt)
+        val buttonH = restRect?.height ?: with(density) { 56.dp.toPx() }
+        val openTop = sheetTop(h, buttonH, with(density) { 16.dp.toPx() }, with(density) { 3.dp.toPx() })
+        // Play's raised place: its centre 3dp under the sheet's edge, same left inset.
+        val raise = restRect?.let { (openTop + with(density) { 3.dp.toPx() } - buttonH / 2f) - it.top } ?: 0f
+        travelPx[0] = (h - openTop).coerceAtLeast(1f)
+
+        // The wall behind sinks back about the pane's centre.
+        val foot = h
+        Box(Modifier.fillMaxSize().clipToBounds().graphicsLayer { val k = 1f - 0.05f * sink.value; scaleX = k; scaleY = k }) { background() }
+        // The fades stay put: scaled with the wall they stopped short of the pane's edges and left
+        // a bright band of unfaded wall down the side and along the top.
+        scrim { sink.value }
+        // The dim; a tap on it (above the sheet) folds the sheet away.
+        if (shown || open) Box(
+            Modifier.fillMaxSize()
+                .graphicsLayer { alpha = sink.value }.background(Color.Black.copy(alpha = 0.42f))
+                .focusProperties { canFocus = false }
+                .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, enabled = open && !launching) { close() },
+        )
+
+        // The sheet: inset at the sides, rounded at the top, no bottom edge - the pane's foot is its foot.
+        if (shown) {
+            val top = lerp(foot, openTop, lift.value)
+            val sheetLeft = inset
+            val sheetRight = w - inset
+            val path = remember { Path() }
+            val rimPath = remember { Path() }
+            val corner = with(density) { SheetCorner.toPx() }
+            val rim = with(density) { 1.4.dp.toPx() }
+            val pill = restRect?.translate(0f, raise)
+            Canvas(Modifier.fillMaxSize()) {
+                val f = fold.value
+                val ft = foldTop.value
+                val l = if (pill != null) lerp(sheetLeft, pill.left, f) else sheetLeft
+                val r = if (pill != null) lerp(sheetRight, pill.right, f) else sheetRight
+                val t = if (pill != null) lerp(top, pill.top, ft) else top
+                val b = if (pill != null) lerp(foot + corner, pill.bottom, ft) else foot + corner
+                val c = if (pill != null) lerp(corner, with(density) { 12.dp.toPx() }, ft) else corner
+                val bc = if (ft > 0f) c else 0f
+                path.reset()
+                path.addRoundRect(RoundRect(l, t, r, b, CornerRadius(c), CornerRadius(c), CornerRadius(bc), CornerRadius(bc)))
+                val fill = lerp(colors.surface, pal.signal, 0.22f * hot.value)
+                drawPath(path, fill)
+                val rimColor = pal.signal.copy(alpha = lerp(0.55f, 0.9f, hot.value))
+                if (ft > 0f) drawPath(path, rimColor, style = Stroke(rim))
+                else {
+                    // Sides and top only: the sheet runs on under the pane's foot.
+                    rimPath.reset()
+                    rimPath.moveTo(l, b)
+                    rimPath.lineTo(l, t + c)
+                    rimPath.arcTo(Rect(l, t, l + 2 * c, t + 2 * c), 180f, 90f, false)
+                    rimPath.lineTo(r - c, t)
+                    rimPath.arcTo(Rect(r - 2 * c, t, r, t + 2 * c), -90f, 90f, false)
+                    rimPath.lineTo(r, b)
+                    drawPath(rimPath, rimColor, style = Stroke(rim))
+                }
+            }
+            // What the sheet holds: the chips to the right of Play, the rows under them.
+            val chipsX = with(density) {
+                if (narrow || pill == null) 16.dp.toPx() else pill.right + 20.dp.toPx() - sheetLeft
+            }
+            val chipsY = with(density) { if (narrow && pill != null) (pill.bottom - openTop) + 10.dp.toPx() else ChipsTop.toPx() }
+            // The rows start under the chips, which are 44dp to touch: from 54dp they ran under the
+            // chips' feet and, scrolled, covered them.
+            val rowsY = with(density) { maxOf(RowsTop.toPx(), chipsY + 52.dp.toPx()) }
+            val sheetW = sheetRight - sheetLeft
+            Box(
+                Modifier
+                    .offset { IntOffset(sheetLeft.roundToInt(), top.roundToInt()) }
+                    .size(with(density) { sheetW.toDp() }, with(density) { (foot - openTop).coerceAtLeast(0f).toDp() })
+                    // Touches on the sheet stay on it; none reach the dim behind.
+                    .pointerInput(Unit) { detectTapGestures { } }
+                    .controllerBack { close() }
+                    .bumpers(
+                        // LB / RB: focus goes to the new tab's chip, so a pad on a row (which goes with
+                        // its tab) is never left with nothing.
+                        onPrevious = { if (tab > 0) { travel = -1; tab--; runCatching { chipFocus[tab].requestFocus() } } },
+                        onNext = { if (tab < tabs.lastIndex) { travel = 1; tab++; runCatching { chipFocus[tab].requestFocus() } } },
+                    )
+                    // A pad stays in the sheet until it folds; Left from it reaches Play, the handle, and folds it.
+                    .focusProperties { exit = { dir -> if (!openState.value || launchingState.value) FocusRequester.Default else if (dir == FocusDirection.Left && ff != null) { leftForPlay[0] = true; ff.primary } else FocusRequester.Cancel } }
+                    .focusGroup(),
+            ) {
+                Box(
+                    Modifier
+                        .offset { IntOffset(chipsX.roundToInt(), chipsY.roundToInt()) }
+                        // Over the rows, whatever they scroll under them.
+                        .zIndex(1f)
+                        .width(with(density) { (sheetW - chipsX - 64.dp.toPx()).coerceAtLeast(0f).toDp() })
+                        .graphicsLayer { val v = pieces[0].value; alpha = v; translationY = (1f - v) * 6.dp.toPx() }
+                        // Up from the chips folds the sheet (a finger drags it down, see the hero's drag).
+                        .onPreviewKeyEvent { e ->
+                            val k = e.nativeKeyEvent
+                            if (k.keyCode == KeyEvent.KEYCODE_DPAD_UP) { if (k.action == KeyEvent.ACTION_DOWN) close(); true } else false
+                        },
+                ) {
+                    SheetChips(tabs.map { it.second }, tab, chipFocus) { i -> travel = if (i > tab) 1 else -1; tab = i }
+                }
+                Box(
+                    Modifier
+                        .offset { IntOffset(0, rowsY.roundToInt()) }
+                        .nestedScroll(rowsPull)
+                        .fillMaxWidth()
+                        .height(with(density) { (foot - openTop - rowsY).coerceAtLeast(0f).toDp() }),
+                ) {
+                    AnimatedContent(
+                        targetState = tab,
+                        transitionSpec = {
+                            val d = travel
+                            val shift = with(density) { 24.dp.roundToPx() }
+                            (slideInHorizontally(Motion.tw(240)) { shift * d } + fadeIn(Motion.tw(240)))
+                                .togetherWith(slideOutHorizontally(Motion.tw(240)) { -shift * d } + fadeOut(Motion.tw(240)))
+                        },
+                        label = "sheetTab",
+                    ) { t ->
+                        val leaving = transition.targetState == androidx.compose.animation.EnterExitState.PostExit
+                        val leavingNow = rememberUpdatedState(leaving)
+                        CompositionLocalProvider(LocalSheetBeat provides remember { SheetBeat(pieces) }) {
+                            Column(
+                                Modifier.fillMaxSize()
+                                    // Focus never lands in rows on their way out. Same group always, only
+                                    // its rule changes (canFocus here made the scroll's own group a stop).
+                                    .focusProperties { enter = { if (leavingNow.value) FocusRequester.Cancel else FocusRequester.Default } }
+                                    .focusGroup()
+                                    .verticalScroll(rememberScrollState())
+                                    .padding(start = 16.dp, end = 16.dp, bottom = 24.dp),
+                            ) { rows(tabs[t].first) }
+                        }
+                    }
+                }
+                val closeSource = remember { MutableInteractionSource() }
+                val closeHot = rememberHot(closeSource)
+                Box(
+                    contentAlignment = Alignment.Center,
+                    modifier = Modifier
+                        .offset { IntOffset((sheetW - 52.dp.toPx()).roundToInt(), chipsY.roundToInt()) }
+                        .zIndex(1f).size(44.dp).testTag("sheet-close")
+                        .clip(CircleShape).glideBorder(closeHot, CircleShape, pal.signal)
+                        .hoverable(closeSource)
+                        .clickable(interactionSource = closeSource, indication = LocalIndication.current, enabled = open && !launching, role = Role.Button) { close() }
+                        .controllerConfirm(enabled = open && !launching) { close() },
+                ) { Icon(Icons.Filled.Close, stringResource(R.string.common_close), tint = colors.onSurfaceVariant, modifier = Modifier.size(20.dp)) }
+            }
+        }
+
+        // The words and the button, where they always were; the button rides the sheet's edge.
+        Column(Modifier.align(Alignment.BottomStart).padding(start = start, bottom = bottom, end = 20.dp)) {
+            Box(Modifier.graphicsLayer { alpha = 1f - sink.value }) { words() }
+            Spacer(Modifier.height(18.dp))
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+            Box(
+                Modifier
+                    .onGloballyPositioned { rest = it.boundsInRoot() }
+                    .graphicsLayer { translationY = raise * ride.value }
+                    .onFocusChanged {
+                        // Left out of the sheet (from the chips or a row) folds it, as Up from the chips does.
+                        if (it.hasFocus && leftForPlay[0]) { leftForPlay[0] = false; if (openState.value && !launchingState.value) close() }
+                        playFocused = it.hasFocus
+                    }
+                    .hoverable(playSrc)
+                    .onPreviewKeyEvent { e ->
+                        val k = e.nativeKeyEvent
+                        if (k.keyCode != KeyEvent.KEYCODE_DPAD_DOWN) false
+                        else {
+                            if (k.action == KeyEvent.ACTION_DOWN && k.repeatCount == 0) {
+                                if (open) runCatching { chipFocus[tab].requestFocus() }
+                                else if (downOpens) open = true
+                                else runCatching { lipFocus.requestFocus() }
+                            }
+                            true
+                        }
+                    },
+            ) {
+                button {
+                    if (launching) return@button
+                    if (open || shown) { launching = true; open = false } else onPrimary()
+                }
+            }
+            // Gone with the words while the sheet is up; nothing a pad or a finger can reach then.
+            val besideShown = !(open || shown)
+            Row(
+                verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp),
+                modifier = Modifier.graphicsLayer { alpha = 1f - sink.value }
+                    .focusProperties { canFocus = besideShown },
+            ) { if (besideShown || sink.value < 0.99f) beside() }
+            }
+        }
+
+        // The lip, under Play: stretched by the pull, gone as the sheet lifts.
+        val r0 = restRect
+        // A lip a pad can reach stays composed (unseen at rest) so Down always has it to land on.
+        if (r0 != null && (lipShow.value > 0.01f || pull.value > 0.5f || (!downOpens && !open && !shown))) {
+            var handleW by remember { mutableStateOf(0f) }
+            val lipH = 32.dp + pull.value.dp
+            val lift = { if (!open) open = true }
+            Box(
+                Modifier
+                    .offset { IntOffset((r0.center.x - handleW / 2f).roundToInt(), (r0.bottom + raise * ride.value + (lipShow.value - 1f) * 8.dp.toPx()).roundToInt()) }
+                    .onSizeChanged { handleW = it.width.toFloat() }
+                    .graphicsLayer { alpha = lipShow.value * (1f - lipGone.value) }
+                    // 44dp to touch, with a 32dp visible handle.
+                    .heightIn(min = 44.dp).testTag("sheet-open")
+                    .semantics { contentDescription = settingsLabel }
+                    .then(
+                        if (downOpens) Modifier.focusProperties { canFocus = false }
+                        else Modifier.focusRequester(lipFocus).onFocusChanged { lipFocused = it.isFocused }.controllerConfirm(onClick = lift),
+                    )
+                    .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, role = Role.Button, onClick = lift),
+            ) {
+                Box(Modifier.glideBorder(lipFocused, RoundedCornerShape(bottomStart = 12.dp, bottomEnd = 12.dp), LocalPalette.current.signal)) {
+                    Handle(lipH)
+                }
+            }
+        }
+    }
+}
+
+/**
+ * The sheet's handle, tucked under Play: "Settings" and a chevron that bobs up every so often,
+ * saying there is a drawer to pull up. Still with animations off.
+ */
+@Composable
+private fun Handle(height: Dp) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val shape = RoundedCornerShape(bottomStart = 12.dp, bottomEnd = 12.dp)
+    val still = Motion.scale == 0f
+    val bob = androidx.compose.animation.core.rememberInfiniteTransition(label = "handle")
+    // A quick lift and settle, then a rest: a nudge, not a pulse.
+    val lift by bob.animateFloat(
+        0f, 0f,
+        androidx.compose.animation.core.infiniteRepeatable(
+            androidx.compose.animation.core.keyframes {
+                durationMillis = 2400
+                0f at 0
+                1f at 180 using androidx.compose.animation.core.FastOutSlowInEasing
+                -0.25f at 420
+                0f at 620
+            },
+        ),
+        label = "handleBob",
+    )
+    Row(
+        verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp),
+        modifier = Modifier.height(height).clip(shape).background(colors.surface)
+            .drawBorderSidesAndFoot(pal.line, 12.dp)
+            .padding(start = 14.dp, end = 10.dp),
+    ) {
+        Text(stringResource(R.string.drawer_page_settings), fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurfaceVariant, maxLines = 1)
+        Icon(
+            Icons.Filled.KeyboardArrowUp, null, tint = colors.onSurfaceVariant,
+            modifier = Modifier.size(16.dp).graphicsLayer { translationY = if (still) 0f else -3.dp.toPx() * lift },
+        )
+    }
+}
+
+/** A 1dp outline down the sides and along the foot, none along the top (the lip tucks under Play). */
+private fun Modifier.drawBorderSidesAndFoot(color: Color, corner: Dp): Modifier =
+    this.drawWithContent {
+        drawContent()
+        val c = corner.toPx()
+        val sw = 1.dp.toPx()
+        val p = Path().apply {
+            moveTo(sw / 2, 0f)
+            lineTo(sw / 2, size.height - c)
+            arcTo(Rect(sw / 2, size.height - 2 * c + sw / 2, 2 * c, size.height - sw / 2), 180f, -90f, false)
+            lineTo(size.width - c, size.height - sw / 2)
+            arcTo(Rect(size.width - 2 * c, size.height - 2 * c + sw / 2, size.width - sw / 2, size.height - sw / 2), 90f, -90f, false)
+            lineTo(size.width - sw / 2, 0f)
+        }
+        drawPath(p, color, style = Stroke(sw))
+    }
+
+/**
+ * The sheet's chips: equal capsules with one selection gliding under them (the stores' chip row),
+ * LB and RB a chip at a time, a tap or A on a far one a hop as a drop. A pad picks a chip by
+ * moving onto it, and comes into the row on the picked one. [first] takes focus as the sheet
+ * opens. Too narrow for equal chips, the row scrolls.
+ */
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+internal fun SheetChips(labels: List<String>, selected: Int, focus: List<FocusRequester>? = null, onPick: (Int) -> Unit) {
+    val pal = LocalPalette.current
+    val bounds = remember { mutableStateMapOf<Int, Rect>() }
+    val tint = rememberUpdatedState(pal.signal)
+    // Each chip its own requester: one moved from chip to chip under a focused chip lost the ring.
+    val chips = focus ?: remember(labels.size) { List(labels.size) { FocusRequester() } }
+    var within by remember { mutableStateOf(false) }
+    // LB / RB with a pad on the chips: focus goes with the selection.
+    LaunchedEffect(selected) { if (within) runCatching { chips[selected].requestFocus() } }
+    BoxWithConstraints(Modifier.fillMaxWidth().onFocusChanged { within = it.hasFocus }) {
+        val equal = maxWidth / labels.size.coerceAtLeast(1) >= 96.dp
+        val scroll = rememberScrollState()
+        // Room inside the scroll for the focus ring, which the scroll's clip would otherwise cut.
+        Box(if (equal) Modifier.fillMaxWidth() else Modifier.edgeFade(scroll).horizontalScroll(scroll).padding(3.dp)) {
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(6.dp),
+                // Up from the rows lands on the picked chip, not whichever sits above: landing picks.
+                modifier = (if (equal) Modifier.fillMaxWidth() else Modifier)
+                    .focusProperties { enter = { chips.getOrNull(selected) ?: FocusRequester.Default } }
+                    .focusGroup(),
+            ) {
+                labels.forEachIndexed { i, label ->
+                    val m = (if (equal) Modifier.weight(1f) else Modifier.widthIn(min = 64.dp))
+                        .onGloballyPositioned { bounds[i] = it.boundsInParent() }
+                        .focusRequester(chips[i])
+                    SheetChip(label, i == selected, m.onFocusChanged { if (it.isFocused && i != selected) onPick(i) }) { onPick(i) }
+                }
+            }
+            // Over the chips: under them, their rest fill hid it as it crossed them.
+            ChipGlide(selected, bounds[selected], tint)
+        }
+    }
+}
+
+@Composable
+private fun SheetChip(label: String, on: Boolean, modifier: Modifier, onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val shape = RoundedCornerShape(99.dp)
+    // The row's glide draws the picked chip's look by touch only; with a pad it draws its own rest
+    // look, and the bar says which is picked.
+    val under = on && LocalInputModeManager.current.inputMode != InputMode.Keyboard
+    Box(
+        contentAlignment = Alignment.Center,
+        modifier = modifier.heightIn(min = 44.dp).clip(shape)
+            .background(if (under) Color.Transparent else colors.surfaceVariant.copy(alpha = 0.5f))
+            .shownBar(on, pal.signal)
+            .glideBorder(hot, shape, pal.signal, if (under) Color.Transparent else pal.line)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Tab, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .padding(horizontal = 14.dp, vertical = 8.dp),
+    ) {
+        Text(label, fontSize = 13.sp, fontWeight = FontWeight.Bold, color = if (on || hot) colors.onBackground else colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+    }
+}
+
+/**
+ * A read-only line that is a link: [title], [value] under it, and "[link] ↗" at the right in the
+ * signal blue - not a picker, so no value box. A (or a tap) follows it. [id] is its focus key.
+ */
+@Composable
+internal fun LinkRow(title: String, value: String, link: String, id: String, arrow: String = "↗", onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val src = remember { MutableInteractionSource() }
+    val hot = rememberHot(src)
+    val shape = RoundedCornerShape(12.dp)
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier.fillMaxWidth().paneItem(id).hopSource(id).heightIn(min = 56.dp).clip(shape)
+            .background(if (hot) pal.signal.copy(alpha = 0.10f) else Color.Transparent)
+            .glideBorder(hot, shape, pal.signal)
+            .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Button, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .padding(horizontal = 14.dp, vertical = 11.dp),
+    ) {
+        Column(Modifier.weight(1f).padding(end = 12.dp)) {
+            Text(title, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)
+            Text(value, fontSize = 12.5.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 2.dp), maxLines = 1, overflow = TextOverflow.Ellipsis)
+        }
+        Text("$link $arrow", fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = pal.signal, maxLines = 1)
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt

@@ -23,6 +23,8 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.compose.ui.layout.boundsInRoot
+import androidx.compose.ui.layout.onGloballyPositioned
 import com.droiddeck.launcher.core.FexPreset
 import com.droiddeck.launcher.runtime.DeckyManager
 import com.droiddeck.launcher.session.SessionPrefs
@@ -152,293 +154,171 @@ class ModeSettingsActions(
     val onDismiss: () -> Unit,
 )
 
-private enum class ModeSettingsTab(val label: Int) {
-    DISPLAY(R.string.drawer_page_display),
-    CONTROLS(R.string.drawer_page_controls),
-    GAMES(R.string.game_settings_title),
-    AUDIO(R.string.mode_audio),
-    SESSION(R.string.mode_session),
-    STEAM(R.string.mode_tab_steam),
+/**
+ * The chips of a mode's lifted sheet, in order: Steam's six; the desktop's Display, Controls and
+ * Session (its Files chip is the Desktop page's own).
+ */
+internal fun modeSheetTabs(steam: Boolean): List<String> =
+    if (steam) listOf(SheetTab.STEAM, SheetTab.DISPLAY, SheetTab.CONTROLS, SheetTab.AUDIO, SheetTab.SESSION, SheetTab.LIBRARY)
+    else listOf(SheetTab.DISPLAY, SheetTab.CONTROLS, SheetTab.SESSION)
+
+/** A sheet tab's chip label. */
+@Composable
+internal fun sheetTabLabel(tab: String): String = when (tab) {
+    SheetTab.DISPLAY -> stringResource(R.string.drawer_page_display)
+    SheetTab.CONTROLS -> stringResource(R.string.drawer_page_controls)
+    SheetTab.AUDIO -> stringResource(R.string.mode_audio)
+    SheetTab.SESSION -> stringResource(R.string.mode_session)
+    SheetTab.LIBRARY -> stringResource(R.string.stores_tab_library)
+    SheetTab.STEAM -> stringResource(R.string.mode_tab_steam)
+    else -> stringResource(R.string.setup_tool_files)
 }
 
+/**
+ * Rows the front end adds to a sheet's tabs: frame generation (Display), Performance (Session) and
+ * the Graphics drivers link to Components (Display, given the drivers' summary).
+ */
+class SheetExtras(
+    val frameGen: @Composable () -> Unit = {},
+    val performance: @Composable () -> Unit = {},
+    val drivers: @Composable (summary: String?) -> Unit = {},
+    /** The Steam tab's account rows (offline mode), from the front end's own state. */
+    val account: @Composable (host: MenuHost) -> Unit = {},
+)
+
+/** One tab of a mode's lifted sheet: the rows the settings page had, grouped by what they are for. */
 @Composable
-fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) {
+fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: SheetExtras = SheetExtras()) {
     val steam = s.mode == SessionService.MODE_STEAM
     val host = rememberMenuHost()
-    var confirmDeckyRemoval by remember { mutableStateOf(false) }
     var explainWifiDiscovery by remember { mutableStateOf(false) }
-    var tabIndex by androidx.compose.runtime.saveable.rememberSaveable(s.mode) { mutableStateOf(0) }
-    val tabs = if (steam) ModeSettingsTab.entries else listOf(
-        ModeSettingsTab.DISPLAY, ModeSettingsTab.CONTROLS, ModeSettingsTab.SESSION,
-    )
-    val tab = tabs[tabIndex]
-    val scrolls = tabs.map { androidx.compose.foundation.rememberScrollState() }
-    val tabFocus = remember(s.mode) { tabs.map { androidx.compose.ui.focus.FocusRequester() } }
-    val firstChip = remember { androidx.compose.ui.focus.FocusRequester() }
-    fun selectTab(index: Int) { host.open = null; tabIndex = index }
-    androidx.compose.runtime.LaunchedEffect(steam, tabIndex) {
-        androidx.compose.runtime.withFrameNanos { }
-        runCatching {
-            if (tab == ModeSettingsTab.DISPLAY) firstChip.requestFocus()
-            else tabFocus[tabIndex].requestFocus()
+    if (tab == SheetTab.DISPLAY) {
+        val displaySize = com.droiddeck.launcher.session.SessionDisplay.resolveChoice(s.panelSize, s.resolution)
+        SettingsGroup(stringResource(R.string.display_session)) {
+            ResolutionRow(host, s.resolution, s.panelSize, a.onResolution)
+            if (s.stretch16x9 != null && (com.droiddeck.launcher.session.SessionDisplay.canStretch16x9(s.panelSize) ||
+                    com.droiddeck.launcher.session.SessionDisplay.canStretch16x9(displaySize))) {
+                val canStretch = com.droiddeck.launcher.session.SessionDisplay.canStretch16x9(displaySize)
+                ChoiceRow(host, "game-fit", stringResource(R.string.display_game_fit),
+                    stringResource(if (canStretch) R.string.display_game_fit_hint else R.string.display_game_fit_unavailable),
+                    listOf(false to stringResource(R.string.display_preserve), true to stringResource(R.string.display_stretch)),
+                    s.stretch16x9 && canStretch, enabled = canStretch, onPick = a.onStretch16x9)
+            }
+        }
+        SettingsGroup(stringResource(R.string.display_image_scaling)) {
+            ChoiceRow(
+                host, "upscaler", stringResource(R.string.display_filter), null,
+                SessionPrefs.upscalerChoices(LocalContext.current), s.upscaler,
+                note = stringResource(R.string.display_filter_note), onPick = a.onUpscaler,
+            )
+            if (SessionPrefs.upscalerHasSharpness(s.upscaler)) SliderRow(
+                stringResource(R.string.display_sharpness), null, s.upscaleSharpness, 0..100, step = 5,
+                format = { "$it%" }, onChange = a.onUpscaleSharpness,
+            )
+        }
+        SettingsGroup(stringResource(R.string.display_frame_rate)) {
+            ChoiceRow(host, "fps", stringResource(R.string.mode_fps), stringResource(R.string.common_applies_next_session),
+                SessionPrefs.fpsLimitChoices(LocalContext.current), s.fpsLimit, note = stringResource(R.string.mode_fps_note), onPick = a.onFpsLimit)
+        }
+        SettingsGroup(stringResource(R.string.mode_hdr)) {
+            ToggleRow(
+                host, "hdr", stringResource(R.string.mode_hdr10),
+                s.hdrReason?.let { stringResource(R.string.mode_hdr_unavailable, it) }
+                    ?: stringResource(R.string.mode_hdr_restart),
+                checked = s.hdr && s.hdrReason == null, enabled = s.hdrReason == null, onChange = a.onHdr,
+            )
+        }
+        extras.frameGen()
+        extras.drivers(s.gpuDrivers)
+    }
+    if (tab == SheetTab.CONTROLS) {
+        SettingsGroup(if (steam) stringResource(R.string.mode_touch_controls) else stringResource(R.string.mode_touch)) {
+            ChoiceRow(
+                host, "touch", stringResource(R.string.mode_touch), null,
+                listOf(SessionPrefs.TOUCH_AUTO to stringResource(R.string.common_auto), SessionPrefs.TOUCH_PAD to stringResource(R.string.mode_touch_touchpad), SessionPrefs.TOUCH_DIRECT to stringResource(R.string.mode_touch_direct), SessionPrefs.TOUCH_OFF to stringResource(R.string.widgets_off)), s.touchMode,
+                note = stringResource(R.string.mode_touch_note),
+                onPick = a.onTouch,
+            )
+            if (steam && s.oscMode != null) ChoiceRow(
+                host, "osc", stringResource(R.string.mode_osc), null,
+                listOf(
+                    SessionPrefs.OSC_AUTO to stringResource(R.string.common_auto),
+                    SessionPrefs.OSC_ALWAYS to stringResource(R.string.common_always),
+                    SessionPrefs.OSC_STEAM_TOUCH to stringResource(R.string.osc_steam_touch),
+                    SessionPrefs.OSC_STEAM_QAM to stringResource(R.string.mode_osc_qam),
+                    SessionPrefs.OSC_NEVER to stringResource(R.string.common_never),
+                ), s.oscMode,
+                note = stringResource(R.string.mode_osc_note), onPick = a.onOsc,
+            )
+            if (steam && s.steamController != null) ChoiceRow(
+                host, "controller", stringResource(R.string.mode_controller), stringResource(R.string.mode_controller_hint),
+                listOf(
+                    SessionPrefs.CONTROLLER_DECK to stringResource(R.string.mode_controller_deck),
+                    SessionPrefs.CONTROLLER_STEAM to stringResource(R.string.mode_controller_steam),
+                    SessionPrefs.CONTROLLER_DS4 to stringResource(R.string.mode_controller_ds4),
+                    SessionPrefs.CONTROLLER_DUALSENSE to stringResource(R.string.mode_controller_dualsense),
+                    SessionPrefs.CONTROLLER_XBOX360 to stringResource(R.string.mode_controller_x360),
+                ), s.steamController,
+                note = stringResource(R.string.mode_controller_note),
+                onPick = a.onSteamController,
+            )
+            if (steam && s.unfoldedControls != null) ToggleRow(
+                host, "unfolded-controls", stringResource(R.string.unfolded_controls),
+                stringResource(R.string.unfolded_controls_hint),
+                s.unfoldedControls, onChange = a.onUnfoldedControls,
+            )
+            if (steam) ChoiceRow(
+                host, "back-actions", stringResource(R.string.mode_back), stringResource(SessionPrefs.backActionsOrder(s.backActionsInverted)),
+                listOf(
+                    false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM),
+                    true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU),
+                ), s.backActionsInverted, onPick = a.onBackActionsInverted,
+            )
         }
     }
-    SettingsPage(
-        host,
-        title = null,
-        onBack = a.onDismiss,
-        scroll = scrolls[tabIndex],
-        modifier = Modifier.bumpers(
-            onPrevious = { selectTab((tabIndex + tabs.size - 1) % tabs.size) },
-            onNext = { selectTab((tabIndex + 1) % tabs.size) },
-        ),
-        header = {
-            TabStrip(tabs.map { stringResource(it.label) }, tabIndex, ::selectTab,
-                modifier = Modifier.fillMaxWidth(), focusRequesters = tabFocus)
-        },
-    ) {
-        if (tab == ModeSettingsTab.DISPLAY) {
-            val displaySize = com.droiddeck.launcher.session.SessionDisplay.resolveChoice(s.panelSize, s.resolution)
-            SettingsGroup(stringResource(R.string.display_session)) {
-                ResolutionRow(host, s.resolution, s.panelSize, a.onResolution,
-                    chipModifier = Modifier.focusRequester(firstChip))
-                if (s.stretch16x9 != null && (com.droiddeck.launcher.session.SessionDisplay.canStretch16x9(s.panelSize) ||
-                        com.droiddeck.launcher.session.SessionDisplay.canStretch16x9(displaySize))) {
-                    val canStretch = com.droiddeck.launcher.session.SessionDisplay.canStretch16x9(displaySize)
-                    ChoiceRow(host, "game-fit", stringResource(R.string.display_game_fit),
-                        stringResource(if (canStretch) R.string.display_game_fit_hint else R.string.display_game_fit_unavailable),
-                        listOf(false to stringResource(R.string.display_preserve), true to stringResource(R.string.display_stretch)),
-                        s.stretch16x9 && canStretch, enabled = canStretch, onPick = a.onStretch16x9)
-                }
-            }
-            SettingsGroup(stringResource(R.string.display_image_scaling)) {
-                ChoiceRow(
-                    host, "upscaler", stringResource(R.string.display_filter), null,
-                    SessionPrefs.upscalerChoices(LocalContext.current), s.upscaler,
-                    note = stringResource(R.string.display_filter_note), onPick = a.onUpscaler,
-                )
-                if (SessionPrefs.upscalerHasSharpness(s.upscaler)) SliderRow(
-                    stringResource(R.string.display_sharpness), null, s.upscaleSharpness, 0..100, step = 5,
-                    format = { "$it%" }, onChange = a.onUpscaleSharpness,
-                )
-            }
-            SettingsGroup(stringResource(R.string.display_frame_rate)) {
-                ChoiceRow(host, "fps", stringResource(R.string.mode_fps), stringResource(R.string.common_applies_next_session),
-                    SessionPrefs.fpsLimitChoices(LocalContext.current), s.fpsLimit, note = stringResource(R.string.mode_fps_note), onPick = a.onFpsLimit)
-            }
-            SettingsGroup(stringResource(R.string.mode_hdr)) {
-                ToggleRow(
-                    host, "hdr", stringResource(R.string.mode_hdr10),
-                    s.hdrReason?.let { stringResource(R.string.mode_hdr_unavailable, it) }
-                        ?: stringResource(R.string.mode_hdr_restart),
-                    checked = s.hdr && s.hdrReason == null, enabled = s.hdrReason == null, onChange = a.onHdr,
-                )
-            }
-            SettingsGroup(stringResource(R.string.mode_drivers)) {
-                SettingsRow(stringResource(R.string.mode_gpu_drivers), stringResource(R.string.mode_gpu_drivers_hint)) {
-                    ValueChip(s.gpuDrivers ?: stringResource(R.string.common_auto), open = false) { a.onGpuDrivers() }
-                }
-            }
-        }
-        if (tab == ModeSettingsTab.CONTROLS) {
-            SettingsGroup(if (steam) stringResource(R.string.mode_touch_controls) else stringResource(R.string.mode_touch)) {
-                ChoiceRow(
-                    host, "touch", stringResource(R.string.mode_touch), null,
-                    listOf(SessionPrefs.TOUCH_AUTO to stringResource(R.string.common_auto), SessionPrefs.TOUCH_PAD to stringResource(R.string.mode_touch_touchpad), SessionPrefs.TOUCH_DIRECT to stringResource(R.string.mode_touch_direct), SessionPrefs.TOUCH_OFF to stringResource(R.string.widgets_off)), s.touchMode,
-                    note = stringResource(R.string.mode_touch_note),
-                    onPick = a.onTouch,
-                )
-                if (steam && s.oscMode != null) ChoiceRow(
-                    host, "osc", stringResource(R.string.mode_osc), null,
-                    listOf(
-                        SessionPrefs.OSC_AUTO to stringResource(R.string.common_auto),
-                        SessionPrefs.OSC_ALWAYS to stringResource(R.string.common_always),
-                        SessionPrefs.OSC_STEAM_TOUCH to stringResource(R.string.osc_steam_touch),
-                        SessionPrefs.OSC_STEAM_QAM to stringResource(R.string.mode_osc_qam),
-                        SessionPrefs.OSC_NEVER to stringResource(R.string.common_never),
-                    ), s.oscMode,
-                    note = stringResource(R.string.mode_osc_note), onPick = a.onOsc,
-                )
-                if (steam && s.steamController != null) ChoiceRow(
-                    host, "controller", stringResource(R.string.mode_controller), stringResource(R.string.mode_controller_hint),
-                    listOf(
-                        SessionPrefs.CONTROLLER_DECK to stringResource(R.string.mode_controller_deck),
-                        SessionPrefs.CONTROLLER_STEAM to stringResource(R.string.mode_controller_steam),
-                        SessionPrefs.CONTROLLER_DS4 to stringResource(R.string.mode_controller_ds4),
-                        SessionPrefs.CONTROLLER_DUALSENSE to stringResource(R.string.mode_controller_dualsense),
-                        SessionPrefs.CONTROLLER_XBOX360 to stringResource(R.string.mode_controller_x360),
-                    ), s.steamController,
-                    note = stringResource(R.string.mode_controller_note),
-                    onPick = a.onSteamController,
-                )
-                if (steam && s.unfoldedControls != null) ToggleRow(
-                    host, "unfolded-controls", stringResource(R.string.unfolded_controls),
-                    stringResource(R.string.unfolded_controls_hint),
-                    s.unfoldedControls, onChange = a.onUnfoldedControls,
-                )
-                if (steam) ChoiceRow(
-                    host, "back-actions", stringResource(R.string.mode_back), stringResource(SessionPrefs.backActionsOrder(s.backActionsInverted)),
-                    listOf(
-                        false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM),
-                        true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU),
-                    ), s.backActionsInverted, onPick = a.onBackActionsInverted,
-                )
-            }
-        }
-        if (tab == ModeSettingsTab.SESSION) {
-            SettingsGroup(stringResource(R.string.mode_session)) {
-                ChoiceRow(
-                    host, "suspend", stringResource(R.string.mode_suspend),
-                    stringResource(R.string.mode_suspend_hint),
-                    listOf(
-                        SessionPrefs.SUSPEND_AUTO to stringResource(R.string.common_auto),
-                        SessionPrefs.SUSPEND_MANUAL to stringResource(R.string.mode_suspend_manual),
-                        SessionPrefs.SUSPEND_NEVER to stringResource(R.string.common_never),
-                    ) + if (steam) listOf(
-                        SessionPrefs.SUSPEND_NATIVE to stringResource(R.string.mode_suspend_native),
-                    ) else emptyList(),
-                    s.suspendPolicy,
-                    note = stringResource(if (steam) R.string.mode_suspend_steam_note else R.string.mode_suspend_note),
-                    onPick = a.onSuspendPolicy,
-                )
-                if (steam && s.suspendPolicy != SessionPrefs.SUSPEND_NEVER) ToggleRow(
-                    host, "background-downloads", stringResource(R.string.mode_background_downloads),
-                    stringResource(R.string.mode_background_downloads_hint),
-                    s.steamDownloadsInBackground, onChange = a.onSteamDownloadsInBackground,
-                )
-            }
-            if (s.pipSupported) SettingsGroup(stringResource(R.string.pip_title)) {
-                ToggleRow(host, "pip-auto", stringResource(R.string.pip_auto), null,
-                    s.pipAutoEnter, onChange = a.onPipAutoEnter)
-            }
-            if (steam) SettingsGroup(stringResource(R.string.mode_startup)) {
-                ToggleRow(
-                    host, "steam-startup", stringResource(R.string.mode_steam_startup),
-                    stringResource(R.string.mode_steam_startup_hint),
-                    s.runSteamAtStartup, onChange = a.onRunSteamAtStartup,
-                )
-            }
-        }
-        if (steam && tab == ModeSettingsTab.STEAM) SettingsGroup(stringResource(R.string.mode_decky)) {
-            val updateAvailable = s.deckyInstalled != null && s.deckyLatestRelease != null &&
-                s.deckyInstalled != s.deckyLatestRelease.tag
-            val status = when {
-                s.deckyStage != null -> s.deckyStage
-                s.deckyChecking -> stringResource(R.string.mode_decky_checking)
-                s.deckyInstalled == null && s.deckyLatestRelease != null -> stringResource(R.string.mode_decky_ready, s.deckyLatestRelease.tag)
-                s.deckyInstalled == null -> stringResource(R.string.mode_decky_none)
-                s.deckyLatestRelease == null -> stringResource(R.string.mode_decky_installed, s.deckyInstalled)
-                updateAvailable -> stringResource(R.string.mode_decky_update, s.deckyLatestRelease.tag)
-                else -> stringResource(R.string.mode_decky_current, s.deckyInstalled)
-            }
-            SettingsRow(stringResource(R.string.mode_decky_loader), status) {
-                val action = when {
-                    s.deckyStage != null -> stringResource(R.string.common_working)
-                    s.deckyChecking -> stringResource(R.string.common_checking)
-                    s.deckyInstalled == null && s.deckyLatestRelease != null -> stringResource(R.string.mode_decky_install_latest)
-                    s.deckyInstalled != null && updateAvailable -> stringResource(R.string.common_update)
-                    else -> stringResource(R.string.common_check)
-                }
-                Row(horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(6.dp)) {
-                    SecondaryButton(
-                        action,
-                        enabled = s.deckyStage == null && !s.deckyChecking && !s.deckySessionRunning,
-                    ) {
-                        if (s.deckyLatestRelease == null || (s.deckyInstalled != null && !updateAvailable)) a.onDeckyCheck()
-                        else s.deckyLatestRelease?.let(a.onDeckyInstall)
-                    }
-                    if (s.deckyInstalled != null) SecondaryButton(
-                        stringResource(R.string.common_uninstall),
-                        enabled = s.deckyStage == null && !s.deckySessionRunning,
-                    ) { confirmDeckyRemoval = true }
-                }
-            }
-            if (s.deckyInstalled != null) ToggleRow(
-                host, "decky-enabled", stringResource(R.string.mode_decky),
-                if (s.deckyEnabled) stringResource(R.string.mode_decky_on)
-                else stringResource(R.string.mode_decky_off),
-                s.deckyEnabled,
-                enabled = !s.deckySessionRunning && s.deckyStage == null,
-                onChange = a.onDeckyEnabled,
-            )
-            SettingsRow(
-                stringResource(R.string.mode_decky_plugins),
-                stringResource(R.string.mode_decky_plugins_hint),
-            ) {
-                SecondaryButton(
-                    if (s.deckyStage != null && s.deckyDownloadingBinary) stringResource(R.string.mode_decky_plugin_downloading) else stringResource(R.string.mode_decky_plugin_install_zip),
-                    enabled = s.deckyInstalled != null && s.deckyStage == null && !s.deckySessionRunning,
-                    onClick = a.onPickDeckyPluginZip,
-                )
-            }
-            if (s.deckyStage != null && s.deckyPercent >= 0) {
-                LinearProgressIndicator(
-                    progress = { s.deckyPercent / 100f },
-                    modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 8.dp),
-                )
-            }
-        }
-        if (steam && tab == ModeSettingsTab.STEAM) SettingsGroup(stringResource(R.string.mode_client)) {
-            ToggleRow(
-                host, "mangoapp", stringResource(R.string.mode_mangoapp),
-                stringResource(R.string.mode_mangoapp_hint),
-                s.mangoapp, onChange = a.onMangoapp,
-            )
-            SettingsRow(
-                stringResource(R.string.mode_steam_repair),
-                stringResource(if (s.steamRepairQueued) R.string.mode_steam_repair_queued else R.string.mode_steam_repair_hint),
-            ) {
-                SecondaryButton(stringResource(R.string.mode_steam_repair_button), enabled = !s.steamRepairQueued, onClick = a.onSteamRepair)
-            }
-        }
-        if (steam && tab == ModeSettingsTab.STEAM && s.wifiDiscovery != null) SettingsGroup(stringResource(R.string.mode_network)) {
-            val hint = when {
-                s.wifiDiscovery && !s.wifiDiscoveryLocation -> stringResource(R.string.mode_wifi_location_off)
-                !s.wifiDiscoveryPermission && s.wifiDiscoveryAsked -> stringResource(R.string.mode_wifi_permission_denied)
-                else -> stringResource(R.string.mode_wifi_discovery_hint)
-            }
-            SettingsRow(stringResource(R.string.mode_wifi_discovery), hint) {
-                Row(verticalAlignment = androidx.compose.ui.Alignment.CenterVertically,
-                    horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(8.dp)) {
-                    if (s.wifiDiscoveryBlocked || (s.wifiDiscovery && !s.wifiDiscoveryLocation)) {
-                        SecondaryButton(stringResource(R.string.mode_wifi_open_settings), onClick = a.onWifiDiscoverySettings)
-                    }
-                    ToggleSwitch(s.wifiDiscovery, label = stringResource(R.string.mode_wifi_discovery)) { on ->
-                        host.open = null
-                        if (on) explainWifiDiscovery = true else a.onWifiDiscovery(false)
-                    }
-                }
-            }
-        }
-        if (steam && tab == ModeSettingsTab.GAMES && s.fexPreset != null) SettingsGroup(stringResource(R.string.game_settings_title)) {
-            if (s.syncBackend != null) SettingsRow(
-                stringResource(R.string.sync_backend_title),
-                stringResource(R.string.sync_backend_hint),
-            ) {
-                SegmentedTabs(
-                    listOf(
-                        SessionPrefs.SYNC_NTSYNC to stringResource(R.string.sync_backend_ntsync),
-                        SessionPrefs.SYNC_FSYNC to stringResource(R.string.sync_backend_fsync),
-                        SessionPrefs.SYNC_ESYNC to stringResource(R.string.sync_backend_esync),
-                        SessionPrefs.SYNC_WINESERVER to stringResource(R.string.sync_backend_wineserver),
-                    ),
-                    s.syncBackend,
-                ) { id -> host.open = null; a.onSyncBackend(id) }
-            }
-            ChoiceRow(
-                host, "fex", stringResource(R.string.fex_preset_title), stringResource(R.string.fex_next_launch),
-                FexPreset.all.map { it.id to stringResource(it.label) }, s.fexPreset,
-                note = stringResource(FexPreset.byId(s.fexPreset).detail), onPick = a.onFexPreset,
-            )
-            ToggleRow(host, "ssbs", stringResource(R.string.force_ssbs_title), stringResource(R.string.force_ssbs_hint), s.forceSsbs, onChange = a.onForceSsbs)
-            GameEnvironmentRow()
-
-        }
-        if (steam && tab == ModeSettingsTab.AUDIO && s.directAudio != null && s.mic != null) SettingsGroup(stringResource(R.string.mode_audio)) {
+    if (tab == SheetTab.AUDIO && steam) {
+        if (s.directAudio != null && s.mic != null) SettingsGroup(stringResource(R.string.mode_audio)) {
             ToggleRow(host, "da", stringResource(R.string.mode_directaudio), stringResource(R.string.mode_directaudio_hint), s.directAudio, onChange = a.onDirectAudio)
             ToggleRow(host, "mic", stringResource(R.string.mode_mic), stringResource(R.string.mode_mic_hint), s.mic, onChange = a.onMic)
         }
-        if (steam && tab == ModeSettingsTab.GAMES && s.gameStorage != null) SettingsGroup(stringResource(R.string.mode_storage)) {
+    }
+    if (tab == SheetTab.SESSION) {
+        SettingsGroup(stringResource(R.string.mode_session)) {
+            ChoiceRow(
+                host, "suspend", stringResource(R.string.mode_suspend),
+                stringResource(R.string.mode_suspend_hint),
+                listOf(
+                    SessionPrefs.SUSPEND_AUTO to stringResource(R.string.common_auto),
+                    SessionPrefs.SUSPEND_MANUAL to stringResource(R.string.mode_suspend_manual),
+                    SessionPrefs.SUSPEND_NEVER to stringResource(R.string.common_never),
+                ) + if (steam) listOf(
+                    SessionPrefs.SUSPEND_NATIVE to stringResource(R.string.mode_suspend_native),
+                ) else emptyList(),
+                s.suspendPolicy,
+                note = stringResource(if (steam) R.string.mode_suspend_steam_note else R.string.mode_suspend_note),
+                onPick = a.onSuspendPolicy,
+            )
+            if (steam && s.suspendPolicy != SessionPrefs.SUSPEND_NEVER) ToggleRow(
+                host, "background-downloads", stringResource(R.string.mode_background_downloads),
+                stringResource(R.string.mode_background_downloads_hint),
+                s.steamDownloadsInBackground, onChange = a.onSteamDownloadsInBackground,
+            )
+        }
+        if (s.pipSupported) SettingsGroup(stringResource(R.string.pip_title)) {
+            ToggleRow(host, "pip-auto", stringResource(R.string.pip_auto), null,
+                s.pipAutoEnter, onChange = a.onPipAutoEnter)
+        }
+        if (steam) SettingsGroup(stringResource(R.string.mode_startup)) {
+            ToggleRow(
+                host, "steam-startup", stringResource(R.string.mode_steam_startup),
+                stringResource(R.string.mode_steam_startup_hint),
+                s.runSteamAtStartup, onChange = a.onRunSteamAtStartup,
+            )
+        }
+        extras.performance()
+    }
+    if (tab == SheetTab.LIBRARY && steam) {
+        if (s.gameStorage != null) SettingsGroup(stringResource(R.string.mode_storage)) {
             val custom = s.gameStorage.isNotEmpty() && s.gameStorage != "off" && s.storageOptions.none { it.path == s.gameStorage }
             // Each choice: its path, its menu line, the chip's shorter line, and the label it is saved with.
             class StorageChoice(val path: String, val label: String, val chip: String, val saved: String)
@@ -481,6 +361,97 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) {
             )
         }
     }
+    if (tab == SheetTab.STEAM && steam) {
+        extras.account(host)
+        SettingsGroup(stringResource(R.string.mode_decky)) {
+            val updateAvailable = s.deckyInstalled != null && s.deckyLatestRelease != null &&
+                s.deckyInstalled != s.deckyLatestRelease.tag
+            val status = when {
+                s.deckyStage != null -> s.deckyStage
+                s.deckyChecking -> stringResource(R.string.mode_decky_checking)
+                s.deckyInstalled == null && s.deckyLatestRelease != null -> stringResource(R.string.mode_decky_ready, s.deckyLatestRelease.tag)
+                s.deckyInstalled == null -> stringResource(R.string.mode_decky_none)
+                s.deckyLatestRelease == null -> stringResource(R.string.mode_decky_installed, s.deckyInstalled)
+                updateAvailable -> stringResource(R.string.mode_decky_update, s.deckyLatestRelease.tag)
+                else -> stringResource(R.string.mode_decky_current, s.deckyInstalled)
+            }
+            SettingsRow(stringResource(R.string.mode_decky_loader), status) {
+                val action = when {
+                    s.deckyStage != null -> stringResource(R.string.common_working)
+                    s.deckyChecking -> stringResource(R.string.common_checking)
+                    s.deckyInstalled == null && s.deckyLatestRelease != null -> stringResource(R.string.mode_decky_install_latest)
+                    s.deckyInstalled != null && updateAvailable -> stringResource(R.string.common_update)
+                    else -> stringResource(R.string.common_check)
+                }
+                Row(horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(6.dp)) {
+                    SecondaryButton(
+                        action,
+                        enabled = s.deckyStage == null && !s.deckyChecking && !s.deckySessionRunning,
+                    ) {
+                        if (s.deckyLatestRelease == null || (s.deckyInstalled != null && !updateAvailable)) a.onDeckyCheck()
+                        else s.deckyLatestRelease?.let(a.onDeckyInstall)
+                    }
+                    if (s.deckyInstalled != null) DeckyUninstall(enabled = s.deckyStage == null && !s.deckySessionRunning, onUninstall = a.onDeckyUninstall)
+                }
+            }
+            if (s.deckyInstalled != null) ToggleRow(
+                host, "decky-enabled", stringResource(R.string.mode_decky),
+                if (s.deckyEnabled) stringResource(R.string.mode_decky_on)
+                else stringResource(R.string.mode_decky_off),
+                s.deckyEnabled,
+                enabled = !s.deckySessionRunning && s.deckyStage == null,
+                onChange = a.onDeckyEnabled,
+            )
+            SettingsRow(
+                stringResource(R.string.mode_decky_plugins),
+                stringResource(R.string.mode_decky_plugins_hint),
+            ) {
+                SecondaryButton(
+                    if (s.deckyStage != null && s.deckyDownloadingBinary) stringResource(R.string.mode_decky_plugin_downloading) else stringResource(R.string.mode_decky_plugin_install_zip),
+                    enabled = s.deckyInstalled != null && s.deckyStage == null && !s.deckySessionRunning,
+                    onClick = a.onPickDeckyPluginZip,
+                )
+            }
+            if (s.deckyStage != null && s.deckyPercent >= 0) {
+                LinearProgressIndicator(
+                    progress = { s.deckyPercent / 100f },
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 8.dp),
+                )
+            }
+        }
+        SettingsGroup(stringResource(R.string.mode_client)) {
+            ToggleRow(
+                host, "mangoapp", stringResource(R.string.mode_mangoapp),
+                stringResource(R.string.mode_mangoapp_hint),
+                s.mangoapp, onChange = a.onMangoapp,
+            )
+            SettingsRow(
+                stringResource(R.string.mode_steam_repair),
+                stringResource(if (s.steamRepairQueued) R.string.mode_steam_repair_queued else R.string.mode_steam_repair_hint),
+            ) {
+                SecondaryButton(stringResource(R.string.mode_steam_repair_button), enabled = !s.steamRepairQueued, onClick = a.onSteamRepair)
+            }
+        }
+        if (s.wifiDiscovery != null) SettingsGroup(stringResource(R.string.mode_network)) {
+            val hint = when {
+                s.wifiDiscovery && !s.wifiDiscoveryLocation -> stringResource(R.string.mode_wifi_location_off)
+                !s.wifiDiscoveryPermission && s.wifiDiscoveryAsked -> stringResource(R.string.mode_wifi_permission_denied)
+                else -> stringResource(R.string.mode_wifi_discovery_hint)
+            }
+            SettingsRow(stringResource(R.string.mode_wifi_discovery), hint) {
+                Row(verticalAlignment = androidx.compose.ui.Alignment.CenterVertically,
+                    horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(8.dp)) {
+                    if (s.wifiDiscoveryBlocked || (s.wifiDiscovery && !s.wifiDiscoveryLocation)) {
+                        SecondaryButton(stringResource(R.string.mode_wifi_open_settings), onClick = a.onWifiDiscoverySettings)
+                    }
+                    ToggleSwitch(s.wifiDiscovery, label = stringResource(R.string.mode_wifi_discovery)) { on ->
+                        host.open = null
+                        if (on) explainWifiDiscovery = true else a.onWifiDiscovery(false)
+                    }
+                }
+            }
+        }
+    }
     if (explainWifiDiscovery) AlertDialog(
         onDismissRequest = { explainWifiDiscovery = false },
         title = { Text(stringResource(R.string.mode_wifi_explain_title)) },
@@ -494,15 +465,66 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) {
             TextButton(onClick = { explainWifiDiscovery = false }) { Text(stringResource(R.string.common_cancel)) }
         },
     )
-    if (confirmDeckyRemoval) AlertDialog(
-        onDismissRequest = { confirmDeckyRemoval = false },
-        title = { Text(stringResource(R.string.mode_decky_remove_title)) },
-        text = { Text(stringResource(R.string.mode_decky_remove_text)) },
-        confirmButton = {
-            TextButton(onClick = { confirmDeckyRemoval = false; a.onDeckyUninstall() }) { Text(stringResource(R.string.common_uninstall)) }
-        },
-        dismissButton = { TextButton(onClick = { confirmDeckyRemoval = false }) { Text(stringResource(R.string.common_cancel)) } },
+}
+
+/**
+ * The options that apply to every Proton - how Wine syncs, FEX's preset, Force SSBS and the games'
+ * environment - for the Components page's Proton layer.
+ */
+@Composable
+internal fun ProtonOptions(
+    syncBackend: String, fexPreset: String, forceSsbs: Boolean,
+    onSyncBackend: (String) -> Unit, onFexPreset: (String) -> Unit, onForceSsbs: (Boolean) -> Unit,
+) {
+    val host = rememberMenuHost()
+    SettingsRow(stringResource(R.string.sync_backend_title), stringResource(R.string.sync_backend_hint), stacked = true) {
+        SegmentedTabs(
+            listOf(
+                SessionPrefs.SYNC_NTSYNC to stringResource(R.string.sync_backend_ntsync),
+                SessionPrefs.SYNC_FSYNC to stringResource(R.string.sync_backend_fsync),
+                SessionPrefs.SYNC_ESYNC to stringResource(R.string.sync_backend_esync),
+                SessionPrefs.SYNC_WINESERVER to stringResource(R.string.sync_backend_wineserver),
+            ),
+            syncBackend,
+        ) { id -> host.open = null; onSyncBackend(id) }
+    }
+    ChoiceRow(
+        host, "fex", stringResource(R.string.fex_preset_title), stringResource(R.string.fex_next_launch),
+        FexPreset.all.map { it.id to stringResource(it.label) }, fexPreset,
+        note = stringResource(FexPreset.byId(fexPreset).detail), onPick = onFexPreset,
     )
+    ToggleRow(host, "ssbs", stringResource(R.string.force_ssbs_title), stringResource(R.string.force_ssbs_hint), forceSsbs, onChange = onForceSsbs)
+    GameEnvironmentRow()
+}
+
+/**
+ * Uninstall for Decky Loader: are you sure steps out of it in red, Cancel first, so a stray A
+ * costs nothing.
+ */
+@Composable
+private fun DeckyUninstall(enabled: Boolean, onUninstall: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val label = stringResource(R.string.common_uninstall)
+    val title = stringResource(R.string.mode_decky_remove_title)
+    val note = stringResource(R.string.mode_decky_remove_text)
+    val cancel = stringResource(R.string.common_cancel)
+    var at by remember { mutableStateOf<androidx.compose.ui.geometry.Rect?>(null) }
+    androidx.compose.foundation.layout.Box(Modifier.onGloballyPositioned { at = it.boundsInRoot() }) {
+        SecondaryButton(label, enabled = enabled) {
+            val from = at ?: return@SecondaryButton
+            Steps.ask(StepAsk(
+                anchor = from, side = StepSide.Left, accent = colors.error, pillCorner = 12.dp, items = 3,
+                handle = { Text(label, fontSize = 15.sp, fontWeight = androidx.compose.ui.text.font.FontWeight.SemiBold, color = colors.error, maxLines = 1) },
+            ) {
+                StepTitle(title)
+                Text(note, fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.stepItem(1).padding(start = 4.dp, bottom = 12.dp))
+                Row(horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(8.dp, androidx.compose.ui.Alignment.End), modifier = Modifier.stepItem(2)) {
+                    StepChoice(cancel, enabled = open, modifier = Modifier.focusRequester(first)) { Steps.fold() }
+                    StepChoice(label, danger = true, enabled = open) { Steps.fold(); onUninstall() }
+                }
+            })
+        }
+    }
 }
 
 /** Width × height for the session, with the common handheld shapes one tap away. */

app/src/main/java/com/droiddeck/launcher/ui/PageFlood.kt

@@ -30,7 +30,9 @@ import androidx.compose.ui.graphics.drawscope.clipPath
 import androidx.compose.ui.graphics.drawscope.translate
 import androidx.compose.ui.graphics.painter.Painter
 import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.layout.positionInRoot
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.util.lerp
 import kotlinx.coroutines.coroutineScope
@@ -44,9 +46,38 @@ import kotlin.math.sin
 // Play (LaunchFlood): the control stretches out over the pane on loose springs, the far edges
 // first, and the page rises into it once it is covered. Back draws it down into the control again.
 
-/** Where a page opened from: the control's bounds and corner radius, in px. */
-internal class Origin(val bounds: Rect, val corner: Float) {
-    fun translate(by: Offset) = Origin(bounds.translate(by), corner)
+/**
+ * Where a page opened from: the control's bounds and corner radius, in px, and the rail item that
+ * was showing it ([owner]), so the page only draws back into it when that content returns. [art]
+ * is the control's picture for the tile (a drawable id, or an image Coil loads), if it has one.
+ */
+internal class Origin(val bounds: Rect, val corner: Float, val owner: String? = null, val art: Any? = null) {
+    fun translate(by: Offset) = Origin(bounds.translate(by), corner, owner, art)
+    fun ownedBy(key: String) = Origin(bounds, corner, key, art)
+}
+
+/** How a page that opened from a control leaves. */
+internal enum class PageExit {
+    /** Back into the control it came from, which is on screen again. */
+    Drain,
+    /** Out through a link into another section, which takes the page there itself. */
+    Hop,
+    /** Away with the pane, as any page goes: the control it came from is not coming back. */
+    Sink,
+}
+
+/** Why a page is leaving: an ordinary change of page, or a link into another section. */
+internal enum class PageLeave { Ordinary, Link }
+
+/**
+ * The exit for a page opened from a control on [owner]'s content, leaving for [incoming]. It only
+ * draws back into the control when the content that control belongs to is what comes back; a page
+ * left for another rail item or another page drained into a control that was no longer there.
+ */
+internal fun pageExit(owner: String?, incoming: String, leave: PageLeave): PageExit = when {
+    owner != null && incoming == owner -> PageExit.Drain
+    leave == PageLeave.Link -> PageExit.Hop
+    else -> PageExit.Sink
 }
 
 internal object PageOrigin {
@@ -70,6 +101,7 @@ internal const val PAGE_RETURN_MS = 900
  * [content], a page that opened from the control at [from] (in this element's coordinates): the
  * control's tile stretching over it until covered, then the page rising in as the tile fades.
  * Once [leaving], the reverse: the tile comes back over the page and draws down into the control.
+ * A page that [sinks] instead goes with the pane and draws no tile at all.
  * The focus ring stays out of it until it is done.
  */
 @Composable
@@ -78,6 +110,15 @@ internal fun PageFlood(
     leaving: Boolean,
     /** What the tile shows instead of the control's fill: a game card's art, cropped to the tile as it grows. */
     art: Painter? = null,
+    sinks: Boolean = false,
+    /**
+     * Where on the page the control's tile lands (root px), when the page has its own picture of
+     * the control - a game page's hero art: the tile grows onto it instead of over the whole pane,
+     * corner to corner ([ontoCorner] there), and the page comes in around it. Back leaves from it.
+     * Null, or off screen: the pane, as any page.
+     */
+    onto: (() -> Rect?)? = null,
+    ontoCorner: androidx.compose.ui.unit.Dp = 0.dp,
     content: @Composable () -> Unit,
 ) {
     val pal = LocalPalette.current
@@ -87,9 +128,44 @@ internal fun PageFlood(
     val shown = remember { Animatable(0f) }
     val tile = remember { Animatable(1f) }
     var size by remember { mutableStateOf(Size.Zero) }
-    LaunchedEffect(size != Size.Zero, leaving) {
+    var at by remember { mutableStateOf(Offset.Zero) }
+    // Where this flood lands (in its own space), read as it opens and again as it leaves.
+    var target by remember { mutableStateOf<Rect?>(null) }
+    val density = androidx.compose.ui.platform.LocalDensity.current
+    LaunchedEffect(size != Size.Zero, leaving, sinks) {
+        if (sinks) {
+            // Whatever the flood in was doing, the page is shown whole and leaves with the pane.
+            tile.snapTo(0f)
+            shown.snapTo(1f)
+            glide?.hidden = false
+            return@LaunchedEffect
+        }
         if (size == Size.Zero) return@LaunchedEffect
         glide?.hidden = true
+        // The page lays out under the tile at once, so its picture is there within a frame or two.
+        target = onto?.let { get ->
+            kotlinx.coroutines.withTimeoutOrNull(300) { snapshotFlow { get() }.first { it != null } }
+        }?.translate(-at)?.takeIf { it.height > 1f && it.overlaps(Rect(Offset.Zero, size)) }
+        if (target != null) {
+            coroutineScope {
+                if (!leaving) {
+                    // Onto the page's picture, every edge together on one firm spring: no blob, and
+                    // nowhere to go past it.
+                    val runs = edges.map { launch { it.animateTo(1f, Motion.sp(0.85f, 320f)) } }
+                    snapshotFlow { edges.all { it.value >= 0.9f } }.first { it }
+                    launch { shown.animateTo(1f, Motion.tw(240)) }
+                    launch { delay(Motion.ms(140).toLong()); tile.animateTo(0f, Motion.tw(220)) }
+                    runs.forEach { it.join() }
+                } else {
+                    launch { shown.animateTo(0f, Motion.tw(160)) }
+                    tile.animateTo(1f, Motion.tw(120))
+                    edges.map { launch { it.animateTo(0f, Motion.sp(0.9f, 320f)) } }.forEach { it.join() }
+                    tile.animateTo(0f, Motion.tw(120))
+                }
+            }
+            glide?.hidden = false
+            return@LaunchedEffect
+        }
         val b = from.bounds
         val travel = listOf(b.left, b.top, size.width - b.right, size.height - b.bottom).map { it.coerceAtLeast(0f) }
         val far = travel.max().coerceAtLeast(1f)
@@ -122,10 +198,16 @@ internal fun PageFlood(
         glide?.hidden = false
     }
     DisposableEffect(Unit) { onDispose { glide?.hidden = false } }
-    Box(Modifier.fillMaxSize().clipToBounds().onSizeChanged { size = Size(it.width.toFloat(), it.height.toFloat()) }) {
-        Box(Modifier.fillMaxSize().graphicsLayer { alpha = shown.value; translationY = (1f - shown.value) * 14.dp.toPx() }) { content() }
+    Box(
+        Modifier.fillMaxSize().clipToBounds().onSizeChanged { size = Size(it.width.toFloat(), it.height.toFloat()) }
+            .onGloballyPositioned { at = it.positionInRoot() },
+    ) {
+        // Landing on the page's picture, the page must not rise: its picture would move off the tile.
+        val rise = if (onto != null) 0f else 1f
+        Box(Modifier.fillMaxSize().graphicsLayer { alpha = shown.value; translationY = (1f - shown.value) * 14.dp.toPx() * rise }) { content() }
+        val onCorner = with(density) { ontoCorner.toPx() }
         Canvas(Modifier.fillMaxSize()) {
-            if (tile.value > 0.01f) drawTile(from, edges.map { it.value }, pal.surface, pal.line2, tile.value, art)
+            if (tile.value > 0.01f) drawTile(from, edges.map { it.value }, pal.surface, pal.line2, tile.value, art, target, onCorner)
         }
     }
 }
@@ -134,22 +216,33 @@ internal fun PageFlood(
  * The control's tile with its edges [v] of the way to the pane's (left, top, right, bottom):
  * sinking with the page behind, blobby in flight, square once it fills the pane.
  */
-private fun DrawScope.drawTile(from: Origin, v: List<Float>, fill: Color, line: Color, alpha: Float, art: Painter? = null) {
+private fun DrawScope.drawTile(
+    from: Origin, v: List<Float>, fill: Color, line: Color, alpha: Float, art: Painter? = null,
+    /** Lands on this instead of the pane (a page's picture of the control), corner [toCorner]. */
+    to: Rect? = null, toCorner: Float = 0f,
+) {
     val (l, t, r, b) = v
     val mean = v.sumOf { it.coerceIn(0f, 1f).toDouble() }.toFloat() / 4f
-    // The control sinks with the page behind it (scaled to 0.95 about the pane's centre).
-    val k = 1f - 0.05f * mean
-    val cx = size.width / 2f
-    val cy = size.height / 2f
     val f = from.bounds
-    val left = lerp(cx + (f.left - cx) * k, 0f, l)
-    val top = lerp(cy + (f.top - cy) * k, 0f, t)
-    val right = lerp(cx + (f.right - cx) * k, size.width, r)
-    val bottom = lerp(cy + (f.bottom - cy) * k, size.height, b)
+    val left: Float; val top: Float; val right: Float; val bottom: Float
+    if (to != null) {
+        left = lerp(f.left, to.left, l); top = lerp(f.top, to.top, t)
+        right = lerp(f.right, to.right, r); bottom = lerp(f.bottom, to.bottom, b)
+    } else {
+        // The control sinks with the page behind it (scaled to 0.95 about the pane's centre).
+        val k = 1f - 0.05f * mean
+        val cx = size.width / 2f
+        val cy = size.height / 2f
+        left = lerp(cx + (f.left - cx) * k, 0f, l)
+        top = lerp(cy + (f.top - cy) * k, 0f, t)
+        right = lerp(cx + (f.right - cx) * k, size.width, r)
+        bottom = lerp(cy + (f.bottom - cy) * k, size.height, b)
+    }
     val w = (right - left).coerceAtLeast(0f)
     val h = (bottom - top).coerceAtLeast(0f)
-    val blob = sin(PI * mean).toFloat().coerceAtLeast(0f)
-    val corner = lerp(from.corner * (1f - mean), minOf(w, h) * 0.42f, blob)
+    // Onto a picture it keeps a card's shape, corner to corner; over the pane it blobs in flight.
+    val corner = if (to != null) lerp(from.corner, toCorner, mean).coerceAtMost(minOf(w, h) / 2f)
+    else lerp(from.corner * (1f - mean), minOf(w, h) * 0.42f, sin(PI * mean).toFloat().coerceAtLeast(0f))
     drawRoundRect(fill, Offset(left, top), Size(w, h), CornerRadius(corner), alpha = alpha)
     val pic = art?.intrinsicSize?.takeIf { it.isSpecified && it.width > 0f && it.height > 0f }
     if (art != null && pic != null && w > 0f && h > 0f) {

app/src/main/java/com/droiddeck/launcher/ui/ProtonPage.kt

@@ -1,88 +0,0 @@
-package com.droiddeck.launcher.ui
-
-import com.droiddeck.launcher.R
-import androidx.compose.ui.res.stringResource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.LinearProgressIndicator
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-
-class ProtonRow(val id: String, val name: String, val installed: String?, val queued: Boolean)
-
-@Composable
-fun ProtonPage(
-    rows: List<ProtonRow>,
-    busyId: String?,
-    stage: String?,
-    percent: Int,
-    runtimeReady: Boolean,
-    sessionRunning: Boolean,
-    onInstall: (String) -> Unit,
-    onCancel: (String) -> Unit,
-    onRemove: (String) -> Unit,
-    onBack: () -> Unit,
-) {
-    val host = rememberMenuHost()
-    val colors = MaterialTheme.colorScheme
-    SettingsPage(
-        host,
-        title = stringResource(R.string.setup_tool_protons),
-        eyebrow = stringResource(R.string.setup_title),
-        lede = stringResource(R.string.proton_lede),
-        onBack = onBack,
-    ) {
-        if (!runtimeReady) Text(
-            stringResource(R.string.content_needs_runtime),
-            fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 8.dp, bottom = 6.dp),
-        )
-        if (sessionRunning) Text(
-            stringResource(R.string.proton_stop_first),
-            fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 8.dp, bottom = 6.dp),
-        )
-        val compatible = stringResource(R.string.steam_compat_label)
-        Text(
-            stringResource(R.string.proton_compatible_note, compatible),
-            fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 8.dp, bottom = 6.dp),
-        )
-        SettingsGroup(stringResource(R.string.proton_available)) {
-            for (row in rows) {
-                SettingsRow(
-                    row.name,
-                    when {
-                        row.installed != null -> stringResource(R.string.proton_installed_compatible, row.installed, compatible)
-                        row.queued -> stringResource(R.string.proton_queued)
-                        else -> stringResource(R.string.proton_not_installed)
-                    },
-                ) {
-                    Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
-                        when {
-                            row.installed != null -> SecondaryButton(stringResource(R.string.store_remove), enabled = busyId == null && runtimeReady && !sessionRunning) { onRemove(row.id) }
-                            busyId != null -> SecondaryButton(if (busyId == row.id) stringResource(R.string.store_installing) else stringResource(R.string.store_install), enabled = false) {}
-                            else -> SecondaryButton(stringResource(R.string.proton_install_now), enabled = runtimeReady && !sessionRunning) { onInstall(row.id) }
-                        }
-                        if (row.queued && row.installed == null && busyId == null) {
-                            SecondaryButton(stringResource(R.string.proton_cancel_queued), enabled = !sessionRunning) { onCancel(row.id) }
-                        }
-                    }
-                }
-                if (busyId == row.id) Column(modifier = Modifier.fillMaxWidth().padding(start = 12.dp, end = 12.dp, bottom = 10.dp)) {
-                    Text(
-                        if (stage != null && percent >= 0) stringResource(R.string.store_busy_percent_short, stage, percent) else stage ?: stringResource(R.string.store_starting),
-                        fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(bottom = 5.dp),
-                    )
-                    if (percent >= 0) LinearProgressIndicator(progress = { percent / 100f }, modifier = Modifier.fillMaxWidth().height(4.dp))
-                    else LinearProgressIndicator(modifier = Modifier.fillMaxWidth().height(4.dp))
-                }
-            }
-        }
-    }
-}

app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt

@@ -18,6 +18,7 @@ import androidx.compose.ui.input.key.type
 import androidx.compose.ui.layout.LayoutCoordinates
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.IntSize
 import kotlin.math.roundToInt
@@ -72,6 +73,7 @@ import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.ScrollState
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
 import androidx.compose.material3.Text
@@ -88,6 +90,9 @@ import com.droiddeck.launcher.HomeApp
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.animateColorAsState
 import androidx.compose.animation.core.Spring
+import com.droiddeck.launcher.core.GameEnvironment
+import com.droiddeck.launcher.session.ProfileValue
+import com.droiddeck.launcher.session.SelectedGameProfile
 import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.semantics.stateDescription
@@ -205,8 +210,8 @@ class DrawerActions(
     /** The compositor's post chain (gpu/ScreenEffects), changed live. */
     val effects: ScreenEffects = ScreenEffects.OFF,
     /** Texture filtering for DirectX 9-11 games (core/TextureFiltering); lands on their next launch. */
-    val textureAnisotropy: Int = 0,
-    val textureLodBias: String = TextureFiltering.LOD_BIAS_OFF,
+    val textureAnisotropy: Int? = 0,
+    val textureLodBias: String? = TextureFiltering.LOD_BIAS_OFF,
     val secondScreenMode: SecondScreenMode,
     val secondScreenDisplays: List<SecondScreenDisplay>,
     val selectedSecondScreenDisplay: Int,
@@ -219,6 +224,10 @@ class DrawerActions(
     val onHardwareKeyboard: () -> Unit,
     val onSteamMenu: (() -> Unit)?,
     val onQam: (() -> Unit)?,
+    /** Null hides the achievements row. */
+    val onAchievements: (() -> Unit)? = null,
+    /** (unlocked, total), or null when unknown. */
+    val achievementsProgress: Pair<Int, Int>? = null,
     val onOsc: (String) -> Unit,
     /** Edits the Steam touch layout of the game in front, when Steam's controls are up. */
     val onEditSteamTouch: (() -> Unit)? = null,
@@ -235,8 +244,8 @@ class DrawerActions(
     val onUpscaler: (Int) -> Unit = {},
     val onUpscaleSharpness: (Int) -> Unit = {},
     val onEffects: (ScreenEffects) -> Unit = {},
-    val onTextureAnisotropy: (Int) -> Unit = {},
-    val onTextureLodBias: (String) -> Unit = {},
+    val onTextureAnisotropy: (Int?) -> Unit = {},
+    val onTextureLodBias: (String?) -> Unit = {},
     val onSecondScreenMode: (SecondScreenMode) -> Unit,
     val onSecondScreenDisplay: (Int) -> Unit,
     val onLaunchAndroidApp: (HomeApp.LaunchableApp, Int?) -> Unit,
@@ -257,8 +266,32 @@ class DrawerActions(
     val components: ComponentsManager.Snapshot? = null,
     /** Re-reads the Protons (and runs swaps that waited for a game to close). */
     val onComponentsRefresh: () -> Unit = {},
+    val componentCatalog: List<ComponentsManager.CatalogItem> = emptyList(),
+    val componentCatalogAt: Long = 0,
+    val componentCatalogChecking: Boolean = false,
+    val componentDownloads: Map<String, Int> = emptyMap(),
+    val componentDownloadRevision: Long = 0,
+    val onComponentCatalogRefresh: () -> Unit = {},
+    val onComponentDownload: (ComponentsManager.CatalogItem) -> Unit = {},
+    /** Installed games available for profile inspection in the session drawer. */
+    val gameProfiles: List<Pair<Long, String>> = emptyList(),
+    /** The selected game profile, or null for the Default profile. */
+    val selectedGameProfileId: Long? = null,
+    val selectedGameProfile: SelectedGameProfile? = null,
+    val gameProfilesLoaded: Boolean = false,
+    val gameProfileRefreshFailed: Boolean = false,
+    val onSelectedGameProfile: (Long?) -> Unit = {},
+    val onGameProfilesPageOpened: () -> Unit = {},
+    val onSelectedGameProfileRefresh: () -> Unit = {},
+    val gameFexPresetSaving: Boolean = false,
+    val onGameFexPreset: (Long, String?) -> Unit = { _, _ -> },
+    /** Saves the selected game's Start without Steam (GameEnvironment.NO_STEAM). */
+    val gameNoSteamSaving: Boolean = false,
+    val onGameNoSteam: (Long, Boolean) -> Unit = { _, _ -> },
     /** Swaps [value] ("orig:<build>" or a stored package file) into a Proton's component. */
     val onComponentSwap: (protonId: String, comp: String, value: String) -> Unit = { _, _, _ -> },
+    /** Saves a stored package for a game, or null to inherit that component from the Default profile. */
+    val onGameComponent: (appId: Long, comp: String, file: String?) -> Unit = { _, _, _ -> },
 )
 
 @OptIn(ExperimentalComposeUiApi::class)
@@ -286,7 +319,19 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont
     }
     BackHandler(enabled = open && confirmStop) { confirmStop = false }
     LaunchedEffect(page) { host.open = null; appToChooseDisplay = null }
-    LaunchedEffect(open, page) { if (open && page == SessionDrawerPage.GAMES) a.onComponentsRefresh() }
+    LaunchedEffect(a.selectedGameProfileId) {
+        if (host.open == "fex") host.open = null
+    }
+    LaunchedEffect(open, page, a.componentDownloadRevision) {
+        if (open && page == SessionDrawerPage.GAMES) {
+            a.onGameProfilesPageOpened()
+            a.onComponentsRefresh()
+            while (true) {
+                a.onSelectedGameProfileRefresh()
+                delay(1_000)
+            }
+        }
+    }
     LaunchedEffect(open, controllerActive) {
         if (open && !controllerActive) focusManager.clearFocus(force = true)
     }
@@ -376,6 +421,11 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont
                     }
                     StopSessionButton(modifier = focus.track(page, "stop").onGloballyPositioned { stopCoords = it }) { host.open = null; confirmStop = true }
                 }
+                a.onAchievements?.let { show ->
+                    DrawerAchievementsRow(a.achievementsProgress, Modifier.padding(top = if (short) 6.dp else 10.dp).then(focus.track(page, "achievements"))) {
+                        host.open = null; show()
+                    }
+                }
 
                 Row(
                     verticalAlignment = Alignment.CenterVertically,
@@ -479,16 +529,31 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont
                             SecondScreenGroup(host, a) { key -> focus.track(page, key) }
                         }
                         SessionDrawerPage.GAMES -> {
+                            if (a.steam) SelectedGameProfileGroup(host, a) { key -> focus.track(page, key) }
                             Text(stringResource(R.string.fex_next_launch), fontSize = 12.sp,
                                 color = colors.onSurfaceVariant, modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp))
                             TextureFilteringGroup(host, a) { key -> focus.track(page, key) }
                             if (a.steam) SettingsGroup(stringResource(R.string.game_settings_title)) {
-                                ChoiceRow(host, "fex", stringResource(R.string.fex_preset_title), null,
-                                    FexPreset.all.map { it.id to stringResource(it.label) }, a.fexPreset,
-                                    chipModifier = focus.track(page, "fex"), onPick = a.onFexPreset)
-                                GameEnvironmentRow(modifier = focus.track(page, "game-env"), showHint = false)
+                                DrawerFexPresetRow(host, a, focus.track(page, "fex"))
+                                DrawerNoSteamRow(host, a, focus.track(page, "no-steam"))
+                                GameEnvironmentRow(
+                                    modifier = focus.track(page, "game-env"),
+                                    showHint = false,
+                                    initialScope = a.selectedGameProfileId?.toString().orEmpty(),
+                                )
                             }
                             ComponentsDrawerPage(host, a) { key -> focus.track(page, key) }
+                            ComponentDownloadsDrawerGroup(
+                                host = host,
+                                catalog = a.componentCatalog,
+                                catalogAt = a.componentCatalogAt,
+                                checking = a.componentCatalogChecking,
+                                packages = a.components?.packages.orEmpty(),
+                                downloads = a.componentDownloads,
+                                onRefresh = a.onComponentCatalogRefresh,
+                                onDownload = a.onComponentDownload,
+                                track = { key -> focus.track(page, key) },
+                            )
                         }
                         SessionDrawerPage.SESSION -> {
                             if (a.isHomeApp) SettingsGroup(stringResource(R.string.drawer_android_apps)) {
@@ -874,24 +939,205 @@ private fun SecondScreenGroup(host: MenuHost, a: DrawerActions, track: (String)
     }
 }
 
+@Composable
+private fun DrawerFexPresetRow(host: MenuHost, a: DrawerActions, modifier: Modifier) {
+    val appId = a.selectedGameProfileId
+    val profile = a.selectedGameProfile?.takeIf { it.appId == appId }
+    val inherited = profile?.fexPreset?.inherited == true
+    val hint = if (profile == null) null else stringResource(
+        if (inherited) R.string.comp_game_fex_inherited else R.string.comp_game_fex_override,
+    )
+    SettingsRow(stringResource(R.string.fex_preset_title), hint, highlighted = host.open == "fex") {
+        if (appId != null && profile == null) {
+            ValueChip("-", false, enabled = false, modifier = modifier) {}
+        } else {
+            FexPresetChip(
+                preset = profile?.fexPreset?.value ?: a.fexPreset,
+                inherited = inherited,
+                open = host.open == "fex",
+                enabled = !a.gameFexPresetSaving,
+                onToggle = { host.open = if (host.open == "fex") null else "fex" },
+                onDismiss = { if (host.open == "fex") host.open = null },
+                onPick = { preset ->
+                    if (appId == null) {
+                        preset?.let(a.onFexPreset)
+                    } else {
+                        a.onGameFexPreset(appId, preset)
+                    }
+                },
+                allowInheritance = appId != null,
+                modifier = modifier,
+            )
+        }
+    }
+}
+
+/** A game's Start without Steam; only with a game selected - the Default profile has no such switch. */
+@Composable
+private fun DrawerNoSteamRow(host: MenuHost, a: DrawerActions, modifier: Modifier) {
+    val appId = a.selectedGameProfileId ?: return
+    val profile = a.selectedGameProfile?.takeIf { it.appId == appId } ?: return
+    ToggleRow(
+        host, "no-steam", stringResource(R.string.game_no_steam_title), stringResource(R.string.game_no_steam_detail),
+        profile.startWithoutSteam, enabled = !a.gameNoSteamSaving, chipModifier = modifier,
+    ) { on -> a.onGameNoSteam(appId, on) }
+}
+
 /** Texture filtering on the Games page: DXVK options for the next DirectX 9-11 launch. */
 @Composable
 private fun TextureFilteringGroup(host: MenuHost, a: DrawerActions, track: (String) -> Modifier) {
+    val inherited = a.selectedGameProfileId != null
+    val anisotropyChoices: List<Pair<Int?, String>> =
+        (if (inherited) listOf(null to stringResource(R.string.comp_game_use_general)) else emptyList()) +
+            SessionPrefs.textureAnisotropyChoices(LocalContext.current).map { (value, label) -> value as Int? to label }
+    val lodBiasChoices: List<Pair<String?, String>> =
+        (if (inherited) listOf(null to stringResource(R.string.comp_game_use_general)) else emptyList()) +
+            SessionPrefs.textureLodBiasChoices(LocalContext.current).map { (value, label) -> value as String? to label }
     SettingsGroup(stringResource(R.string.drawer_texture)) {
         ChoiceRow(host, "anisotropy", stringResource(R.string.drawer_anisotropy), null,
-            SessionPrefs.textureAnisotropyChoices(LocalContext.current), a.textureAnisotropy, chipModifier = track("anisotropy"), onPick = a.onTextureAnisotropy)
+            anisotropyChoices, a.textureAnisotropy, chipModifier = track("anisotropy"), onPick = a.onTextureAnisotropy)
         ChoiceRow(host, "texture-sharpness", stringResource(R.string.drawer_texture_sharpness), null,
-            SessionPrefs.textureLodBiasChoices(LocalContext.current), a.textureLodBias, note = stringResource(R.string.drawer_texture_sharpness_note),
+            lodBiasChoices, a.textureLodBias, note = stringResource(R.string.drawer_texture_sharpness_note),
             chipModifier = track("texture-sharpness"), onPick = a.onTextureLodBias)
     }
 }
 
 private fun signed(v: Int) = if (v > 0) "+$v" else "$v"
 
+@Composable
+private fun SelectedGameProfileGroup(host: MenuHost, a: DrawerActions, track: (String) -> Modifier) {
+    val colors = MaterialTheme.colorScheme
+    val options: List<Pair<Long?, String>> = listOf(null to stringResource(R.string.comp_scope_general)) +
+        a.gameProfiles.map { (id, name) -> Pair(id, name) }
+    val profile = a.selectedGameProfile
+    SettingsGroup(stringResource(R.string.drawer_selected_profile)) {
+        DrawerStackedChoice(
+            host = host,
+            key = "game-profile",
+            label = stringResource(R.string.comp_profile),
+            hint = if (a.selectedGameProfileId == null) stringResource(R.string.comp_scope_general_detail)
+            else stringResource(R.string.drawer_profile_inspect_hint),
+            options = options,
+            selected = a.selectedGameProfileId,
+            chipModifier = track("game-profile"),
+            onPick = a.onSelectedGameProfile,
+        )
+        if (a.gameProfileRefreshFailed) {
+            Text(
+                stringResource(
+                    if (a.gameProfilesLoaded) {
+                        R.string.drawer_profile_refresh_failed_stale
+                    } else {
+                        R.string.drawer_profile_refresh_failed_initial
+                    },
+                ),
+                fontSize = 13.sp,
+                color = colors.error,
+                modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp),
+            )
+        }
+        if (a.selectedGameProfileId == null) return@SettingsGroup
+        if (profile == null) {
+            if (!a.gameProfileRefreshFailed) Text(
+                stringResource(R.string.drawer_selected_profile_none),
+                fontSize = 13.sp,
+                color = colors.onSurfaceVariant,
+                modifier = Modifier.padding(14.dp),
+            )
+            return@SettingsGroup
+        }
+        val hasOverrides = profile.hasOverrides ||
+            a.textureAnisotropy != null ||
+            a.textureLodBias != null
+        Column(modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 11.dp)) {
+            Text(
+                stringResource(
+                    if (hasOverrides) R.string.drawer_profile_custom
+                    else R.string.drawer_profile_default,
+                ),
+                fontSize = 12.sp,
+                color = colors.onSurfaceVariant,
+                modifier = Modifier.padding(bottom = if (hasOverrides) 5.dp else 0.dp),
+            )
+            if (!profile.fexPreset.inherited) {
+                ProfileSummaryRow(stringResource(R.string.comp_game_fex), fexProfileLabel(profile.fexPreset))
+            }
+            if (!profile.proton.inherited) {
+                ProfileSummaryRow(stringResource(R.string.comp_proton), profileValueLabel(profile.proton))
+            }
+            for (component in ComponentsManager.COMPONENTS) {
+                val value = profile.components.getValue(component)
+                if (!value.inherited) {
+                    ProfileSummaryRow(ComponentsManager.LABEL.getValue(component), profileValueLabel(value))
+                }
+            }
+            if (profile.startWithoutSteam) {
+                ProfileSummaryRow(stringResource(R.string.game_no_steam_title), stringResource(R.string.game_no_steam_on))
+            }
+            if (profile.environmentOverrides > 0) {
+                ProfileSummaryRow(
+                    stringResource(R.string.game_env_title),
+                    pluralStringResource(
+                        R.plurals.drawer_profile_environment_overrides,
+                        profile.environmentOverrides,
+                        profile.environmentOverrides,
+                    ),
+                )
+            }
+            if (profile.windowsComponentNames.isNotEmpty()) {
+                ProfileSummaryRow(
+                    stringResource(R.string.wincomp_title),
+                    profile.windowsComponentNames.joinToString(", "),
+                )
+            }
+            a.textureAnisotropy?.let { value ->
+                ProfileSummaryRow(
+                    stringResource(R.string.drawer_anisotropy),
+                    SessionPrefs.textureAnisotropyChoices(LocalContext.current)
+                        .firstOrNull { it.first == value }?.second.orEmpty(),
+                )
+            }
+            a.textureLodBias?.let { value ->
+                ProfileSummaryRow(
+                    stringResource(R.string.drawer_texture_sharpness),
+                    SessionPrefs.textureLodBiasChoices(LocalContext.current)
+                        .firstOrNull { it.first == value }?.second.orEmpty(),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun fexProfileLabel(value: ProfileValue): String {
+    return when (value.value) {
+        GameEnvironment.CUSTOM_FEX_PRESET -> stringResource(R.string.comp_game_fex_custom)
+        else -> stringResource(FexPreset.byId(value.value).label)
+    }
+}
+
+@Composable
+private fun profileValueLabel(value: ProfileValue) =
+    value.value.ifEmpty { stringResource(R.string.comp_no_proton_short) }
+
+@Composable
+private fun ProfileSummaryRow(label: String, value: String) {
+    Row(modifier = Modifier.fillMaxWidth().padding(top = 3.dp)) {
+        Text(label, fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.width(96.dp))
+        Text(
+            value,
+            fontSize = 12.sp,
+            color = MaterialTheme.colorScheme.onBackground,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+        )
+    }
+}
+
 /**
  * The Games tab's components: quick swaps between what is already installed, per Proton. A swap
- * into the Proton a running game uses waits until that game closes; downloading, importing and
- * deleting stay on the Components page in the app.
+ * into the Proton a running game uses waits until that game closes. Downloads below share the
+ * launcher's package store; importing and deleting stay on the Components page.
  */
 @Composable
 private fun ComponentsDrawerPage(host: MenuHost, a: DrawerActions, track: (String) -> Modifier) {
@@ -903,6 +1149,54 @@ private fun ComponentsDrawerPage(host: MenuHost, a: DrawerActions, track: (Strin
         }
         return
     }
+    val gameProfile = a.selectedGameProfileId?.let { appId ->
+        a.selectedGameProfile?.takeIf { it.appId == appId }
+    }
+    if (a.selectedGameProfileId != null) {
+        if (gameProfile == null) {
+            SettingsGroup(stringResource(R.string.drawer_page_components)) {
+                Text(
+                    stringResource(R.string.comp_reading),
+                    fontSize = 13.sp,
+                    color = colors.onSurfaceVariant,
+                    modifier = Modifier.padding(14.dp),
+                )
+            }
+            return
+        }
+        SettingsGroup(stringResource(R.string.drawer_page_components)) {
+            Column(modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 11.dp)) {
+                ProfileSummaryRow(stringResource(R.string.comp_proton), gameProfile.proton.value)
+            }
+            for (comp in ComponentsManager.COMPONENTS) {
+                val value = gameProfile.components.getValue(comp)
+                val options: List<Pair<String?, String>> =
+                    listOf(null to stringResource(R.string.comp_game_use_general)) +
+                        snap.packages.filter { it.comp == comp }.map { it.file to it.version }
+                DrawerStackedChoice(
+                    host = host,
+                    key = "game-cmp-$comp",
+                    label = ComponentsManager.LABEL.getValue(comp),
+                    hint = if (value.inherited) {
+                        stringResource(R.string.drawer_component_inherited, value.value)
+                    } else {
+                        null
+                    },
+                    options = options,
+                    selected = gameProfile.componentFiles[comp],
+                    chipModifier = track("cmp-$comp"),
+                    onPick = { file -> a.onGameComponent(gameProfile.appId, comp, file) },
+                )
+            }
+        }
+        Text(
+            stringResource(R.string.drawer_game_components_note, gameProfile.name),
+            fontSize = 12.sp,
+            color = colors.onSurfaceVariant,
+            modifier = Modifier.padding(horizontal = 4.dp, vertical = 12.dp),
+        )
+        return
+    }
     val running = snap.protons.filter { it.inUseByGame }
     var pick by rememberSaveable { mutableStateOf<String?>(null) }
     val view = snap.protons.firstOrNull { it.proton.id == pick } ?: running.firstOrNull() ?: snap.protons.firstOrNull()
@@ -976,6 +1270,84 @@ private fun ComponentsDrawerPage(host: MenuHost, a: DrawerActions, track: (Strin
     )
 }
 
+/** Downloads only store packages; the profile/Proton choices above apply them separately. */
+@Composable
+internal fun ComponentDownloadsDrawerGroup(
+    host: MenuHost,
+    catalog: List<ComponentsManager.CatalogItem>,
+    catalogAt: Long,
+    checking: Boolean,
+    packages: List<ComponentsManager.Package>,
+    downloads: Map<String, Int>,
+    onRefresh: () -> Unit,
+    onDownload: (ComponentsManager.CatalogItem) -> Unit,
+    track: (String) -> Modifier = { Modifier },
+) {
+    val colors = MaterialTheme.colorScheme
+    val installed = packages.map { it.file }.toSet()
+    SettingsGroup(stringResource(R.string.drawer_component_downloads)) {
+        Text(stringResource(R.string.drawer_component_downloads_hint), fontSize = 12.sp,
+            color = colors.onSurfaceVariant, modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp))
+        SettingsRow(stringResource(R.string.comp_nightlies_checked,
+            if (catalogAt > 0) java.text.DateFormat.getTimeInstance(java.text.DateFormat.SHORT)
+                .format(java.util.Date(catalogAt * 1000)) else stringResource(R.string.comp_never)), null, stacked = true) {
+            ValueChip(stringResource(if (checking) R.string.common_checking else R.string.stores_refresh),
+                false, enabled = !checking, modifier = track("cmp-download-refresh"), onClick = onRefresh)
+        }
+        for (comp in ComponentsManager.COMPONENTS) {
+            val key = "cmp-download-$comp"
+            val items = catalog.filter { it.comp == comp }
+            val open = host.open == key
+            Column(Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 10.dp)) {
+                Text(ComponentsManager.LABEL.getValue(comp), fontSize = 15.sp,
+                    fontWeight = FontWeight.SemiBold, color = colors.onBackground)
+                Box(Modifier.fillMaxWidth().padding(top = 6.dp)) {
+                    ValueChip(stringResource(R.string.drawer_component_choose_download), open,
+                        enabled = items.isNotEmpty(), modifier = track(key).fillMaxWidth()) {
+                        host.open = if (open) null else key
+                    }
+                    AnchoredMenu(open, onDismiss = { if (host.open == key) host.open = null },
+                        title = ComponentsManager.LABEL.getValue(comp)) { firstItemFocus ->
+                        val firstAvailable = items.firstOrNull { ComponentsManager.safeName(it.file) !in installed && it.file !in downloads }
+                        items.forEach { item ->
+                            val stored = ComponentsManager.safeName(item.file) in installed
+                            val progress = downloads[item.file]
+                            MenuItem(item.file.removeSuffix(".wcp"), checked = stored,
+                                enabled = !stored && progress == null,
+                                detail = when {
+                                    stored -> stringResource(R.string.wincomp_downloaded)
+                                    progress != null -> if (progress < 0) stringResource(R.string.wincomp_downloading, item.file.removeSuffix(".wcp")) else "$progress%"
+                                    else -> item.release + " · " + stringResource(R.string.common_size_mb, item.size / 1048576.0)
+                                },
+                                focusRequester = if (item == firstAvailable) firstItemFocus else null,
+                            ) {
+                                onDownload(item)
+                                host.open = null
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (catalog.isEmpty() && !checking) Text(
+            stringResource(if (catalogAt == 0L) R.string.comp_refresh_to_list else R.string.comp_nothing_new),
+            fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(14.dp),
+        )
+        for ((file, progress) in downloads) {
+            Column(Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 8.dp)) {
+                Text(stringResource(R.string.wincomp_downloading, file.removeSuffix(".wcp")),
+                    fontSize = 12.sp, color = colors.onSurfaceVariant)
+                if (progress < 0) LinearProgressIndicator(modifier = Modifier.fillMaxWidth().padding(top = 4.dp))
+                else {
+                    Text("$progress%", fontSize = 12.sp, color = colors.onSurfaceVariant)
+                    LinearProgressIndicator(progress = { progress / 100f },
+                        modifier = Modifier.fillMaxWidth().padding(top = 4.dp))
+                }
+            }
+        }
+    }
+}
+
 /**
  * A choice for the drawer's narrow column: label, then the box across the full width, then the
  * detail underneath - so a long Proton or package name never squeezes the text beside it.

app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt

@@ -62,6 +62,7 @@ import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -98,6 +99,7 @@ import androidx.compose.ui.text.style.TextAlign
 import kotlin.math.roundToInt
 import androidx.compose.ui.input.InputMode
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalInputModeManager
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
@@ -281,11 +283,16 @@ fun AnchoredMenu(
             android.util.Log.i("AnchoredMenu", "requested first option focus")
         }
     }
-    val gap = with(LocalDensity.current) { 6.dp.roundToPx() }
+    // Popup installs Android's window density. Keep the app scale from the anchor, including
+    // the matching dp window dimensions used to cap and scroll the menu.
+    val density = LocalDensity.current
+    val configuration = LocalConfiguration.current
+    val gap = with(density) { 6.dp.roundToPx() }
     val provider = remember(gap, compact) { if (compact) BelowStartProvider(gap) else BelowEndProvider(gap) }
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
     Popup(popupPositionProvider = provider, onDismissRequest = onDismiss, properties = PopupProperties(focusable = true)) {
+      CompositionLocalProvider(LocalDensity provides density, LocalConfiguration provides configuration) {
         AnimatedVisibility(
             visibleState = state,
             enter = fadeIn(Motion.tw(180)) + scaleIn(Motion.sp(0.7f), initialScale = 0.94f, transformOrigin = TransformOrigin(if (compact) 0f else 1f, 0f)),
@@ -345,6 +352,7 @@ fun AnchoredMenu(
                 }
             }
         }
+      }
     }
 }
 
@@ -423,6 +431,8 @@ fun ValueChip(text: String, open: Boolean, enabled: Boolean = true, modifier: Mo
 fun SettingsGroup(title: String, compact: Boolean = false, content: @Composable ColumnScope.() -> Unit) {
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
+    // In a lifted sheet each group fades and rises in on its own beat.
+    Column(Modifier.fillMaxWidth().sheetPiece()) {
     Row(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(if (compact) 6.dp else 10.dp),
@@ -432,6 +442,7 @@ fun SettingsGroup(title: String, compact: Boolean = false, content: @Composable
         Box(modifier = Modifier.weight(1f).height(1.dp).background(pal.line))
     }
     Column(modifier = Modifier.fillMaxWidth().clip(GroupShape).background(colors.surface).border(1.dp, pal.line, GroupShape)) { content() }
+    }
 }
 
 /**
@@ -440,7 +451,7 @@ fun SettingsGroup(title: String, compact: Boolean = false, content: @Composable
  * under it stay put.
  */
 @Composable
-fun SettingsRow(label: String, hint: String?, highlighted: Boolean = false, hintLines: Int? = null, control: @Composable () -> Unit) {
+fun SettingsRow(label: String, hint: String?, highlighted: Boolean = false, hintLines: Int? = null, stacked: Boolean = false, control: @Composable () -> Unit) {
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
     val bg by animateColorAsState(if (highlighted) pal.signal.copy(alpha = 0.10f) else Color.Transparent, Motion.tw(200), label = "rowBg")
@@ -449,7 +460,7 @@ fun SettingsRow(label: String, hint: String?, highlighted: Boolean = false, hint
             minLines = hintLines ?: 1, maxLines = hintLines ?: Int.MAX_VALUE, overflow = TextOverflow.Ellipsis)
     }
     // A narrow page stacks the control under its label, so neither squeezes the other.
-    if (LocalNarrowPane.current) Column(
+    if (stacked || LocalNarrowPane.current) Column(
         modifier = Modifier.fillMaxWidth().background(bg).padding(start = 14.dp, end = 14.dp, top = 11.dp, bottom = 12.dp),
     ) {
         Text(label, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground)

app/src/main/java/com/droiddeck/launcher/ui/SharedMotion.kt

@@ -0,0 +1,274 @@
+package com.droiddeck.launcher.ui
+
+import android.os.SystemClock
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.CornerRadius
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.rotate
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.lerp
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.sin
+
+// The moves the stores made first, for any section: one selection shape that glides along a row
+// (or down a column) of choices, and a pressed control that squashes into a dot and flies home.
+
+/** Which way a [ChipGlide]'s choices run. */
+internal enum class GlideAxis { Horizontal, Vertical }
+
+/**
+ * The selection under a row of chips: [at] (in the row) of chip [index], in [tint]. A move to the
+ * next chip stretches it - the leading edge on the focus ring's lead spring, the trailing one a
+ * beat later on its trail spring - and a hop past chips stretches the same way, across them.
+ * Draw it over the chips: under them, their own rest fill hid it in flight. [axis] runs it down a column instead (the rail, a stack of layers). [corner] is the
+ * chips' own corner; null draws a capsule. [fill] and [outline] are the resting alphas. Not
+ * [visible], it fades away, and comes back on whichever chip it is on by then.
+ */
+@Composable
+internal fun BoxScope.ChipGlide(
+    index: Int,
+    at: Rect?,
+    tint: State<Color>,
+    axis: GlideAxis = GlideAxis.Horizontal,
+    corner: Dp? = null,
+    fill: Float = 0.16f,
+    outline: Float = 0.7f,
+    visible: Boolean = true,
+) {
+    val density = androidx.compose.ui.platform.LocalDensity.current
+    // The two edges along the axis (left and right, or top and bottom), and the two across it.
+    val start = remember { Animatable(Float.NaN) }
+    val end = remember { Animatable(0f) }
+    val pinch = remember { Animatable(0f) }
+    // With a pad the focus ring fills what it holds, and is the only fill: a selection of the
+    // row's own, sliding on its own beat, trailed the ring and sat on items the pad had left.
+    val pad = androidx.compose.ui.platform.LocalInputModeManager.current.inputMode == androidx.compose.ui.input.InputMode.Keyboard
+    @Suppress("NAME_SHADOWING") val visible = visible && !pad
+    val shown = remember { Animatable(if (visible) 1f else 0f) }
+    val visibleNow = rememberUpdatedState(visible)
+    LaunchedEffect(visible) { shown.animateTo(if (visible) 1f else 0f, Motion.tw(if (visible) 160 else 120)) }
+    val crossStart = remember { mutableStateOf(0f) }
+    val crossEnd = remember { mutableStateOf(0f) }
+    val was = remember { intArrayOf(-1) }
+    val vertical = axis == GlideAxis.Vertical
+    LaunchedEffect(index, at, Motion.scale) {
+        val b = at ?: return@LaunchedEffect
+        val s = if (vertical) b.top else b.left
+        val e = if (vertical) b.bottom else b.right
+        crossStart.value = if (vertical) b.left else b.top
+        crossEnd.value = if (vertical) b.right else b.bottom
+        val from = was[0]
+        was[0] = index
+        if (start.value.isNaN() || from == index || from < 0 || Motion.scale == 0f) {
+            start.snapTo(s); end.snapTo(e); pinch.snapTo(0f)
+            if (visibleNow.value) shown.snapTo(1f)
+            return@LaunchedEffect
+        }
+        // Away or on its way back: it goes straight to the chip, unseen.
+        if (!visibleNow.value || shown.value < 0.5f) {
+            start.snapTo(s); end.snapTo(e); pinch.snapTo(0f)
+            return@LaunchedEffect
+        }
+        coroutineScope {
+            run {
+                // Every move stretches across, however far: a long one used to go as a drop (which
+                // sat on chips already left) and then as a fade (a flash of no fill at all).
+                launch { pinch.animateTo(0f, Motion.sp(0.6f, 500f)) }
+                launch { shown.animateTo(1f, Motion.tw(120)) }
+                val forward = index > from
+                val (lead, trail) = if (forward) end to start else start to end
+                val leadTo = if (forward) e else s
+                val trailTo = if (forward) s else e
+                launch { lead.animateTo(leadTo, Motion.sp(0.62f, 700f)) }
+                launch { delay(Motion.ms(40).toLong()); trail.animateTo(trailTo, Motion.sp(0.78f, 360f)) }
+            }
+        }
+    }
+    Canvas(Modifier.matchParentSize()) {
+        if (start.value.isNaN() || crossEnd.value <= crossStart.value) return@Canvas
+        val p = pinch.value
+        val shape = glideShape(start.value, end.value, crossStart.value, crossEnd.value, p, with(density) { 6.dp.toPx() }, vertical)
+        val at0 = shape.topLeft
+        val size = shape.size
+        val round = minOf(size.width, size.height) / 2f
+        val r = CornerRadius(corner?.let { lerp(minOf(with(density) { it.toPx() }, round), round, p) } ?: round)
+        // A drop in flight is solid; on a chip it is the chip's tinted fill and outline.
+        val a = shown.value
+        drawRoundRect(tint.value.copy(alpha = lerp(fill, 0.9f, p) * a), at0, size, r)
+        if (outline > 0f) {
+            // Inside the chip's edge: a stroke on it would lose its outer half to a scrolling row's clip.
+            val w = with(density) { 1.dp.toPx() }
+            val inset = w / 2f
+            drawRoundRect(
+                tint.value.copy(alpha = outline * (1f - p) * a), at0 + Offset(inset, inset), Size(size.width - w, size.height - w),
+                CornerRadius((r.x - inset).coerceAtLeast(0f)), style = Stroke(w),
+            )
+        }
+    }
+}
+
+/**
+ * The chosen one of a row of chips (or a column, [vertical]): a short bar of [color] along its foot
+ * (or its start edge). Not a fill or an outline, so it never reads as focus; with a pad the ring's
+ * own infill is the only fill. Goes inside the chip's clip.
+ */
+@Composable
+internal fun Modifier.shownBar(on: Boolean, color: Color, vertical: Boolean = false): Modifier {
+    val shown = androidx.compose.animation.core.animateFloatAsState(if (on) 1f else 0f, Motion.tw(if (on) 140 else 100), label = "shownBar").value
+    return drawWithContent {
+        drawContent()
+        if (shown <= 0.01f) return@drawWithContent
+        val t = 3.dp.toPx()
+        if (vertical) {
+            val l = size.height * 0.5f
+            drawRect(color, Offset(0f, (size.height - l) / 2f), Size(t, l), alpha = shown)
+        } else {
+            val w = size.width * 0.36f
+            drawRect(color, Offset((size.width - w) / 2f, size.height - t), Size(w, t), alpha = shown)
+        }
+    }
+}
+
+/**
+ * Where a glide's shape is: its edges along the axis at [start] and [end] (either order), across
+ * it from [crossStart] to [crossEnd], pinched [pinch] of the way (0 to 1) into a drop [drop] each
+ * side of its centre. [vertical] runs the axis down instead of across.
+ */
+internal fun glideShape(start: Float, end: Float, crossStart: Float, crossEnd: Float, pinch: Float, drop: Float, vertical: Boolean): Rect {
+    val a0 = minOf(start, end)
+    val a1 = maxOf(start, end)
+    val ca = (a0 + a1) / 2f
+    val cc = (crossStart + crossEnd) / 2f
+    val s0 = lerp(a0, ca - drop, pinch)
+    val s1 = lerp(a1, ca + drop, pinch)
+    val c0 = lerp(crossStart, cc - drop, pinch)
+    val c1 = lerp(crossEnd, cc + drop, pinch)
+    return if (vertical) Rect(c0, s0, c1, s1) else Rect(s0, c0, s1, c1)
+}
+
+/**
+ * A dot on its way somewhere: from the control at [from] (root px) to the point [to] gives (root
+ * px, asked each frame, so a target that moves is followed). [color] null is the palette's signal
+ * blue. [onHalf] runs as it passes the top of its arc, [onLand] once it lands.
+ */
+internal class Flight(
+    val from: Rect,
+    val to: Density.() -> Offset?,
+    val color: Color? = null,
+    val onHalf: () -> Unit = {},
+    val onLand: () -> Unit = {},
+) {
+    val id = SystemClock.uptimeMillis() * 1000 + (next++ % 1000)
+
+    private companion object { var next = 0L }
+}
+
+/** Dots flying anywhere outside the Stores page (which keeps its own): a hop, a swap, a toggle. */
+internal object Flights {
+    val all = mutableStateListOf<Flight>()
+
+    /** Sends [f], or with animations off just runs its ends. */
+    fun fly(f: Flight) {
+        if (Motion.scale == 0f) { f.onHalf(); f.onLand(); return }
+        all += f
+    }
+}
+
+/** [Flights] drawn over everything, in the space of an element at [origin] (root px). */
+@Composable
+internal fun FlightsLayer(origin: Offset) {
+    for (f in Flights.all.toList()) key(f.id) { FlightDot(f, origin) { Flights.all.remove(f) } }
+}
+
+/**
+ * One dot: the control squashes into a 14dp dot (width first, a little bloop), which then flies
+ * on an arc to its target, stretched along its path like the focus ring's drop.
+ */
+@Composable
+internal fun FlightDot(f: Flight, origin: Offset, onDone: () -> Unit) {
+    val pal = LocalPalette.current
+    val color = f.color ?: pal.signal
+    val t = remember { Animatable(0f) }
+    LaunchedEffect(Unit) {
+        t.animateTo(1f, Motion.tw(150, easing = FastOutSlowInEasing))
+        coroutineScope {
+            launch { delay(Motion.ms(150).toLong()); f.onHalf() }
+            t.animateTo(2f, Motion.tw(300, easing = FastOutSlowInEasing))
+        }
+        f.onLand()
+        onDone()
+    }
+    Canvas(Modifier.fillMaxSize()) {
+        val r = 7.dp.toPx()
+        val from = f.from.translate(-origin)
+        val a = from.center
+        val b = (f.to(this) ?: return@Canvas) - origin
+        val v = t.value
+        if (v < 1f) {
+            // Squash: the width goes first, then the height, into the dot; a bloop at the end.
+            val w = lerp(from.width, 2 * r, (v * 1.4f).coerceAtMost(1f))
+            val h = lerp(from.height, 2 * r, ((v - 0.25f) / 0.75f).coerceIn(0f, 1f))
+            val k = 1f - 0.15f * sin(PI * v).toFloat()
+            drawRoundRect(color, Offset(a.x - w * k / 2, a.y - h * k / 2), Size(w * k, h * k), CornerRadius(minOf(w, h) * k / 2))
+        } else {
+            val p = v - 1f
+            val c = Offset((a.x + b.x) / 2, minOf(a.y, b.y) - 80.dp.toPx())
+            val q = 1f - p
+            val pos = Offset(q * q * a.x + 2 * q * p * c.x + p * p * b.x, q * q * a.y + 2 * q * p * c.y + p * p * b.y)
+            val d = Offset(2 * q * (c.x - a.x) + 2 * p * (b.x - c.x), 2 * q * (c.y - a.y) + 2 * p * (b.y - c.y))
+            val stretch = sin(PI * p).toFloat()
+            val angle = atan2(d.y, d.x) * 180f / PI.toFloat()
+            rotate(angle, pos) {
+                val w = 2 * r * (1f + 0.5f * stretch)
+                val h = 2 * r * (1f - 0.25f * stretch)
+                drawOval(color, Offset(pos.x - w / 2, pos.y - h / 2), Size(w, h))
+            }
+        }
+    }
+}
+
+/**
+ * A row that scrolls sideways fades out at an edge it has more past, instead of slicing a pill or
+ * a card through: the content's own alpha, so whatever is behind the row shows through.
+ */
+internal fun Modifier.edgeFade(scroll: androidx.compose.foundation.ScrollState, width: Dp = 28.dp): Modifier =
+    this.graphicsLayer { compositingStrategy = androidx.compose.ui.graphics.CompositingStrategy.Offscreen }
+        .drawWithContent {
+            drawContent()
+            val w = width.toPx().coerceAtMost(size.width / 3f)
+            if (scroll.value > 0) drawRect(
+                androidx.compose.ui.graphics.Brush.horizontalGradient(0f to Color.Transparent, 1f to Color.Black, startX = 0f, endX = w),
+                size = Size(w, size.height), blendMode = androidx.compose.ui.graphics.BlendMode.DstIn,
+            )
+            if (scroll.value < scroll.maxValue) drawRect(
+                androidx.compose.ui.graphics.Brush.horizontalGradient(0f to Color.Black, 1f to Color.Transparent, startX = size.width - w, endX = size.width),
+                topLeft = Offset(size.width - w, 0f), size = Size(w, size.height), blendMode = androidx.compose.ui.graphics.BlendMode.DstIn,
+            )
+        }

app/src/main/java/com/droiddeck/launcher/ui/SheetRows.kt

@@ -0,0 +1,63 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import com.droiddeck.launcher.R
+
+// The rows the lifted sheets add to what the session settings already had: frame generation,
+// Performance and the link to the GPU drivers on Components.
+
+/** Frame generation, moved here from Setup: it is how Play's games are drawn. */
+@Composable
+internal fun FrameGenGroup(s: FrontEndState, a: FrontEndActions) {
+    val host = rememberMenuHost()
+    SettingsGroup(stringResource(R.string.frame_gen_title)) {
+        SettingsRow(stringResource(R.string.frame_gen_title), stringResource(R.string.frame_gen_hint), highlighted = host.open == "fg") {
+            Box {
+                ValueChip(s.frameGenLabel, host.open == "fg") { host.open = if (host.open == "fg") null else "fg" }
+                FrameGenMenu(host, s.frameGen, s.lossless, a.onFrameGenPick, a.onImportLossless)
+            }
+        }
+    }
+}
+
+/**
+ * Performance (CPU core assignment), opened from the sheet's Session chip: its page floods out of
+ * this row, and Back draws it into the row again with the sheet lifted where it was.
+ */
+@Composable
+internal fun PerformanceLink(a: FrontEndActions, rail: String, tab: String) {
+    val id = "sheet:performance"
+    val title = stringResource(R.string.setup_tool_performance)
+    SettingsGroup(title) {
+        LinkRow(title, stringResource(R.string.setup_tool_performance_hint), stringResource(R.string.store_open), id, arrow = "›") {
+            Hops.sources[id]?.let { at ->
+                PageOrigin.mark(Origin(at, 12f * Hops.density))
+                Hops.restore = HopOrigin(rail, HOP_SURFACE_SHEET, tab, id, at, "", dest = rail, page = "performance")
+            }
+            a.onPerformance()
+        }
+    }
+}
+
+/**
+ * The GPU drivers in use, read only, and a link to where they are set: A hops to Components with
+ * the GPU drivers layer chosen, and B there comes back to this row.
+ */
+@Composable
+internal fun DriversLink(a: FrontEndActions, summary: String?, rail: String, back: String) {
+    val id = "sheet:gpu-drivers"
+    SettingsGroup(stringResource(R.string.mode_drivers)) {
+        LinkRow(
+            stringResource(R.string.sheet_graphics_drivers), summary ?: stringResource(R.string.common_auto),
+            stringResource(R.string.rail_components), id,
+        ) {
+            val at = Hops.sources[id]
+            if (at == null) a.onComponentsTab(GPU_TAB)
+            else Hops.go(HopOrigin(rail, HOP_SURFACE_SHEET, SheetTab.DISPLAY, id, at, back, dest = "components", page = "components")) {
+                a.onComponentsTab(GPU_TAB)
+            }
+        }
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt

@@ -58,6 +58,7 @@ import androidx.compose.ui.graphics.drawscope.DrawScope
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.drawscope.inset
 import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.graphics.drawscope.translate
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalDensity
 import coil.compose.rememberAsyncImagePainter
@@ -82,41 +83,62 @@ internal fun SteamHome(s: FrontEndState, a: FrontEndActions, modifier: Modifier)
     // came out differently from one read of the library to the next moved every capsule.
     val games = remember(s.steamGames) { s.steamGames.sortedWith(compareByDescending<Library.SteamGame> { it.lastPlayed }.thenBy { it.gameId }) }
     val narrow = LocalNarrowPane.current
-    val colors = MaterialTheme.colorScheme
     // Where the words and buttons sit, for the empty library's wandering mark to keep off.
     var words by remember { mutableStateOf<Rect?>(null) }
-    Box(modifier = modifier.fillMaxSize().clipToBounds()) {
-        when {
-            games.isEmpty() -> EmptyLibrary(avoid = words) { WallFade() }
-            games.size < WALL_MIN_GAMES -> CapsuleFan(games)
-            else -> {
-                CapsuleWall(games)
-                WallFade()
+    val mode = com.droiddeck.launcher.session.SessionService.MODE_STEAM
+    val tabs = modeSheetTabs(steam = true).map { it to sheetTabLabel(it) }
+    val back = stringResource(R.string.hop_from_play)
+    val extras = SheetExtras(
+        frameGen = { FrameGenGroup(s, a) },
+        performance = { PerformanceLink(a, "steam", SheetTab.SESSION) },
+        drivers = { summary -> DriversLink(a, summary, "steam", back) },
+        // Offline mode lives with Steam's other settings; Setup only checks the account.
+        account = { host ->
+            SettingsGroup(stringResource(R.string.setup_account)) {
+                ToggleRow(
+                    host, "offline", stringResource(R.string.setup_offline),
+                    s.offlineAccount?.let { if (it.isEmpty()) stringResource(R.string.setup_signed_in_unnamed) else stringResource(R.string.setup_signed_in, it) } ?: stringResource(R.string.setup_sign_in_first),
+                    s.offline, enabled = s.offlineAccount != null,
+                ) { a.onOffline() }
             }
-        }
-        Column(
-            modifier = Modifier.align(Alignment.BottomStart)
-                .padding(start = if (narrow) 20.dp else 44.dp, bottom = if (narrow) 20.dp else 44.dp, end = 20.dp)
-                .onPlaced { words = it.boundsInParent() },
-        ) {
-            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        },
+    )
+    LiftHero(
+        key = "steam", tabs = tabs,
+        onOpen = a.onSteamSettings, onPrimary = a.onPlay,
+        modifier = modifier.clipToBounds(),
+        start = if (narrow) 20.dp else 44.dp, bottom = if (narrow) 20.dp else 44.dp,
+        background = {
+            when {
+                // The mark wanders over this fade, so it sinks with the wall: drawn a little oversized,
+                // it still reaches the pane's edges at the sink's 0.95.
+                games.isEmpty() -> EmptyLibrary(avoid = words) { Box(Modifier.fillMaxSize().graphicsLayer { scaleX = 1.06f; scaleY = 1.06f }) { WallFade() } }
+                games.size < WALL_MIN_GAMES -> CapsuleFan(games)
+                else -> CapsuleWall(games)
+            }
+        },
+        scrim = { if (games.size >= WALL_MIN_GAMES) WallFade() },
+        words = {
+            Row(
+                verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp),
+                modifier = Modifier.onPlaced { words = it.boundsInParent() },
+            ) {
                 Wordmark(if (narrow) 30.dp else 40.dp)
                 // Said only when something stands between Play and Steam; a ready runtime needs no words.
                 if (s.busy || !s.ready || (s.available != null && s.available != s.installed)) RuntimeChip(s)
             }
-            Spacer(Modifier.height(18.dp))
-            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) {
-                // Enabled without a runtime: the session's loading screen installs it first.
-                PrimaryButton(stringResource(R.string.games_play_steam), enabled = !s.busy, main = true, large = true, icon = Icons.Filled.PlayArrow, modifier = Modifier.testTag("play-steam"), onClick = a.onPlay)
-                Cog(size = 54.dp, onClick = a.onSteamSettings)
-            }
-        }
-    }
+        },
+        button = { click ->
+            // Enabled without a runtime: the session's loading screen installs it first.
+            PrimaryButton(stringResource(R.string.games_play_steam), enabled = !s.busy, main = true, large = true, icon = Icons.Filled.PlayArrow, modifier = Modifier.testTag("play-steam"), onClick = click)
+        },
+        rows = { tab -> a.modeSheet(mode, tab, extras) },
+    )
 }
 
 /** The wall fades out behind the words, and toward the bottom where the buttons sit. */
 @Composable
-private fun WallFade() {
+internal fun WallFade() {
     val colors = MaterialTheme.colorScheme
     Box(
         Modifier.fillMaxSize().background(
@@ -147,8 +169,12 @@ internal fun CapsuleWall(
     TiltedWall(games.size, driftMs, modifier) { i -> if (games.isEmpty()) blank else WallCapsule(artBrush(hueOf(games[i].name)), games[i].art) }
 }
 
-/** One capsule of a [TiltedWall]: its ground, the art laid over it once loaded, and an outline. */
-internal class WallCapsule(val ground: Brush, val art: Any? = null, val edge: Color? = null)
+/**
+ * One capsule of a [TiltedWall]: its ground, the art laid over it once loaded, and an outline. A
+ * tile that is an app rather than a cover carries an [icon] instead (a drawable id or an image),
+ * drawn whole at the tile's centre, and a window's [bar] along its foot.
+ */
+internal class WallCapsule(val ground: Brush, val art: Any? = null, val edge: Color? = null, val icon: Any? = null, val bar: Color? = null)
 
 /**
  * [CapsuleWall]'s tilted, drifting columns for any [count] of capsules; [capsule] describes number i
@@ -161,25 +187,28 @@ internal fun TiltedWall(
     count: Int,
     driftMs: Int,
     modifier: Modifier = Modifier,
+    /** One tile's size, the gap between tiles and their corner: portrait capsules unless a wall says otherwise. */
+    capW: androidx.compose.ui.unit.Dp = 112.dp,
+    capH: androidx.compose.ui.unit.Dp = 168.dp,
+    gap: androidx.compose.ui.unit.Dp = 14.dp,
+    corner: androidx.compose.ui.unit.Dp = 10.dp,
     capsule: (index: Int) -> WallCapsule,
 ) {
-    val capW = 112.dp
-    val capH = 168.dp
-    val gap = 14.dp
     // Animations off in the system settings: a still wall.
     val still = Motion.scale == 0f
     // The wall moves a few pixels a step. Stepped on frames at most every 15 ms it looks the same as
-    // stepped on every frame, which on a 120 Hz screen drew it twice as often.
+    // stepped on every frame, which on a 120 Hz screen drew it twice as often. The phase advances by
+    // the time since the last step over the period now, so a period that changes (Flathub's wall
+    // slowing while it sets up) changes the speed without the wall jumping.
     val drift = remember { mutableFloatStateOf(0f) }
-    if (!still) LaunchedEffect(driftMs) {
-        val period = driftMs * 1_000_000.0 * Motion.scale
-        var start = 0L
+    val period = androidx.compose.runtime.rememberUpdatedState(driftMs)
+    if (!still) LaunchedEffect(Unit) {
         var shown = 0L
         while (true) withFrameNanos { now ->
-            if (start == 0L) start = now
-            if (shown == 0L || now - shown >= DRIFT_STEP_NS) {
+            if (shown == 0L) shown = now
+            else if (now - shown >= DRIFT_STEP_NS) {
+                drift.floatValue = ((drift.floatValue + (now - shown) / (period.value * 1_000_000.0 * Motion.scale)) % 1.0).toFloat()
                 shown = now
-                drift.floatValue = ((now - start) % period / period).toFloat()
             }
         }
     }
@@ -196,14 +225,15 @@ internal fun TiltedWall(
         val run = (capH + gap) * perRun
         val cap = with(density) { Size(capW.toPx(), capH.toPx()) }
         val step = with(density) { (capH + gap).toPx() }
-        val radius = with(density) { 10.dp.toPx() }
+        val radius = with(density) { corner.toPx() }
         val line = with(density) { 1.dp.toPx() }
+        val barH = with(density) { 12.dp.toPx() }
         val indexOf = { c: Int, i: Int -> if (count == 0) 0 else (c * 5 + (i % perRun) * 3) % count }
         val shown = remember(count, columns, perRun) { (0 until columns).flatMap { c -> (0 until perRun).map { indexOf(c, it) } }.distinct() }
         val looks = HashMap<Int, Pair<WallCapsule, Painter?>>(shown.size * 2)
         for (index in shown) key(index) {
             val look = capsule(index)
-            looks[index] = look to look.art?.let { rememberCapsuleArt(it, cap, radius) }
+            looks[index] = look to (look.art?.let { rememberCapsuleArt(it, cap, radius) } ?: look.icon?.let { rememberIcon(it) })
         }
         Row(
             horizontalArrangement = Arrangement.spacedBy(gap),
@@ -224,7 +254,7 @@ internal fun TiltedWall(
                             for (i in 0 until perRun * 2) {
                                 val (look, art) = looks[indexOf(c, i)] ?: continue
                                 val top = i * step
-                                inset(0f, top, 0f, size.height - top - cap.height) { drawCapsule(look, art, radius, line) }
+                                inset(0f, top, 0f, size.height - top - cap.height) { drawCapsule(look, art, radius, line, barH) }
                             }
                         },
                 )
@@ -247,9 +277,20 @@ private fun rememberCapsuleArt(model: Any, size: Size, radius: Float): Painter {
     )
 }
 
-private fun DrawScope.drawCapsule(look: WallCapsule, art: Painter?, radius: Float, line: Float) {
+/** An app's icon for a wall tile: a bundled drawable, or an image Coil loads. */
+@Composable
+private fun rememberIcon(model: Any): Painter =
+    if (model is Int) androidx.compose.ui.res.painterResource(model) else rememberAsyncImagePainter(model)
+
+private fun DrawScope.drawCapsule(look: WallCapsule, art: Painter?, radius: Float, line: Float, barH: Float = 0f) {
     drawRoundRect(look.ground, size = size, cornerRadius = CornerRadius(radius))
-    if (art != null) with(art) { draw(size) }
+    look.bar?.let { drawRect(it, Offset(0f, size.height - barH), Size(size.width, barH)) }
+    if (art != null && look.icon != null) {
+        // An app's icon whole at the tile's centre (above a window's bar), not cropped over it.
+        val side = minOf(size.width, size.height - (if (look.bar != null) barH else 0f)) * 0.5f
+        val cy = (size.height - (if (look.bar != null) barH else 0f)) / 2f
+        translate((size.width - side) / 2f, cy - side / 2f) { with(art) { draw(Size(side, side)) } }
+    } else if (art != null) with(art) { draw(size) }
     look.edge?.let {
         drawRoundRect(it, Offset(line / 2, line / 2), Size(size.width - line, size.height - line), CornerRadius(radius - line / 2), style = Stroke(line))
     }

app/src/main/java/com/droiddeck/launcher/ui/StepOut.kt

@@ -7,6 +7,8 @@ import androidx.compose.foundation.LocalIndication
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.focusGroup
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.foundation.hoverable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
@@ -133,7 +135,7 @@ internal enum class StepSide {
 }
 
 /** The choices' side of a [StepOut]: each piece fades in on its own beat, and [first] takes focus. */
-internal class StepOutScope(private val items: List<Animatable<Float, AnimationVector1D>>, val first: FocusRequester, val open: Boolean) {
+internal class StepOutScope(private val items: List<Animatable<Float, AnimationVector1D>>, val first: FocusRequester, val open: Boolean, val maxHeight: Dp) {
     /** Piece [i] (0 first) of the box: it fades and rises in after the box has stepped out. */
     fun Modifier.stepItem(i: Int): Modifier = graphicsLayer {
         val v = items[i.coerceIn(0, items.lastIndex)].value
@@ -179,11 +181,27 @@ internal fun StepOut(
     var grown by remember { mutableStateOf(false) }
     var measured by remember { mutableStateOf<IntSize?>(null) }
     val first = remember { FocusRequester() }
+    // The control focus was on as it opened: focus goes back to it as it folds, not to wherever
+    // the screen puts a pad with nothing focused (the rail).
+    val glide = LocalFocusGlide.current
+    val opener = remember { arrayOfNulls<GlideSource>(1) }
+    val openNow = androidx.compose.runtime.rememberUpdatedState(open)
+    // While the box grows or folds the ring keeps out (it flew across the moving shape) and comes
+    // back on whatever has focus once it has settled: the first choice, or the control again.
+    var moving by remember { mutableStateOf(false) }
+    if (moving) VeilRing()
     val pull = with(density) { OutPull.toPx() }
     val corner = pillCorner?.let { with(density) { it.toPx() } } ?: minOf(pill.height, pill.width) / 2f
 
     BoxWithConstraints(Modifier.fillMaxSize()) {
         val hostWidth = constraints.maxWidth.toFloat()
+        val hostHeight = constraints.maxHeight.toFloat()
+        val availableHeight = with(density) {
+            maxOf(hostHeight - pill.bottom - pull, pill.top - pull).coerceAtLeast(44.dp.toPx()).toDp()
+        }
+        // No room under the control (a row near the foot of the screen): it steps out upward
+        // instead, the same outline mirrored about the control.
+        val up = measured?.let { pill.bottom + pull + it.height > hostHeight && pill.top - pull - it.height >= 0f } ?: false
         val room = if (side == StepSide.Left) pill.right else hostWidth - pill.left
         val maxW = with(density) { maxWidth.toPx() }.coerceAtMost(room).coerceAtLeast(pill.width)
         LaunchedEffect(open, measured) {
@@ -195,6 +213,7 @@ internal fun StepOut(
             val boxBottom = pill.bottom + pull + c.height
             if (open) {
                 if (!grown) {
+                    opener[0] = glide?.current
                     edge.snapTo(rest); bottom.snapTo(pill.bottom); tint.snapTo(0f)
                     pieces.forEach { it.snapTo(0f) }
                     grown = true
@@ -202,8 +221,12 @@ internal fun StepOut(
                 coroutineScope {
                     launch { dim.animateTo(1f, Motion.tw(260)) }
                     launch { tint.animateTo(1f, Motion.tw(200)) }
-                    launch { bottom.animateTo(boxBottom, Motion.sp(0.7f, 380f)) }
-                    launch { delay(Motion.ms(110).toLong()); edge.animateTo(out, Motion.sp(0.55f, 300f)) }
+                    // Down and out together, on one spring: down first drew the control as a stick
+                    // that then snapped out sideways.
+                    moving = true
+                    val down = launch { bottom.animateTo(boxBottom, Motion.sp(0.8f, 380f)) }
+                    val across = launch { edge.animateTo(out, Motion.sp(0.8f, 380f)) }
+                    launch { down.join(); across.join(); moving = false }
                     pieces.forEachIndexed { i, a ->
                         launch { delay(Motion.ms(260 + i * 55).toLong()); a.animateTo(1f, Motion.tw(220)) }
                     }
@@ -214,14 +237,20 @@ internal fun StepOut(
                     }
                 }
             } else {
+                opener[0]?.let { o -> if (inputMode.inputMode == InputMode.Keyboard) runCatching { o.requester.requestFocus() } }
+                opener[0] = null
                 coroutineScope {
                     pieces.forEach { launch { it.animateTo(0f, Motion.tw(90)) } }
                     launch { delay(Motion.ms(60).toLong()); dim.animateTo(0f, Motion.tw(300)) }
-                    launch { delay(Motion.ms(60).toLong()); edge.animateTo(rest, Motion.sp(1f, 420f)) }
-                    launch { delay(Motion.ms(160).toLong()); bottom.animateTo(pill.bottom, Motion.sp(1f, 380f)) }
+                    // In and up together on a timed ease: width first left a tall tail under the
+                    // control, and a damped spring's tail kept a nub of it on screen.
+                    moving = true
+                    launch { delay(Motion.ms(60).toLong()); edge.animateTo(rest, Motion.tw(240)) }
+                    launch { delay(Motion.ms(60).toLong()); bottom.animateTo(pill.bottom, Motion.tw(240)) }
                     launch { delay(Motion.ms(200).toLong()); tint.animateTo(0f, Motion.tw(200)) }
                 }
                 grown = false
+                moving = false
                 onClosed()
             }
         }
@@ -246,8 +275,24 @@ internal fun StepOut(
             if (!grown) return@Canvas
             if (side == StepSide.Left) stepPath(path, pill, edge.value, bottom.value, pill.bottom + pull, boxCorner, fillet, corner)
             else stepPathRight(path, pill, edge.value, bottom.value, pill.bottom + pull, boxCorner, fillet, corner)
-            drawPath(path, lerp(hotFill, restFill, tint.value))
-            drawPath(path, accent.copy(alpha = lerpF(0.9f, 0.55f, tint.value)), style = Stroke(rim))
+            if (up) path.transform(Matrix().apply { this[1, 1] = -1f; this[3, 1] = pill.top + pill.bottom })
+            // Barely out of the control, the pull and its fillet drew a hook off the control's foot:
+            // the outline comes in over the first part of the way out (and goes over the last part
+            // of the way back), by how far along it is. A share of the way, not a distance: a box
+            // no wider than its control (a confirm under a full-width row) never got 24dp out, and
+            // was never drawn at all.
+            val a = measured?.let { c ->
+                val rest = if (side == StepSide.Left) pill.left else pill.right
+                val out = if (side == StepSide.Left) (pill.right - c.width).coerceAtLeast(0f) else (pill.left + c.width).coerceAtMost(hostWidth)
+                val down = pill.bottom + pull + c.height - pill.bottom
+                val across = kotlin.math.abs(out - rest)
+                val fd = if (down < 1f) 1f else (bottom.value - pill.bottom) / down
+                val fa = if (across < 1f) 1f else kotlin.math.abs(edge.value - rest) / across
+                ((minOf(fd, fa) - 0.1f) / 0.3f).coerceIn(0f, 1f)
+            } ?: 0f
+            if (a <= 0.01f) return@Canvas
+            drawPath(path, lerp(hotFill, restFill, tint.value), alpha = a)
+            drawPath(path, accent.copy(alpha = lerpF(0.9f, 0.55f, tint.value) * a), style = Stroke(rim))
         }
         // The control's label rides on top, as the pull's handle.
         if (grown) Box(
@@ -258,15 +303,17 @@ internal fun StepOut(
         val x = if (side == StepSide.Left) pill.right - (measured?.width?.toFloat() ?: maxW) else pill.left
         Column(
             modifier = Modifier
-                .offset { IntOffset(x.roundToInt(), (pill.bottom + pull).roundToInt()) }
+                .offset { IntOffset(x.roundToInt(), (if (up) pill.top - pull - (measured?.height ?: 0) else pill.bottom + pull).roundToInt()) }
                 .widthIn(min = with(density) { pill.width.toDp() }, max = with(density) { maxW.toDp() })
+                .heightIn(max = availableHeight)
                 .onSizeChanged { if (measured != it) measured = it }
                 .controllerBack(onDismiss)
                 // A pad stays in the box until it is answered or folded, as it did in Stop's dialog.
-                .focusProperties { exit = { FocusRequester.Cancel } }
+                .focusProperties { exit = { if (openNow.value) FocusRequester.Cancel else FocusRequester.Default } }
                 .focusGroup()
+                .verticalScroll(rememberScrollState())
                 .padding(start = 14.dp, end = 14.dp, top = 12.dp, bottom = 12.dp),
-        ) { StepOutScope(pieces, first, open).content() }
+        ) { StepOutScope(pieces, first, open, availableHeight).content() }
     }
 }
 

app/src/main/java/com/droiddeck/launcher/ui/Steps.kt

@@ -0,0 +1,55 @@
+package com.droiddeck.launcher.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.geometry.Offset
+
+// The front end's confirms and short lists, each stepping out of the control that asked for it
+// (StepOut): a sheet's Uninstall, a Components swap, a remove. The Stores page keeps its own, in
+// StoresMotion; everything else asks here and is drawn over the whole screen.
+
+internal object Steps {
+    /** The confirm or list stepping out of a control now, and whether it is open. */
+    var step by mutableStateOf<StepAsk?>(null)
+        private set
+    var open by mutableStateOf(false)
+        private set
+
+    fun ask(a: StepAsk) {
+        step?.onDismiss()
+        step = a
+        open = true
+    }
+
+    /** Folds the current one back into its control. */
+    fun fold() { open = false }
+
+    /** Drops it at once: the control it came from has gone. */
+    fun drop() {
+        step?.let { step = null; it.onDismiss() }
+        open = false
+    }
+
+    internal fun closed(a: StepAsk) {
+        if (step === a) step = null
+        a.onDismiss()
+    }
+}
+
+/** [Steps] drawn over an element at [origin] (root px) that fills the screen. */
+@Composable
+internal fun StepsLayer(origin: Offset) {
+    val ask = Steps.step ?: return
+    // Back (B, or the system's) folds what is stepped out, before it reaches the page under it.
+    androidx.activity.compose.BackHandler(enabled = Steps.open) { Steps.fold() }
+    key(ask) {
+        StepOut(
+            open = Steps.open, pill = ask.anchor.translate(-origin), side = ask.side, accent = ask.accent,
+            onDismiss = { Steps.fold() }, onClosed = { Steps.closed(ask) },
+            pillCorner = ask.pillCorner, maxWidth = ask.maxWidth, items = ask.items, handle = ask.handle, content = ask.content,
+        )
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/StoreAchievementsUi.kt

@@ -0,0 +1,381 @@
+package com.droiddeck.launcher.ui
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.LocalIndication
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.focusable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.EmojiEvents
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import coil.compose.AsyncImage
+import com.droiddeck.launcher.R
+import com.droiddeck.launcher.stores.StoreAchievements
+import com.droiddeck.launcher.stores.StoreAchievements.Achievement
+import com.droiddeck.launcher.stores.StoreAchievements.Reason
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.text.DateFormat
+import java.util.Date
+
+private val TrophyGold = Color(0xFFF5C542)
+
+internal class AchievementsState(val list: List<Achievement>?, val reason: Reason?, val reading: Boolean) {
+    val done: Int get() = list?.count { it.unlocked } ?: 0
+    val all: Boolean get() = !list.isNullOrEmpty() && list.all { it.unlocked }
+
+    companion object { val READING = AchievementsState(null, null, true) }
+}
+
+/** The cached list at once, then the store's answer (the cache stays if the store fails). */
+@Composable
+internal fun rememberAchievements(game: StoreAchievements.Game?): AchievementsState? {
+    val ctx = LocalContext.current.applicationContext
+    var state by remember(game) { mutableStateOf(if (game == null) null else AchievementsState.READING) }
+    LaunchedEffect(game, StoreAchievements.revision) {
+        if (game == null) return@LaunchedEffect
+        val source = StoreAchievements.forSource(game.source) ?: return@LaunchedEffect
+        val cached = withContext(Dispatchers.IO) { source.cached(ctx, game) }
+        if (cached != null) state = AchievementsState(cached, null, true)
+        state = when (val r = withContext(Dispatchers.IO) { source.fetch(ctx, game) }) {
+            is StoreAchievements.Result.Found -> AchievementsState(r.list, null, false)
+            is StoreAchievements.Result.Failed -> AchievementsState(cached, r.reason, false)
+        }
+    }
+    return state
+}
+
+@Composable
+internal fun achievementsNote(state: AchievementsState, label: String): String? = when {
+    !state.list.isNullOrEmpty() -> null
+    state.reading -> stringResource(R.string.achievements_reading)
+    state.reason == Reason.SIGNED_OUT -> stringResource(R.string.achievements_signed_out, label)
+    state.reason == Reason.UNREACHABLE -> stringResource(R.string.achievements_unreachable, label)
+    else -> stringResource(R.string.achievements_none, label)
+}
+
+@Composable
+internal fun Trophy(size: Dp = 18.dp, modifier: Modifier = Modifier, description: String? = stringResource(R.string.achievements_all)) {
+    Icon(Icons.Filled.EmojiEvents, description, modifier.size(size), tint = TrophyGold)
+}
+
+@Composable
+internal fun AchievementsProgress(state: AchievementsState, compact: Boolean = false) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val list = state.list ?: return
+    if (list.isEmpty()) return
+    Column(verticalArrangement = Arrangement.spacedBy(if (compact) 6.dp else 8.dp)) {
+        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+            Text(stringResource(R.string.achievements_count, state.done, list.size), fontSize = 13.sp, color = colors.onSurfaceVariant)
+            if (state.all) Trophy(16.dp)
+        }
+        LinearProgressIndicator(
+            progress = { state.done / list.size.toFloat() },
+            color = pal.signal, trackColor = pal.line,
+            modifier = Modifier.fillMaxWidth().height(4.dp).clip(RoundedCornerShape(2.dp)),
+        )
+    }
+}
+
+@Composable
+private fun AchievementGroupLabel(label: String) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth().padding(top = 6.dp, bottom = 2.dp)) {
+        Text(label.uppercase(), fontSize = 11.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 1.2.sp, color = colors.onSurfaceVariant)
+        Box(Modifier.weight(1f).height(1.dp).background(pal.line))
+    }
+}
+
+/** Unlocked (newest first), locked, then hidden ones not yet unlocked. */
+private fun groups(list: List<Achievement>): List<Pair<Int, List<Achievement>>> = listOf(
+    R.string.achievements_group_unlocked to list.filter { it.unlocked }.sortedByDescending { it.unlockedAt },
+    R.string.achievements_group_locked to list.filter { !it.unlocked && !it.hidden },
+    R.string.achievements_group_hidden to list.filter { !it.unlocked && it.hidden },
+).filter { it.second.isNotEmpty() }
+
+/** Focusable so the pad can scroll the list. */
+@Composable
+internal fun AchievementRow(a: Achievement, compact: Boolean, modifier: Modifier = Modifier) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val interaction = remember { MutableInteractionSource() }
+    val hot = interaction.collectIsFocusedAsState().value
+    val shape = RoundedCornerShape(12.dp)
+    val secret = a.hidden && !a.unlocked
+    val icon = if (compact) 36.dp else 48.dp
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = modifier.fillMaxWidth().clip(shape)
+            .background(if (hot) pal.signal.copy(alpha = 0.10f) else colors.surface)
+            .glideBorder(hot, shape, pal.signal, pal.line)
+            .focusable(interactionSource = interaction)
+            .padding(if (compact) 8.dp else 10.dp),
+    ) {
+        Box(Modifier.size(icon).clip(RoundedCornerShape(8.dp)).background(pal.surfaceVariant)) {
+            val url = if (a.unlocked) a.icon else a.iconLocked ?: a.icon
+            if (url != null) AsyncImage(
+                model = url, contentDescription = null, contentScale = ContentScale.Crop,
+                modifier = Modifier.fillMaxSize().alpha(if (a.unlocked) 1f else 0.55f),
+            )
+        }
+        Spacer(Modifier.width(12.dp))
+        Column(Modifier.weight(1f)) {
+            Text(
+                if (secret) stringResource(R.string.achievements_hidden) else a.name,
+                fontSize = if (compact) 14.sp else 15.sp, fontWeight = FontWeight.SemiBold,
+                color = if (a.unlocked) colors.onBackground else colors.onSurfaceVariant,
+                maxLines = if (compact) 1 else 2, overflow = TextOverflow.Ellipsis,
+            )
+            val desc = if (secret) stringResource(R.string.achievements_hidden_detail) else a.description
+            if (desc.isNotEmpty()) Text(
+                desc, fontSize = if (compact) 12.sp else 13.sp, lineHeight = if (compact) 16.sp else 18.sp,
+                color = colors.onSurfaceVariant, maxLines = if (compact) 1 else 3, overflow = TextOverflow.Ellipsis,
+            )
+        }
+        if (a.unlocked && a.unlockedAt > 0) {
+            Spacer(Modifier.width(10.dp))
+            Text(
+                DateFormat.getDateInstance(DateFormat.MEDIUM).format(Date(a.unlockedAt * 1000)),
+                fontSize = 12.sp, fontWeight = FontWeight.Medium, color = pal.signal,
+            )
+        }
+    }
+}
+
+@Composable
+internal fun StoreAchievementsSection(game: StoreAchievements.Game) {
+    val label = StoreAchievements.forSource(game.source)?.label ?: return
+    StoreAchievementsSectionContent(label, rememberAchievements(game) ?: return)
+}
+
+@Composable
+internal fun StoreAchievementsSectionContent(label: String, state: AchievementsState) {
+    val colors = MaterialTheme.colorScheme
+    val list = state.list
+    // Hidden for games without achievements.
+    if (list.isNullOrEmpty() && !state.reading && state.reason != Reason.SIGNED_OUT && state.reason != Reason.UNREACHABLE) return
+    val narrow = LocalNarrowPane.current
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth().padding(top = 18.dp)) {
+        Text(stringResource(R.string.achievements_title), fontSize = 18.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
+        achievementsNote(state, label)?.let { Text(it, fontSize = 13.sp, color = colors.onSurfaceVariant) }
+        if (!list.isNullOrEmpty()) {
+            AchievementsProgress(state)
+            for ((label, group) in groups(list)) {
+                AchievementGroupLabel(stringResource(label, group.size))
+                for (a in group) AchievementRow(a, compact = narrow)
+            }
+        }
+    }
+}
+
+private fun LazyListScope.achievementItems(list: List<Achievement>, compact: Boolean, first: FocusRequester) {
+    var index = 0
+    for ((label, group) in groups(list)) {
+        item(key = "group-$label") { AchievementGroupLabel(stringResource(label, group.size)) }
+        val offset = index
+        itemsIndexed(group, key = { _, a -> "a-" + a.id }) { i, a ->
+            AchievementRow(a, compact, if (offset + i == 0) Modifier.focusRequester(first) else Modifier)
+        }
+        index += group.size
+    }
+}
+
+@Composable
+internal fun SessionAchievements(game: StoreAchievements.Game, title: String?, onClose: () -> Unit) {
+    val label = StoreAchievements.forSource(game.source)?.label.orEmpty()
+    SessionAchievementsPanel(label, rememberAchievements(game) ?: AchievementsState.READING, title, onClose)
+}
+
+@Composable
+internal fun SessionAchievementsPanel(label: String, state: AchievementsState, title: String?, onClose: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    BackHandler(onBack = onClose)
+    BoxWithConstraints(
+        Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.45f))
+            .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClick = onClose),
+        contentAlignment = Alignment.CenterEnd,
+    ) {
+        val short = maxHeight < 440.dp
+        Column(
+            Modifier.fillMaxHeight().width(minOf(420.dp, maxWidth * 0.92f))
+                .background(pal.background.copy(alpha = 0.97f))
+                .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) {}
+                .controllerBack(onClose)
+                .padding(if (short) 12.dp else 16.dp),
+        ) {
+            Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) {
+                Column(Modifier.weight(1f)) {
+                    Text(stringResource(R.string.achievements_title), fontSize = if (short) 18.sp else 20.sp, fontWeight = FontWeight.Bold, color = colors.onBackground)
+                    if (title != null) Text(title, fontSize = 13.sp, color = colors.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                }
+                state.list?.takeIf { it.isNotEmpty() }?.let { list ->
+                    if (state.all) Trophy(20.dp, Modifier.padding(end = 6.dp))
+                    Text(stringResource(R.string.achievements_count_short, state.done, list.size), fontSize = 16.sp, fontWeight = FontWeight.SemiBold, color = pal.signal)
+                }
+            }
+            val list = state.list
+            if (list.isNullOrEmpty()) {
+                Text(achievementsNote(state, label).orEmpty(), fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(top = 14.dp))
+            } else {
+                LinearProgressIndicator(
+                    progress = { state.done / list.size.toFloat() },
+                    color = pal.signal, trackColor = pal.line,
+                    modifier = Modifier.padding(top = if (short) 6.dp else 10.dp).fillMaxWidth().height(4.dp).clip(RoundedCornerShape(2.dp)),
+                )
+                val first = remember { FocusRequester() }
+                LazyColumn(
+                    Modifier.weight(1f).padding(top = 6.dp),
+                    contentPadding = PaddingValues(vertical = 6.dp),
+                    verticalArrangement = Arrangement.spacedBy(6.dp),
+                ) { achievementItems(list, short, first) }
+                LaunchedEffect(list.isNotEmpty()) {
+                    withFrameNanos {} // rows lay out a frame after composition
+                    runCatching { first.requestFocus() }
+                }
+            }
+        }
+    }
+}
+
+/** [progress]: (unlocked, total), or null when unknown. */
+@Composable
+internal fun DrawerAchievementsRow(progress: Pair<Int, Int>?, modifier: Modifier = Modifier, onClick: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val pal = LocalPalette.current
+    val interaction = remember { MutableInteractionSource() }
+    val hot = interaction.collectIsFocusedAsState().value
+    val shape = RoundedCornerShape(12.dp)
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        modifier = modifier.fillMaxWidth().height(44.dp).clip(shape)
+            .background(if (hot) pal.signal.copy(alpha = 0.14f) else colors.surface)
+            .glideBorder(hot, shape, pal.signal, pal.line)
+            .clickable(interactionSource = interaction, indication = LocalIndication.current, onClick = onClick)
+            .controllerConfirm(onClick = onClick)
+            .padding(horizontal = 12.dp),
+    ) {
+        val all = progress != null && progress.second > 0 && progress.first == progress.second
+        Icon(Icons.Filled.EmojiEvents, null, tint = if (all) TrophyGold else if (hot) pal.signal else colors.onSurfaceVariant, modifier = Modifier.size(20.dp))
+        Text(stringResource(R.string.achievements_title), fontSize = 14.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, modifier = Modifier.weight(1f))
+        if (progress != null && progress.second > 0) {
+            Text(stringResource(R.string.achievements_count_short, progress.first, progress.second), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = pal.signal)
+        }
+    }
+}
+
+
+private val previewList = listOf(
+    Achievement("first", "First Steps", "Finish the tutorial.", hidden = false, unlocked = true, unlockedAt = 1_759_000_000, icon = null, iconLocked = null),
+    Achievement("boss", "Giant Slayer", "Defeat the warden of the old keep without taking damage.", hidden = false, unlocked = true, unlockedAt = 1_760_100_000, icon = null, iconLocked = null),
+    Achievement("collector", "Collector", "Find every relic in the valley.", hidden = false, unlocked = false, unlockedAt = 0, icon = null, iconLocked = null),
+    Achievement("secret", "The Last Door", "Open it.", hidden = true, unlocked = false, unlockedAt = 0, icon = null, iconLocked = null),
+)
+
+@Composable
+private fun PreviewSurface(content: @Composable () -> Unit) {
+    DroidDeckTheme(theme = Themes.GRAPHITE) {
+        Box(Modifier.fillMaxSize().background(LocalPalette.current.background).padding(16.dp)) { content() }
+    }
+}
+
+@Preview(name = "Store page section", widthDp = 800, heightDp = 600)
+@Composable
+private fun StoreAchievementsSectionPreview() = PreviewSurface {
+    Column(Modifier.width(560.dp)) { StoreAchievementsSectionContent("GOG", AchievementsState(previewList, null, false)) }
+}
+
+@Preview(name = "Store page section, signed out", widthDp = 800, heightDp = 200)
+@Composable
+private fun StoreAchievementsSectionSignedOutPreview() = PreviewSurface {
+    Column(Modifier.width(560.dp)) { StoreAchievementsSectionContent("Epic", AchievementsState(null, Reason.SIGNED_OUT, false)) }
+}
+
+@Preview(name = "Session panel", widthDp = 800, heightDp = 500)
+@Composable
+private fun SessionAchievementsPanelPreview() = DroidDeckTheme(theme = Themes.GRAPHITE) {
+    SessionAchievementsPanel("Epic", AchievementsState(previewList, null, false), "Hollow Valley", onClose = {})
+}
+
+@Preview(name = "Session panel, 4:3", widthDp = 560, heightDp = 420)
+@Composable
+private fun SessionAchievementsPanelShortPreview() = DroidDeckTheme(theme = Themes.GRAPHITE) {
+    SessionAchievementsPanel("GOG", AchievementsState(previewList.map {
+        Achievement(it.id, it.name, it.description, it.hidden, true, 1_760_000_000, null, null)
+    }, null, false), "Hollow Valley", onClose = {})
+}
+
+@Preview(name = "Session panel, offline", widthDp = 800, heightDp = 500)
+@Composable
+private fun SessionAchievementsPanelOfflinePreview() = DroidDeckTheme(theme = Themes.GRAPHITE) {
+    SessionAchievementsPanel("GOG", AchievementsState(null, Reason.UNREACHABLE, false), "Hollow Valley", onClose = {})
+}
+
+@Preview(name = "Drawer row", widthDp = 360, heightDp = 160)
+@Composable
+private fun DrawerAchievementsRowPreview() = PreviewSurface {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        DrawerAchievementsRow(2 to 4) {}
+        DrawerAchievementsRow(4 to 4) {}
+        DrawerAchievementsRow(null) {}
+    }
+}
+
+@Preview(name = "Rows", widthDp = 480, heightDp = 300)
+@Composable
+private fun AchievementRowPreview() = PreviewSurface {
+    Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        AchievementsProgress(AchievementsState(previewList, null, false))
+        for (a in previewList) AchievementRow(a, compact = false)
+        AchievementRow(previewList[0], compact = true)
+    }
+}

app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt

@@ -19,6 +19,13 @@ import com.droiddeck.launcher.stores.Store
 
 // Where a game came from, as a small coloured chip: Steam, one of the stores, or an added folder.
 
+/** Flathub's own accent, as each store has one, and the ink that reads on it. */
+internal val FlathubTeal = Color(0xFF3FB8AF)
+internal val FlathubInk = Color(0xFF04211F)
+
+/** The Store rail section's source id, for its colours. */
+internal const val FLATHUB = "flathub"
+
 /** The chip's colours per source: a tinted ground and a readable ink on it, one pair per store. */
 internal class SourceColours(val fill: Color, val ink: Color, val dot: Color)
 
@@ -27,6 +34,7 @@ internal fun sourceColours(source: String): SourceColours = when (source) {
     Store.EPIC.id -> SourceColours(Color(0xFF2A2A2A), Color(0xFFDDDDDD), Color(0xFFBDBDBD))
     Store.AMAZON.id -> SourceColours(Color(0xFF3A2A0A), Color(0xFFFFC266), Color(0xFFFF9900))
     Library.SOURCE_STEAM -> SourceColours(Color(0xFF16293D), Color(0xFF7CC4FF), Color(0xFF1A9FFF))
+    FLATHUB -> SourceColours(Color(0xFF0B2E2B), Color(0xFF9FE3DD), FlathubTeal)
     else -> SourceColours(Color(0xFF1A1D22), Color(0xFF9AA3AF), Color(0xFF9AA3AF))
 }
 

app/src/main/java/com/droiddeck/launcher/ui/StoreGridNavigation.kt

@@ -0,0 +1,7 @@
+package com.droiddeck.launcher.ui
+
+/** Vertical controller moves keep the same column, including across lazy item boundaries. */
+internal fun storeGridNeighbor(index: Int, count: Int, columns: Int, direction: Int): Int? {
+    if (index !in 0 until count || columns < 1 || direction !in listOf(-1, 1)) return null
+    return (index + columns * direction).takeIf { it in 0 until count }
+}

app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt

@@ -1,5 +1,6 @@
 package com.droiddeck.launcher.ui
 
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.layout.boundsInRoot
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.foundation.background
@@ -35,6 +36,7 @@ import coil.compose.AsyncImage
 import com.droiddeck.launcher.R
 import com.droiddeck.launcher.stores.CatalogItem
 import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoreAchievements
 import com.droiddeck.launcher.stores.StoresState
 import com.droiddeck.launcher.stores.download.DownloadState
 import com.droiddeck.launcher.stores.formatBytes
@@ -52,8 +54,6 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
     val installed = StoresState.installedGame(store, id)
     val download = StoresState.download("${store.id}:$id")?.takeIf { it.isActive }
     // Removal asks twice: one stray press of A should not cost a download.
-    var confirmRemove by remember(key) { mutableStateOf(false) }
-    LaunchedEffect(confirmRemove) { if (confirmRemove) { kotlinx.coroutines.delay(4000); confirmRemove = false } }
     val title = item?.title ?: installed?.sidecar?.title ?: id
     Rise(0) {
         Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp), modifier = Modifier.padding(bottom = 12.dp)) {
@@ -61,8 +61,16 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
             SourceChip(store.id)
         }
     }
-    Rise(1) {
-        Box(Modifier.fillMaxWidth().heightIn(min = if (narrow) 150.dp else 180.dp).clip(Shape16).background(artBrush(hueOf(title)))) {
+    // Out of a card, the hero holds still in its place: the card's flood lands on it, and a hero
+    // still rising in sat below where the flood had measured it (the art showed twice).
+    val hero: @Composable () -> Unit = {
+        androidx.compose.runtime.DisposableEffect(Unit) { onDispose { StoresMotion.heroAt = null } }
+        Box(
+            Modifier.fillMaxWidth().heightIn(min = if (narrow) 150.dp else 180.dp)
+                // The card it opened from floods onto this, and draws back into the card from it.
+                .onGloballyPositioned { StoresMotion.heroAt = it.boundsInRoot() }
+                .clip(Shape16).background(artBrush(hueOf(title))),
+        ) {
             val art = item?.imageUrl ?: installed?.sidecar?.hero ?: installed?.sidecar?.cover
             if (art != null) AsyncImage(model = art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize())
             Spacer(Modifier.matchParentSize().background(Brush.horizontalGradient(0f to colors.background.copy(alpha = 0.94f), 0.5f to colors.background.copy(alpha = 0.55f), 1f to Color.Transparent)))
@@ -83,10 +91,13 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
                             // Launching, the prefix and the files belong to the Games tab, where every
                             // installed game has them; here an install only says it is in Steam and
                             // offers the one thing Games does not: removing it.
+                            // The row keeps its shape: the chip stays, and Uninstall becomes its own
+                            // progress in place while the files go; then the page reads Install again.
                             ActionChip(stringResource(R.string.stores_in_steam), ok = true)
-                            SecondaryButton(if (confirmRemove) stringResource(R.string.stores_uninstall_confirm) else stringResource(R.string.stores_uninstall), enabled = download == null) {
-                                if (!confirmRemove) confirmRemove = true
-                                else { confirmRemove = false; StoresState.uninstall(ctx, installed) { StoresState.refresh(ctx); a.onLibraryChanged() }; onBack() }
+                            val gone = StoresState.uninstalling["${store.id}:$id"]
+                            if (gone != null) SecondaryButton(stringResource(R.string.stores_uninstalling), enabled = false, progress = gone) {}
+                            else UninstallButton(title, installed, enabled = download == null) {
+                                StoresState.uninstall(ctx, installed) { StoresState.refresh(ctx); a.onLibraryChanged() }
                             }
                         }
                         download != null -> {
@@ -110,6 +121,7 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
             }
         }
     }
+    if (StoresMotion.heroLands) hero() else Rise(1) { hero() }
     // Plain text only, and nothing at all when the store sent a template key instead of words.
     // A description that is only the title again (some stores fill it so) is no description.
     val description = item?.let { com.droiddeck.launcher.stores.cleanStoreText(it.description) }.orEmpty()
@@ -117,6 +129,49 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro
     if (description.isNotBlank()) Rise(2) {
         Text(description, fontSize = 13.sp, lineHeight = 19.sp, color = colors.onSurfaceVariant, maxLines = 6, overflow = TextOverflow.Ellipsis, modifier = Modifier.padding(top = 12.dp))
     }
+    val achievements = remember(store, id, item?.owned, installed) {
+        when {
+            StoreAchievements.forSource(store.id) == null -> null
+            item?.owned == true -> StoreAchievements.Game.of(item)
+            installed != null -> StoreAchievements.Game.of(installed.sidecar)
+            else -> null
+        }
+    }
+    if (achievements != null) Rise(3) { StoreAchievementsSection(achievements) }
+}
+
+/**
+ * Uninstall that asks the way Cancel does: a confirm steps out of it, naming the game and what
+ * goes (its size on disk), with Keep first so a stray A does nothing.
+ */
+@Composable
+private fun UninstallButton(title: String, game: com.droiddeck.launcher.stores.InstalledStoreGame, enabled: Boolean, onUninstall: () -> Unit) {
+    val colors = MaterialTheme.colorScheme
+    val placed = remember { arrayOfNulls<androidx.compose.ui.layout.LayoutCoordinates>(1) }
+    val heading = stringResource(R.string.stores_uninstall_title, title)
+    val size = com.droiddeck.launcher.stores.StoreSizes.onDisk["${game.sidecar.store.id}:${game.sidecar.id}"]
+    val body = if (size != null && size > 0) stringResource(R.string.stores_uninstall_body_size, formatBytes(size)) else stringResource(R.string.stores_uninstall_body)
+    val keep = stringResource(R.string.stores_notification_keep)
+    val remove = stringResource(R.string.stores_uninstall)
+    Box(Modifier.onGloballyPositioned { placed[0] = it }) {
+        SecondaryButton(remove, enabled = enabled) {
+            val at = placed[0]?.takeIf { it.isAttached }?.boundsInRoot() ?: return@SecondaryButton
+            // It starts once the confirm has folded back into the button: started at once, the button
+            // turned into the progress under the fold and it drew back into a control that had gone.
+            var confirmed = false
+            StoresMotion.ask(StepAsk(anchor = at, side = StepSide.Right, accent = colors.error, items = 3, pillCorner = 12.dp, maxWidth = 340.dp,
+                onDismiss = { if (confirmed) onUninstall() }, handle = {
+                Text(remove, fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.error, maxLines = 1)
+            }) {
+                StepTitle(heading)
+                Text(body, fontSize = 13.sp, lineHeight = 18.sp, color = colors.onSurfaceVariant, modifier = Modifier.stepItem(1).padding(start = 4.dp, bottom = 12.dp))
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End), modifier = Modifier.fillMaxWidth().stepItem(2)) {
+                    StepChoice(keep, enabled = open, modifier = Modifier.focusRequester(first)) { StoresMotion.fold() }
+                    StepChoice(remove, danger = true, enabled = open) { confirmed = true; StoresMotion.fold() }
+                }
+            })
+        }
+    }
 }
 
 /**

app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt

@@ -24,6 +24,9 @@ import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.geometry.CornerRadius
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Rect
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.TransformOrigin
 import androidx.compose.ui.graphics.graphicsLayer
@@ -45,6 +48,7 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.focusGroup
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxWithConstraints
 import androidx.compose.foundation.layout.Column
@@ -90,17 +94,10 @@ import com.droiddeck.launcher.stores.formatSpeed
 
 // The Downloads chip: one queue for the three stores, its settings and the engine log.
 
+/** The queue. Its settings (speed tier, downloads at a time) live in the chip row's cog only. */
 @Composable
 internal fun StoresDownloadsPane(s: FrontEndState, a: FrontEndActions) {
-    BoxWithConstraints(Modifier.fillMaxWidth()) {
-        val wide = maxWidth >= 700.dp
-        val list: @Composable () -> Unit = { DownloadList(s, a) }
-        val side: @Composable () -> Unit = { DownloadSettings(s, a) }
-        if (wide) Row(horizontalArrangement = Arrangement.spacedBy(24.dp)) {
-            Box(Modifier.weight(3f)) { list() }
-            Box(Modifier.weight(2f)) { side() }
-        } else Column { list(); side() }
-    }
+    DownloadList(s, a)
 }
 
 @Composable
@@ -114,10 +111,26 @@ private fun DownloadList(s: FrontEndState, a: FrontEndActions) {
     var clearing by remember { mutableStateOf(false) }
     // Under way on top; finished below a line whose X clears them all (rows only - a failed
     // download's kept files stay until its game page's Clear).
-    val (active, finished) = entries.partition { it.isActive }
+    // Under way first, then paused, then the queue in its order: a queued row sat above the one running.
+    val (active, finished) = entries.partition { it.isActive }.let { (on, off) ->
+        on.sortedWith(compareBy<DownloadEntry>({ when (it.state) { DownloadState.RUNNING -> 0; DownloadState.PAUSED -> 1; else -> 2 } }, { it.queuePosition })) to off
+    }
     val finishedShown = if (clearing) emptyList() else finished
+    // Installs that stopped without the queue knowing (the app closed or was killed): the queue
+    // lives in memory, so after a restart they were only on their game's page. They resume here too.
+    val queued = entries.mapTo(HashSet()) { it.key }
+    // Matched against each store's library: one not read yet (Downloads opened first) is read from
+    // its cache, quietly, so the rows are there without visiting the store.
+    val ctx = LocalContext.current
+    val missing = StoresState.unfinished.map { it.store }.filter { StoresState.library[it] == null }.toSet()
+    LaunchedEffect(missing) { missing.forEach { StoresState.backend(it)?.syncLibrary(ctx, false) } }
+    val interrupted = StoresState.unfinished.mapNotNull { u ->
+        StoresState.library[u.store]?.firstOrNull {
+            u.id == it.id || (u.id == null && u.folder.name == com.droiddeck.launcher.stores.StoreInstallRoot.folderName(it.title, it.id))
+        }
+    }.filter { "${it.store.id}:${it.id}" !in queued }.distinctBy { "${it.store.id}:${it.id}" }
     Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {
-        AnimatedVisibility(entries.isEmpty(), enter = fadeIn(Motion.tw(300, 300)), exit = fadeOut(Motion.tw(120))) {
+        AnimatedVisibility(entries.isEmpty() && interrupted.isEmpty(), enter = fadeIn(Motion.tw(300, 300)), exit = fadeOut(Motion.tw(120))) {
             Box(Modifier.fillMaxWidth().padding(vertical = 40.dp), contentAlignment = Alignment.Center) {
                 Text(stringResource(R.string.stores_downloads_empty), fontSize = 13.sp, color = colors.onSurfaceVariant)
             }
@@ -138,6 +151,11 @@ private fun DownloadList(s: FrontEndState, a: FrontEndActions) {
                 else shrinkHorizontally(Motion.tw(260), shrinkTowards = Alignment.End) + shrinkVertically(Motion.tw(300, 120)) + fadeOut(Motion.tw(200, 80))
             },
         ) { row, _ -> DownloadCard(StoresState.download(row.key) ?: row, s, a) }
+        AnimatedRows(
+            interrupted, key = { "${it.store.id}:${it.id}" },
+            enter = { i, _ -> fadeIn(Motion.tw(300, 60 * i.coerceAtMost(5))) + expandVertically(Motion.tw(260)) },
+            exit = { _, _, _ -> fadeOut(Motion.tw(160)) + shrinkVertically(Motion.tw(220, 60)) },
+        ) { item, _ -> InterruptedRow(item) }
         AnimatedVisibility(
             finishedShown.isNotEmpty(),
             enter = expandVertically(Motion.tw(260)) + fadeIn(Motion.tw(220)),
@@ -175,21 +193,50 @@ private fun DownloadList(s: FrontEndState, a: FrontEndActions) {
     }
 }
 
+/** An install that stopped before it finished, from an earlier run: Resume picks it up, Clear deletes what it had. */
+@Composable
+private fun InterruptedRow(item: com.droiddeck.launcher.stores.CatalogItem) {
+    val ctx = LocalContext.current
+    ArtStrip(item.imageUrl ?: item.tallImageUrl, item.title) {
+        Text(item.title, fontSize = 13.sp, fontWeight = FontWeight.Bold, color = Color.White, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false))
+        SourceChip(item.store.id, small = true)
+        Text(stringResource(R.string.stores_dl_interrupted), fontSize = 12.sp, color = Color(0xFFFFC24D), maxLines = 1)
+        Spacer(Modifier.weight(1f))
+        RoundAction(Icons.Filled.PlayArrow, stringResource(R.string.stores_dl_resume), primary = true) { StoresState.requestInstall(ctx, item) }
+        CancelAction { StoresState.clearUnfinished(ctx, item) }
+    }
+}
+
 /** How long a row that installed holds for its bar to gather into Play before it moves under the line. */
 private const val GATHER_HOLD_MS = 900
 
+/**
+ * A row in the download card's look, shorter: the game's art behind it under the same dark wash,
+ * the copy in white. Finished and interrupted downloads read as the same thing as one under way.
+ */
+@Composable
+private fun ArtStrip(cover: String?, name: String, content: @Composable androidx.compose.foundation.layout.RowScope.() -> Unit) {
+    val pal = LocalPalette.current
+    Box(Modifier.fillMaxWidth().heightIn(min = 60.dp).clip(Shape12).background(Color(0xFF101318)).border(1.dp, pal.line, Shape12)) {
+        if (!cover.isNullOrEmpty()) AsyncImage(model = cover, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize())
+        else Spacer(Modifier.matchParentSize().background(artBrush(hueOf(name))))
+        Spacer(Modifier.matchParentSize().background(Brush.horizontalGradient(0f to Color.Black.copy(alpha = 0.92f), 0.5f to Color.Black.copy(alpha = 0.72f), 1f to Color.Black.copy(alpha = 0.2f))))
+        Row(
+            verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp),
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 8.dp), content = content,
+        )
+    }
+}
+
 /** A finished download: its name and store, and Play when it installed - blooming out of a dot when it just did. */
 @Composable
 private fun FinishedRow(d: DownloadEntry, s: FrontEndState, a: FrontEndActions, bloom: Boolean = false) {
     val ctx = LocalContext.current
-    val colors = MaterialTheme.colorScheme
-    Row(
-        verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp),
-        modifier = Modifier.fillMaxWidth().clip(Shape12).background(colors.surface).padding(horizontal = 12.dp, vertical = 6.dp),
-    ) {
-        Text(d.name, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false))
+    ArtStrip(d.cover, d.name) {
+        Text(d.name, fontSize = 13.sp, fontWeight = FontWeight.Bold, color = Color.White, maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false))
         SourceChip(d.store.id, small = true)
-        Text(stringResource(if (d.state == DownloadState.INSTALLED) R.string.stores_installed_chip else R.string.stores_dl_cancelled), fontSize = 11.sp, color = colors.onSurfaceVariant, maxLines = 1, modifier = Modifier.weight(1f))
+        Text(stringResource(if (d.state == DownloadState.INSTALLED) R.string.stores_installed_chip else R.string.stores_dl_cancelled), fontSize = 12.sp, color = Color.White.copy(alpha = 0.72f), maxLines = 1)
+        Spacer(Modifier.weight(1f))
         if (d.state == DownloadState.INSTALLED) Box(Modifier.bloomIn(bloom, GATHER_HOLD_MS + 150)) {
             RoundAction(Icons.Filled.PlayArrow, stringResource(R.string.stores_play), primary = true) { launchStoreGame(ctx, d.store, d.id, s, a) }
         }
@@ -450,21 +497,9 @@ private fun eta(seconds: Long): String = when {
     else -> "~${seconds / 3600} h ${(seconds % 3600) / 60} m"
 }
 
-/** The queue's settings beside it: speed tier, downloads at a time, and the engine log. */
-@Composable
-private fun DownloadSettings(s: FrontEndState, a: FrontEndActions) {
-    val ctx = LocalContext.current
-    val colors = MaterialTheme.colorScheme
-    val pal = LocalPalette.current
-    SectionTitle(stringResource(R.string.stores_download_manager), null)
-    Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth().clip(Shape12).background(colors.surface).border(1.dp, pal.line, Shape12).padding(horizontal = 14.dp, vertical = 10.dp)) {
-        DownloadControls(s, a)
-    }
-}
-
 /**
  * The queue's two knobs on one line - the speed tier on the left, downloads at a time on the
- * right; the same control sits in the cog's popup. A narrow page puts them on two tight lines.
+ * right; it sits in the cog's popup. A narrow page puts them on two tight lines.
  */
 @Composable
 internal fun DownloadControls(s: FrontEndState, a: FrontEndActions) {
@@ -490,31 +525,42 @@ internal fun DownloadControls(s: FrontEndState, a: FrontEndActions) {
 }
 
 /**
- * The chip row's cog: the section's own settings in a small card - which tab a store opens on
- * and the speed tier. Setup › Stores repeats them under its gate. Every install is added to Steam;
- * that is not a choice.
+ * The chip row's cog: the section's own settings stepped out of it - which tab a store opens on,
+ * mature titles, the speed tier and how many at once, and the download engine. Their only home;
+ * Setup no longer repeats them. Every install is added to Steam; that is not a choice. [s] is
+ * read live, so a change shows at once in what is stepped out.
  */
-@Composable
-internal fun StoresSettingsDialog(s: FrontEndState, a: FrontEndActions, onDismiss: () -> Unit) {
-    val shown = rememberShown(onDismiss)
-    val close = { shown.targetState = false }
-    AppDialog(shown, close, "storesSettings", wide = false, maxWidth = 440.dp) {
-        DialogHeader(stringResource(R.string.stores_settings_eyebrow), stringResource(R.string.stores_title))
-        Rise(1) {
-            Column {
-                SettingsRow(stringResource(R.string.setup_stores_open_on), null) {
-                    SegmentedTabs(
-                        listOf(SessionPrefs.STORES_OPEN_LIBRARY to stringResource(R.string.stores_tab_library), SessionPrefs.STORES_OPEN_STORE to stringResource(R.string.stores_tab_store)),
-                        s.storesOpenTab,
-                    ) { a.onStoresOpenTab(it) }
-                }
-                SettingsRow(stringResource(R.string.stores_show_mature), null) {
-                    ToggleSwitch(s.storesShowMature, label = stringResource(R.string.stores_show_mature)) { a.onStoresShowMature(it) }
-                }
-                // The queue's two knobs as one compact row, the same control the Downloads page has.
-                Column(Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 11.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { DownloadControls(s, a) }
+internal fun storesSettingsStep(at: Rect, s: androidx.compose.runtime.State<FrontEndState>, a: FrontEndActions, accent: androidx.compose.ui.graphics.Color): StepAsk =
+    StepAsk(
+        anchor = at, side = StepSide.Left, accent = accent, items = 2, maxWidth = 440.dp,
+        handle = { androidx.compose.material3.Icon(androidx.compose.material.icons.Icons.Filled.Settings, null, tint = accent, modifier = Modifier.size(20.dp)) },
+    ) {
+        StepTitle(stringResource(R.string.stores_settings_eyebrow))
+        Column(
+            Modifier.stepItem(1).fillMaxWidth().heightIn(max = minOf(340.dp, (maxHeight - 64.dp).coerceAtLeast(44.dp))).verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+        ) {
+            val st = s.value
+            // No OK: B or a tap outside folds it, and a pad starts on the first choice.
+            SettingsRow(stringResource(R.string.setup_stores_open_on), null, stacked = true) {
+                Box(Modifier.focusRequester(first).focusGroup()) { SegmentedTabs(
+                    listOf(SessionPrefs.STORES_OPEN_LIBRARY to stringResource(R.string.stores_tab_library), SessionPrefs.STORES_OPEN_STORE to stringResource(R.string.stores_tab_store)),
+                    st.storesOpenTab,
+                ) { a.onStoresOpenTab(it) } }
             }
+            SettingsRow(stringResource(R.string.stores_show_mature), null) {
+                ToggleSwitch(st.storesShowMature, label = stringResource(R.string.stores_show_mature)) { a.onStoresShowMature(it) }
+            }
+            // The queue's two knobs as one compact row, the same control the Downloads page has.
+            Column(Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 11.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { DownloadControls(st, a) }
+            val context = androidx.compose.ui.platform.LocalContext.current
+            var gogAchievements by androidx.compose.runtime.remember { androidx.compose.runtime.mutableStateOf(com.droiddeck.launcher.stores.gog.GogComet.enabled(context)) }
+            SettingsRow(stringResource(R.string.gog_achievements), stringResource(R.string.gog_achievements_hint)) {
+                ToggleSwitch(gogAchievements, label = stringResource(R.string.gog_achievements)) {
+                    gogAchievements = it
+                    com.droiddeck.launcher.stores.gog.GogComet.setEnabled(context, it)
+                }
+            }
+            StoresEngineRow()
         }
-        Rise(2) { Actions { SecondaryButton(stringResource(R.string.common_ok), onClick = close) } }
     }
-}

app/src/main/java/com/droiddeck/launcher/ui/StoresMotion.kt

@@ -83,7 +83,8 @@ internal object StoresMotion {
 
     fun fly(from: Rect) {
         if (Motion.scale == 0f || downloadsChip == null) { landed++; return }
-        flights += Flight(from, SystemClock.uptimeMillis())
+        // The count sits at the chip's right end.
+        flights += Flight(from, to = { downloadsChip?.let { Offset(it.right - 22.dp.toPx(), it.center.y) } }, onLand = { landed++ })
     }
 
     /** The confirm or list stepping out of a control on the Stores page now, and whether it is open. */
@@ -124,6 +125,12 @@ internal object StoresMotion {
     /** Where each store's dot sits on its chip, for a sign-in to come home to. */
     val dots = HashMap<Store, Rect>()
 
+    /** Where the open game page's hero art sits (root px): what a card's flood lands on, and leaves from. */
+    var heroAt by mutableStateOf<Rect?>(null)
+
+    /** The open game page came out of a card: its hero holds still, for the card's flood to land on. */
+    var heroLands by mutableStateOf(false)
+
     /** The card a game page is about to open from. */
     private var card: CardMark? = null
     private var cardAt = 0L
@@ -140,8 +147,6 @@ internal object StoresMotion {
 /** A game card at [bounds] (root px) with corner [corner] (px) and its art, for the page it opens to flood out of. */
 internal class CardMark(val key: String, val bounds: Rect, val corner: Float, val art: String?)
 
-internal class Flight(val from: Rect, val id: Long)
-
 /**
  * A confirm or short list for [StepOut] on the Stores page, asked by a control that sits at [anchor]
  * (root px). [content] gets a close that folds it; [onDismiss] runs once it has folded, however.
@@ -153,6 +158,7 @@ internal class StepAsk(
     val pillCorner: androidx.compose.ui.unit.Dp? = null,
     val items: Int = 4,
     val onDismiss: () -> Unit = {},
+    val maxWidth: androidx.compose.ui.unit.Dp = 300.dp,
     val handle: @Composable () -> Unit,
     val content: @Composable StepOutScope.() -> Unit,
 )
@@ -167,63 +173,21 @@ internal class SignInFlood(val store: Store, val from: Rect, val start: Color, v
 /** The dots flying to the Downloads chip, drawn over the page whose root offset is [origin]. */
 @Composable
 internal fun FlightLayer(origin: Offset) {
-    for (f in StoresMotion.flights.toList()) key(f.id) { FlightDot(f, origin) }
+    for (f in StoresMotion.flights.toList()) key(f.id) { FlightDot(f, origin) { StoresMotion.flights.remove(f) } }
 }
 
 /**
- * One install's dot: the button squashes into a 14dp dot (width first, a little bloop), which then
- * flies on an arc to the Downloads chip, stretched along its path like the focus ring's drop.
+ * Pops (1.3 to 1, with one ring) each time [trigger] changes: by default each time a download's
+ * dot lands, for the count on the chip and the rail; any other landing passes its own count.
  */
-@Composable
-private fun FlightDot(f: Flight, origin: Offset) {
-    val pal = LocalPalette.current
-    val t = remember { Animatable(0f) }
-    LaunchedEffect(Unit) {
-        t.animateTo(1f, Motion.tw(150, easing = FastOutSlowInEasing))
-        t.animateTo(2f, Motion.tw(300, easing = FastOutSlowInEasing))
-        StoresMotion.landed++
-        StoresMotion.flights.remove(f)
-    }
-    Canvas(Modifier.fillMaxSize()) {
-        val r = 7.dp.toPx()
-        val from = f.from.translate(-origin)
-        val chip = (StoresMotion.downloadsChip ?: return@Canvas).translate(-origin)
-        val a = from.center
-        // The count sits at the chip's right end.
-        val b = Offset(chip.right - 22.dp.toPx(), chip.center.y)
-        val v = t.value
-        if (v < 1f) {
-            // Squash: the width goes first, then the height, into the dot; a bloop at the end.
-            val w = lerp(from.width, 2 * r, (v * 1.4f).coerceAtMost(1f))
-            val h = lerp(from.height, 2 * r, ((v - 0.25f) / 0.75f).coerceIn(0f, 1f))
-            val k = 1f - 0.15f * sin(PI * v).toFloat()
-            drawRoundRect(pal.signal, Offset(a.x - w * k / 2, a.y - h * k / 2), Size(w * k, h * k), CornerRadius(minOf(w, h) * k / 2))
-        } else {
-            val p = v - 1f
-            val c = Offset((a.x + b.x) / 2, minOf(a.y, b.y) - 80.dp.toPx())
-            val q = 1f - p
-            val pos = Offset(q * q * a.x + 2 * q * p * c.x + p * p * b.x, q * q * a.y + 2 * q * p * c.y + p * p * b.y)
-            val d = Offset(2 * q * (c.x - a.x) + 2 * p * (b.x - c.x), 2 * q * (c.y - a.y) + 2 * p * (b.y - c.y))
-            val stretch = sin(PI * p).toFloat()
-            val angle = atan2(d.y, d.x) * 180f / PI.toFloat()
-            rotate(angle, pos) {
-                val w = 2 * r * (1f + 0.5f * stretch)
-                val h = 2 * r * (1f - 0.25f * stretch)
-                drawOval(pal.signal, Offset(pos.x - w / 2, pos.y - h / 2), Size(w, h))
-            }
-        }
-    }
-}
-
-/** Pops (1.3 to 1, with one ring) each time a download's dot lands; for the count on the chip and the rail. */
-internal fun Modifier.landingPop(): Modifier = composed {
+internal fun Modifier.landingPop(trigger: Int = StoresMotion.landed): Modifier = composed {
     val pal = LocalPalette.current
     val scale = remember { Animatable(1f) }
     val ring = remember { Animatable(1f) }
-    val seen = remember { intArrayOf(StoresMotion.landed) }
-    LaunchedEffect(StoresMotion.landed) {
-        if (StoresMotion.landed == seen[0]) return@LaunchedEffect
-        seen[0] = StoresMotion.landed
+    val seen = remember { intArrayOf(trigger) }
+    LaunchedEffect(trigger) {
+        if (trigger == seen[0]) return@LaunchedEffect
+        seen[0] = trigger
         coroutineScope {
             launch { scale.snapTo(1.3f); scale.animateTo(1f, Motion.sp(0.45f, 500f)) }
             launch { ring.snapTo(0f); ring.animateTo(1f, Motion.tw(400)) }

app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt

@@ -32,6 +32,10 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import androidx.compose.ui.layout.boundsInWindow
 import androidx.compose.ui.layout.onGloballyPositioned
+import android.view.KeyEvent
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.draw.drawWithContent
 import androidx.compose.ui.draw.drawBehind
@@ -160,7 +164,8 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
     var tab by rememberSaveable { mutableStateOf(if (SessionPrefs.storesOpenTab(ctx) == SessionPrefs.STORES_OPEN_STORE) "store" else "library") }
     var query by rememberSaveable { mutableStateOf("") }
     var openGame by rememberSaveable { mutableStateOf<String?>(null) }
-    var settings by rememberSaveable { mutableStateOf(false) }
+    // The cog's settings read the front end's state live while stepped out.
+    val liveState = androidx.compose.runtime.rememberUpdatedState(s)
     LaunchedEffect(StoresState.openDownloads) { if (StoresState.openDownloads) { chip = DOWNLOADS; StoresState.openDownloads = false } }
     val store = Store.byId(chip)
     // A tab this store does not have (Store or All on Amazon) reads as Library.
@@ -306,6 +311,7 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
             val mark = StoresMotion.takeCard(g)
             detailFrom = mark?.let { Origin(it.bounds.translate(-viewportAt), it.corner) }
             detailArt = mark?.art
+            StoresMotion.heroLands = mark != null
             leaving = false
             detail = g
         } else if (detail != null) {
@@ -337,7 +343,7 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
         Box(Modifier.fillMaxWidth().padding(bottom = 8.dp)) {
             StoreTheme(Store.byId(focusedChip ?: chip)) {
                 Rise(0) { StoreChips(chip, focusedChip, s.storeDownloadsActive, onStore = { st, at -> openModes(st, at) }, onDownloads = { if (chip != DOWNLOADS) pickChip(DOWNLOADS) else move("first") },
-                    onFocusChip = { focusedChip = it }, onSettings = { settings = true }) }
+                    onFocusChip = { focusedChip = it }, onSettings = { at -> if (at != null) StoresMotion.ask(storesSettingsStep(at, liveState, a, pal.signal)) }) }
             }
         }
         val fade = with(androidx.compose.ui.platform.LocalDensity.current) { 14.dp.toPx() }
@@ -445,7 +451,9 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
                                 },
                             )
                         }
-                        PageFlood(from, leaving, art) { body() }
+                        // Onto the page's own hero art, not the whole pane: grown to the pane, the art
+                        // then cut down to the hero's banner (and back out to the pane to close).
+                        PageFlood(from, leaving, art, onto = { StoresMotion.heroAt }, ontoCorner = 16.dp) { body() }
                     }
                 }
             }
@@ -475,7 +483,6 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier
         seenActive.clear(); seenActive.addAll(activeKeys)
         if (fresh.isNotEmpty()) StoresMotion.takeInstall()?.let { StoresMotion.fly(it) }
     }
-    if (settings) StoresSettingsDialog(s, a) { settings = false }
     StoresState.pendingInstall?.let { item -> InstallWhere(item) }
 }
 
@@ -571,7 +578,7 @@ private fun SignInFloodLayer(hostAt: Offset) {
  */
 @Composable
 private fun StoreChips(
-    selected: String, focused: String?, active: Int, onStore: (Store, Rect?) -> Unit, onDownloads: () -> Unit, onSettings: () -> Unit,
+    selected: String, focused: String?, active: Int, onStore: (Store, Rect?) -> Unit, onDownloads: () -> Unit, onSettings: (Rect?) -> Unit,
     /** The chip a pad's focus is on (null when it leaves the row): the page shows that store. */
     onFocusChip: (String?) -> Unit,
 ) {
@@ -581,6 +588,9 @@ private fun StoreChips(
     val rootBounds = remember { HashMap<String, Rect>() }
     // The fill travels with focus; only the expensive pane change waits for the debounce.
     val highlighted = focused ?: selected
+    // With a pad the row has no fill of its own: the focus ring's infill is the only one.
+    val inputMode = androidx.compose.ui.platform.LocalInputModeManager.current.inputMode
+    val fillShown = inputMode != androidx.compose.ui.input.InputMode.Keyboard
     val tint = androidx.compose.animation.animateColorAsState(
         Store.byId(highlighted)?.let { sourceColours(it.id).dot } ?: pal.signal, Motion.tw(160), label = "chipTint",
     )
@@ -589,22 +599,15 @@ private fun StoreChips(
             for (store in Store.entries) {
                 val signedIn = StoresState.isSignedIn(store) && StoresState.expired[store] != true
                 StoreChip(
-                    label = store.shortLabel, on = selected == store.id, key = store.id,
+                    label = store.shortLabel, on = selected == store.id, under = fillShown && highlighted == store.id, key = store.id, mark = sourceColours(store.id).dot,
                     modifier = Modifier.weight(1f).onGloballyPositioned { bounds[store.id] = it.boundsInParent(); rootBounds[store.id] = it.boundsInRoot() },
                     lead = {
                         val c = sourceColours(store.id)
-                        // A store's dot pulses once when it is picked signed in, and when a sign-in lands.
-                        var picked by remember { mutableStateOf(0) }
-                        val on = selected == store.id
-                        val wasOn = remember { booleanArrayOf(on) }
-                        LaunchedEffect(on) {
-                            if (on && !wasOn[0] && signedIn) picked++
-                            wasOn[0] = on
-                        }
+                        // A store's dot pulses when a sign-in lands (and, with the chip's lead, when picked).
                         Box(
                             Modifier.size(12.dp)
                                 .onGloballyPositioned { StoresMotion.dots[store] = it.boundsInRoot() }
-                                .pulseRing(picked + (StoresMotion.pulses[store] ?: 0), c.dot),
+                                .pulseRing(StoresMotion.pulses[store] ?: 0, c.dot),
                         ) { Box(Modifier.matchParentSize().clip(CircleShape).background(c.dot).alpha(if (signedIn) 1f else 0.35f)) }
                     },
                     description = store.label + if (signedIn) "" else " " + stringResource(R.string.stores_chip_signed_out),
@@ -612,7 +615,7 @@ private fun StoreChips(
                 ) { onStore(store, rootBounds[store.id]) }
             }
             StoreChip(
-                label = stringResource(R.string.stores_tab_downloads), on = selected == DOWNLOADS, key = DOWNLOADS,
+                label = stringResource(R.string.stores_tab_downloads), on = selected == DOWNLOADS, under = fillShown && highlighted == DOWNLOADS, key = DOWNLOADS, mark = pal.signal,
                 modifier = Modifier.weight(1f).onGloballyPositioned {
                     bounds[DOWNLOADS] = it.boundsInParent()
                     StoresMotion.downloadsChip = it.boundsInRoot()
@@ -621,78 +624,19 @@ private fun StoreChips(
                 trail = if (active > 0) { { CountPill(active) } } else null,
                 onFocused = onFocusChip,
             ) { onDownloads() }
-            IconChip(Icons.Filled.Settings, stringResource(R.string.stores_settings), onSettings)
-        }
-        // Over the chips: the fill is translucent, and the other chips' rest fill would hide it in flight.
-        ChipGlide(keys.indexOf(highlighted), bounds[highlighted], tint)
-    }
-}
-
-/**
- * The selection under the chips: [at] (in the row) of chip [index], in [tint]. A move to the next
- * chip stretches it - the leading edge on the focus ring's lead spring, the trailing one a beat
- * later on its trail spring - and a hop past a chip pinches it to a drop, carries it and opens it.
- */
-@Composable
-private fun BoxScope.ChipGlide(index: Int, at: Rect?, tint: State<Color>) {
-    val density = androidx.compose.ui.platform.LocalDensity.current
-    val left = remember { Animatable(Float.NaN) }
-    val right = remember { Animatable(0f) }
-    val pinch = remember { Animatable(0f) }
-    val top = remember { mutableStateOf(0f) }
-    val bottom = remember { mutableStateOf(0f) }
-    val was = remember { intArrayOf(-1) }
-    LaunchedEffect(index, at) {
-        val b = at ?: return@LaunchedEffect
-        top.value = b.top; bottom.value = b.bottom
-        val from = was[0]
-        was[0] = index
-        if (left.value.isNaN() || from == index || from < 0 || Motion.scale == 0f) {
-            left.snapTo(b.left); right.snapTo(b.right); pinch.snapTo(0f)
-            return@LaunchedEffect
-        }
-        coroutineScope {
-            if (kotlin.math.abs(index - from) > 1) {
-                // Too far to stretch: pinch into a drop where it is, carry it over, open it there.
-                pinch.animateTo(1f, Motion.tw(90))
-                val l = launch { left.animateTo(b.left, Motion.sp(0.7f, 380f)) }
-                val r = launch { right.animateTo(b.right, Motion.sp(0.7f, 380f)) }
-                l.join(); r.join()
-                pinch.animateTo(0f, Motion.sp(0.6f, 500f))
-            } else {
-                val forward = index > from
-                val (lead, trail) = if (forward) right to left else left to right
-                val leadTo = if (forward) b.right else b.left
-                val trailTo = if (forward) b.left else b.right
-                launch { lead.animateTo(leadTo, Motion.sp(0.62f, 700f)) }
-                launch { delay(Motion.ms(40).toLong()); trail.animateTo(trailTo, Motion.sp(0.78f, 360f)) }
+            var cogAt by remember { mutableStateOf<Rect?>(null) }
+            Box(Modifier.onGloballyPositioned { cogAt = it.boundsInRoot() }) {
+                IconChip(Icons.Filled.Settings, stringResource(R.string.stores_settings)) { onSettings(cogAt) }
             }
         }
-    }
-    androidx.compose.foundation.Canvas(Modifier.matchParentSize()) {
-        if (left.value.isNaN() || bottom.value <= top.value) return@Canvas
-        val l = minOf(left.value, right.value)
-        val r = maxOf(left.value, right.value)
-        val cx = (l + r) / 2f
-        val cy = (top.value + bottom.value) / 2f
-        val drop = with(density) { 6.dp.toPx() }
-        val p = pinch.value
-        val x0 = androidx.compose.ui.util.lerp(l, cx - drop, p)
-        val x1 = androidx.compose.ui.util.lerp(r, cx + drop, p)
-        val y0 = androidx.compose.ui.util.lerp(top.value, cy - drop, p)
-        val y1 = androidx.compose.ui.util.lerp(bottom.value, cy + drop, p)
-        val size = androidx.compose.ui.geometry.Size(x1 - x0, y1 - y0)
-        val corner = androidx.compose.ui.geometry.CornerRadius(minOf(size.width, size.height) / 2f)
-        val at0 = Offset(x0, y0)
-        // A drop in flight is solid; on a chip it is the chip's tinted fill and outline.
-        drawRoundRect(tint.value.copy(alpha = androidx.compose.ui.util.lerp(0.16f, 0.9f, p)), at0, size, corner)
-        drawRoundRect(tint.value.copy(alpha = 0.7f * (1f - p)), at0, size, corner, style = androidx.compose.ui.graphics.drawscope.Stroke(with(density) { 1.dp.toPx() }))
+        // Over the chips: the fill is translucent, and the other chips' rest fill would hide it in flight.
+        ChipGlide(keys.indexOf(highlighted), bounds[highlighted], tint, visible = fillShown)
     }
 }
 
 @Composable
 private fun StoreChip(
-    label: String, on: Boolean, key: String, modifier: Modifier, lead: @Composable () -> Unit,
+    label: String, on: Boolean, under: Boolean, key: String, mark: Color, modifier: Modifier, lead: @Composable () -> Unit,
     trail: (@Composable () -> Unit)? = null, description: String? = null,
     onFocused: (String?) -> Unit = {}, onClick: () -> Unit,
 ) {
@@ -705,7 +649,15 @@ private fun StoreChip(
     val scale by animateFloatAsState(if (pressed) 0.95f else 1f, Motion.sp(0.5f, Spring.StiffnessMedium), label = "chipScale")
     val shape = RoundedCornerShape(99.dp)
     val ink = if (on) colors.onBackground else if (hot) colors.onBackground else colors.onSurfaceVariant
-    // The selected look is the row's glide under the chip, so a chip here draws only its rest state.
+    // The chip whose page shows has a bar of its colour along its foot. Picking it pulses its
+    // lead (a store's dot, Downloads' icon).
+    var picked by remember { mutableStateOf(0) }
+    val wasOn = remember { booleanArrayOf(on) }
+    LaunchedEffect(on) {
+        if (on && !wasOn[0]) picked++
+        wasOn[0] = on
+    }
+    // The row's glide draws the look of the chip [under] it, so that one draws no rest state of its own.
     Row(
         verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally),
         modifier = modifier.paneItem("storechip:$key")
@@ -714,14 +666,17 @@ private fun StoreChip(
                 else if (!f.isFocused) onFocused(null)
             }
             .heightIn(min = 44.dp).graphicsLayer { scaleX = scale; scaleY = scale }.clip(shape)
-            .background(if (on) Color.Transparent else colors.surface)
-            .glideBorder(hot, shape, pal.signal, if (on) Color.Transparent else pal.line)
+            .background(if (under) Color.Transparent else colors.surface)
+            .shownBar(on, mark)
+            .glideBorder(hot, shape, pal.signal, if (under) Color.Transparent else pal.line)
             .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, role = Role.Tab, onClick = onClick)
             .controllerConfirm(onClick = onClick)
             .then(if (description != null) Modifier.semantics { contentDescription = description } else Modifier)
             .padding(horizontal = 12.dp, vertical = 8.dp),
     ) {
-        androidx.compose.runtime.CompositionLocalProvider(androidx.compose.material3.LocalContentColor provides ink) { lead() }
+        androidx.compose.runtime.CompositionLocalProvider(androidx.compose.material3.LocalContentColor provides ink) {
+            Box(Modifier.pulseRing(picked, mark), contentAlignment = Alignment.Center) { lead() }
+        }
         Text(label, fontSize = 13.sp, fontWeight = FontWeight.Bold, color = ink, maxLines = 1, overflow = TextOverflow.Ellipsis)
         trail?.invoke()
     }
@@ -777,23 +732,23 @@ private fun SignInCard(store: Store, height: Dp) {
     val shape = RoundedCornerShape(20.dp)
     val blank = WallCapsule(Brush.linearGradient(listOf(c.fill, colors.background)), edge = c.dot.copy(alpha = 0.22f))
     val ground = SolidColor(c.fill)
-    Box(Modifier.fillMaxWidth().height(height.coerceAtLeast(320.dp)).clip(shape).background(colors.background).border(1.dp, pal.line, shape)) {
+    Box(Modifier.fillMaxWidth().heightIn(min = height.coerceAtLeast(0.dp)).clip(shape).background(colors.background).border(1.dp, pal.line, shape)) {
         // The storefront arrives a moment after the page: its wall fades in over the blank one.
-        androidx.compose.animation.Crossfade(art, animationSpec = Motion.tw(600), label = "signInWall") { tiles ->
+        androidx.compose.animation.Crossfade(art, animationSpec = Motion.tw(600), label = "signInWall", modifier = Modifier.matchParentSize()) { tiles ->
             TiltedWall(tiles.size, if (tiles.isEmpty()) 75_000 else 50_000) { i -> if (tiles.isEmpty()) blank else WallCapsule(ground, tiles[i]) }
         }
         // The wall gives way to the words: dark at the left and the foot, and the store's glow under them.
         Box(
-            Modifier.fillMaxSize().background(
+            Modifier.matchParentSize().background(
                 Brush.horizontalGradient(
                     0f to colors.background.copy(alpha = 0.97f), 0.45f to colors.background.copy(alpha = 0.9f),
                     0.78f to colors.background.copy(alpha = 0.35f), 1f to colors.background.copy(alpha = 0.15f),
                 ),
             ),
         )
-        Box(Modifier.fillMaxSize().background(Brush.verticalGradient(0.5f to Color.Transparent, 1f to colors.background.copy(alpha = 0.92f))))
+        Box(Modifier.matchParentSize().background(Brush.verticalGradient(0.5f to Color.Transparent, 1f to colors.background.copy(alpha = 0.92f))))
         Box(
-            Modifier.fillMaxSize().drawBehind {
+            Modifier.matchParentSize().drawBehind {
                 drawRect(Brush.radialGradient(listOf(c.dot.copy(alpha = 0.22f), Color.Transparent), center = Offset(size.width * 0.16f, size.height * 0.9f), radius = size.height * 0.75f))
             },
         )
@@ -882,13 +837,50 @@ private fun Storefront(
     // A lazy item can be recomposed or prefetched out of order; the first grid card is identified
     // by its key, rather than whichever happens to compose first.
     var firstPlaced = false
+    var columns by remember { mutableIntStateOf(1) }
+    val density = androidx.compose.ui.platform.LocalDensity.current
+    val focus = LocalFrontFocus.current
+    val scope = rememberCoroutineScope()
+    val headerItems = 1 + (if (StoresState.status[store] != null) 1 else 0) + (if (StoresState.problems[store] != null) 1 else 0)
     val card: @Composable (CatalogItem) -> Unit = { item ->
         val first = if (showGrid) item.key == visible.firstOrNull()?.key else !firstPlaced
         firstPlaced = true
-        GameCard(item, store, s, a, installedKeys, onOpen, first)
+        val navigation = if (!showGrid || focus == null) Modifier else Modifier.onPreviewKeyEvent { event ->
+            val key = event.nativeKeyEvent
+            val direction = when (key.keyCode) {
+                KeyEvent.KEYCODE_DPAD_DOWN -> 1
+                KeyEvent.KEYCODE_DPAD_UP -> -1
+                else -> 0
+            }
+            val index = visible.indexOfFirst { it.key == item.key }
+            val next = storeGridNeighbor(index, visible.size, columns, direction)
+            when {
+                direction == 0 || index < 0 -> false
+                next == null -> direction > 0 // The last row stays in its column; Up can reach the header.
+                else -> {
+                    if (key.action == KeyEvent.ACTION_DOWN) {
+                        val target = "card:${visible[next].key}"
+                        val targetIndex = headerItems + next
+                        // Prefetched cards can accept focus without being on screen.
+                        val visibleTarget = grid.layoutInfo.visibleItemsInfo.any { it.index == targetIndex }
+                        if (!visibleTarget || (focus.attached[target] ?: 0) == 0 ||
+                            runCatching { focus.items.getValue(target).requestFocus() }.isFailure) scope.launch {
+                            grid.scrollToItem(targetIndex)
+                            focusWithinFrames({ focus.last == target }) { focus.items[target] ?: androidx.compose.ui.focus.FocusRequester.Default }
+                        }
+                    }
+                    true
+                }
+            }
+        }
+        GameCard(item, store, s, a, installedKeys, onOpen, first, navigation)
     }
     LazyVerticalGrid(
-        columns = GridCells.Adaptive(CardWidth), state = grid, modifier = Modifier.fillMaxSize(),
+        columns = GridCells.Adaptive(CardWidth), state = grid, modifier = Modifier.fillMaxSize().focusGroup().onSizeChanged {
+            val gap = with(density) { 10.dp.roundToPx() }
+            val minimum = with(density) { CardWidth.roundToPx() }
+            columns = ((it.width + gap) / (minimum + gap)).toInt().coerceAtLeast(1)
+        },
         horizontalArrangement = Arrangement.spacedBy(10.dp), verticalArrangement = Arrangement.spacedBy(10.dp),
         contentPadding = PaddingValues(top = 4.dp, bottom = 16.dp),
     ) {
@@ -945,7 +937,7 @@ private fun Storefront(
  * search field across the row, and [trailing] (the account) at the right, over a rule.
  */
 @Composable
-private fun ModeHeader(title: String, query: String, onQuery: (String) -> Unit, placeholder: String, trailing: @Composable () -> Unit) {
+internal fun ModeHeader(title: String, query: String, onQuery: (String) -> Unit, placeholder: String, trailing: @Composable () -> Unit) {
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
     // Open while it holds a query; an empty field closes again once focus leaves it.
@@ -1001,6 +993,22 @@ internal fun storePalette(base: Palette, store: Store?): Palette {
     )
 }
 
+/** The Store section's accent: Flathub's teal, with its dark ink on it. */
+internal fun flathubPalette(base: Palette): Palette = Palette(
+    base.id, base.label, base.detail, base.background, base.surface, base.surfaceVariant, base.line, base.line2,
+    base.onBackground, base.onSurfaceVariant, primary = FlathubTeal, primary2 = Color(0xFF2E958D), onPrimary = FlathubInk, signal = FlathubTeal,
+    good = base.good, error = base.error,
+)
+
+/** [content] with the focus ring, buttons, step-outs and the chip glide in Flathub's teal. */
+@Composable
+internal fun FlathubTheme(content: @Composable () -> Unit) {
+    val base = LocalPalette.current
+    val p = remember(base) { flathubPalette(base) }
+    val scheme = MaterialTheme.colorScheme.copy(primary = p.primary, onPrimary = p.onPrimary)
+    CompositionLocalProvider(LocalPalette provides p) { MaterialTheme(colorScheme = scheme, typography = MaterialTheme.typography, content = content) }
+}
+
 /** [content] with the focus ring, buttons and step-outs in [store]'s colour. */
 @Composable
 internal fun StoreTheme(store: Store?, content: @Composable () -> Unit) {
@@ -1060,7 +1068,7 @@ private fun SignOutButton(store: Store, name: String) {
 
 /** The header's magnifier: a round button the search field opens out of. */
 @Composable
-private fun SearchIcon(description: String, onClick: () -> Unit) {
+internal fun SearchIcon(description: String, onClick: () -> Unit) {
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
     val src = remember { MutableInteractionSource() }
@@ -1109,7 +1117,7 @@ private val CardWidth = 112.dp
  * on the store. Tapping the card itself opens the game's page.
  */
 @Composable
-private fun GameCard(item: CatalogItem, store: Store, s: FrontEndState, a: FrontEndActions, installedKeys: Set<String>, onOpen: (String) -> Unit, first: Boolean = false) {
+private fun GameCard(item: CatalogItem, store: Store, s: FrontEndState, a: FrontEndActions, installedKeys: Set<String>, onOpen: (String) -> Unit, first: Boolean = false, navigation: Modifier = Modifier) {
     val ctx = LocalContext.current
     val colors = MaterialTheme.colorScheme
     val pal = LocalPalette.current
@@ -1138,7 +1146,7 @@ private fun GameCard(item: CatalogItem, store: Store, s: FrontEndState, a: Front
                     if (b.bottom > -ahead && b.top < screen + ahead && b.width > 0f) com.droiddeck.launcher.stores.StoreSizes.request(ctx, item)
                 }
             }
-            .paneItem("card:${item.key}").then(if (first) Modifier.firstTile() else Modifier).graphicsLayer { scaleX = scale; scaleY = scale }
+            .then(navigation).paneItem("card:${item.key}").then(if (first) Modifier.firstTile() else Modifier).graphicsLayer { scaleX = scale; scaleY = scale }
             .clip(RoundedCornerShape(10.dp)).glideBorder(hot, RoundedCornerShape(10.dp), pal.signal, pal.line)
             .hoverable(src).clickable(interactionSource = src, indication = LocalIndication.current, onClick = open).controllerConfirm(onClick = open),
     ) {

app/src/main/java/com/droiddeck/launcher/ui/StoresWidgets.kt

@@ -13,7 +13,7 @@ internal fun StoresEngineRow() {
     val version = StoresNative.version
     SettingsRow(
         stringResource(R.string.setup_stores_engine),
-        version,
+        null,
     ) {
         Chip(if (version != null) stringResource(R.string.setup_stores_engine_chip_ready) else stringResource(R.string.setup_stores_engine_chip_missing), ok = version != null)
     }

app/src/main/java/com/droiddeck/launcher/ui/Theme.kt

@@ -42,7 +42,7 @@ object Themes {
             PAPER, R.string.theme_paper, R.string.theme_paper_detail,
             background = Color(0xFF000000), surface = Color(0xFF0F0F10), surfaceVariant = Color(0xFF191A1C), line = Color(0xFF262729), line2 = Color(0xFF343638),
             onBackground = Color(0xFFF9F9F9), onSurfaceVariant = Color(0xFF8E9196),
-            primary = Color(0xFFF9F9F9), primary2 = Color(0xFFD9DADD), onPrimary = Color(0xFF000000), signal = Color(0xFF136CE0),
+            primary = Color(0xFFF9F9F9), primary2 = Color(0xFFD9DADD), onPrimary = Color(0xFF000000), signal = Color(0xFFF9F9F9),
             good = Color(0xFF4CD37F),
         ),
         Palette(

app/src/main/res/values-es/strings.xml

@@ -568,7 +568,7 @@
     <string name="drawer_game_running">juego en ejecución</string>
     <string name="drawer_reapplied">reaplicado al iniciar %1$s</string>
     <string name="drawer_original">Original</string>
-    <string name="drawer_components_note">Descarga, importa y elimina en la página Componentes.</string>
+    <string name="drawer_components_note">Importa y elimina en la página Componentes.</string>
     <string name="setup_check_done">Hecho</string>
     <string name="setup_check_warn">Requiere atención</string>
     <string name="setup_check_busy">Trabajando</string>
@@ -642,9 +642,6 @@
     <string name="setup_choose_home">Elige una app de inicio</string>
     <string name="setup_choose">Elegir</string>
     <string name="setup_linux_apps">Apps de Linux (beta)</string>
-    <string name="setup_store">Tienda Flathub</string>
-    <string name="setup_store_on">En el menú. Algunas apps pueden no iniciarse; los registros están en Download/DroidDeck.</string>
-    <string name="setup_store_off">Instala apps y juegos de Linux desde Flathub</string>
     <string name="setup_tool_files">Archivos</string>
     <string name="setup_tool_files_hint">Explorar y gestionar archivos</string>
     <string name="setup_tool_protons">Versiones de Proton</string>
@@ -2135,4 +2132,19 @@
         <item quantity="many">%1$d ya en Juegos</item>
         <item quantity="other">%1$d ya en Juegos</item>
     </plurals>
+    <string name="achievements_title">Logros</string>
+    <string name="achievements_count">%1$d de %2$d desbloqueados</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">Desbloqueados · %1$d</string>
+    <string name="achievements_group_locked">Bloqueados · %1$d</string>
+    <string name="achievements_group_hidden">Ocultos · %1$d</string>
+    <string name="achievements_hidden">Logro oculto</string>
+    <string name="achievements_hidden_detail">Los detalles se muestran al desbloquearlo.</string>
+    <string name="achievements_all">Todos los logros desbloqueados</string>
+    <string name="achievements_reading">Leyendo…</string>
+    <string name="achievements_signed_out">Inicia sesión en %1$s para ver tus logros.</string>
+    <string name="achievements_unreachable">No se pudo conectar con %1$s. Vuelve a intentarlo cuando tengas conexión.</string>
+    <string name="achievements_none">%1$s no indica logros para este juego.</string>
+    <string name="achievements_show_all">Ver los %1$d</string>
+    <string name="achievements_dialog_title">Logros · %1$s</string>
 </resources>

app/src/main/res/values-fr/strings.xml

@@ -451,7 +451,7 @@
     <string name="drawer_game_running">Jeu en cours d\'exécution</string>
     <string name="drawer_reapplied">Réappliqué au lancement de %1$s</string>
     <string name="drawer_original">Original</string>
-    <string name="drawer_components_note">Veuillez télécharger, importer et supprimer depuis la page « Composants ».</string>
+    <string name="drawer_components_note">Importez et supprimez depuis la page « Composants ».</string>
     <string name="setup_check_done">Terminé</string>
     <string name="setup_check_warn">À traiter</string>
     <string name="setup_check_busy">Traitement en cours</string>
@@ -518,9 +518,6 @@
     <string name="setup_choose_home">Choisir l\'application d\'écran d\'accueil</string>
     <string name="setup_choose">Choisir</string>
     <string name="setup_linux_apps">Applications Linux (bêta)</string>
-    <string name="setup_store">Boutique Flathub</string>
-    <string name="setup_store_on">Affiché dans le menu. Certaines applications peuvent ne pas se lancer ; les journaux se trouvent dans Download/DroidDeck.</string>
-    <string name="setup_store_off">Installer des applications et des jeux Linux depuis Flathub</string>
     <string name="setup_tool_files">Fichiers</string>
     <string name="setup_tool_files_hint">Parcourir et gérer les fichiers</string>
     <string name="setup_tool_protons">Versions de Proton</string>
@@ -965,4 +962,19 @@
         <item quantity="one">%1$d déjà dans Jeux</item>
         <item quantity="other">%1$d déjà dans Jeux</item>
     </plurals>
+    <string name="achievements_title">Succès</string>
+    <string name="achievements_count">%1$d sur %2$d débloqués</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">Débloqués · %1$d</string>
+    <string name="achievements_group_locked">Verrouillés · %1$d</string>
+    <string name="achievements_group_hidden">Cachés · %1$d</string>
+    <string name="achievements_hidden">Succès caché</string>
+    <string name="achievements_hidden_detail">Les détails s\'affichent une fois débloqué.</string>
+    <string name="achievements_all">Tous les succès débloqués</string>
+    <string name="achievements_reading">Lecture…</string>
+    <string name="achievements_signed_out">Connectez-vous à %1$s pour voir vos succès.</string>
+    <string name="achievements_unreachable">Impossible de joindre %1$s. Réessayez une fois en ligne.</string>
+    <string name="achievements_none">%1$s n\'indique aucun succès pour ce jeu.</string>
+    <string name="achievements_show_all">Tout afficher (%1$d)</string>
+    <string name="achievements_dialog_title">Succès · %1$s</string>
 </resources>

app/src/main/res/values-ja/strings.xml

@@ -564,7 +564,7 @@
     <string name="drawer_game_running">ゲーム実行中</string>
     <string name="drawer_reapplied">%1$sの起動時に再適用しました</string>
     <string name="drawer_original">元</string>
-    <string name="drawer_components_note">「コンポーネント」ページでダウンロード、インポート、削除してください。</string>
+    <string name="drawer_components_note">「コンポーネント」ページでインポート、削除してください。</string>
     <string name="setup_check_done">完了</string>
     <string name="setup_check_warn">要対応</string>
     <string name="setup_check_busy">処理中</string>
@@ -638,9 +638,6 @@
     <string name="setup_choose_home">ホームアプリを選択</string>
     <string name="setup_choose">選択</string>
     <string name="setup_linux_apps">Linuxアプリ（ベータ版）</string>
-    <string name="setup_store">Flathubストア</string>
-    <string name="setup_store_on">メニューに表示されます。一部のアプリは起動できない場合があります。ログはDownload/DroidDeckにあります。</string>
-    <string name="setup_store_off">FlathubからLinuxアプリとゲームをインストール</string>
     <string name="setup_tool_files">ファイル</string>
     <string name="setup_tool_files_hint">ファイルの閲覧と管理</string>
     <string name="setup_tool_protons">Protonバージョン</string>
@@ -2091,4 +2088,19 @@
     <plurals name="games_already_n">
         <item quantity="other">%1$d 本はすでにゲームにあります</item>
     </plurals>
+    <string name="achievements_title">実績</string>
+    <string name="achievements_count">%2$d 個中 %1$d 個を解除</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">解除済み · %1$d</string>
+    <string name="achievements_group_locked">未解除 · %1$d</string>
+    <string name="achievements_group_hidden">隠し実績 · %1$d</string>
+    <string name="achievements_hidden">隠し実績</string>
+    <string name="achievements_hidden_detail">解除すると詳細が表示されます。</string>
+    <string name="achievements_all">すべての実績を解除</string>
+    <string name="achievements_reading">読み込み中…</string>
+    <string name="achievements_signed_out">実績を表示するには %1$s にサインインしてください。</string>
+    <string name="achievements_unreachable">%1$s に接続できませんでした。オンラインになってから再度確認してください。</string>
+    <string name="achievements_none">%1$s にはこのゲームの実績がありません。</string>
+    <string name="achievements_show_all">すべて表示（%1$d）</string>
+    <string name="achievements_dialog_title">実績 · %1$s</string>
 </resources>

app/src/main/res/values-ko/strings.xml

@@ -564,7 +564,7 @@
     <string name="drawer_game_running">게임 실행 중</string>
     <string name="drawer_reapplied">%1$s 시작 시 다시 적용됨</string>
     <string name="drawer_original">원본</string>
-    <string name="drawer_components_note">\"구성 요소\" 페이지에서 다운로드, 가져오기 및 삭제하세요.</string>
+    <string name="drawer_components_note">구성 요소 페이지에서 가져오기 및 삭제하세요.</string>
     <string name="setup_check_done">완료</string>
     <string name="setup_check_warn">처리 필요</string>
     <string name="setup_check_busy">처리 중</string>
@@ -638,9 +638,6 @@
     <string name="setup_choose_home">홈 앱 선택</string>
     <string name="setup_choose">선택</string>
     <string name="setup_linux_apps">Linux 앱(베타)</string>
-    <string name="setup_store">Flathub 스토어</string>
-    <string name="setup_store_on">메뉴에 표시됩니다. 일부 앱은 실행되지 않을 수 있습니다. 로그는 Download/DroidDeck에 있습니다.</string>
-    <string name="setup_store_off">Flathub에서 Linux 앱 및 게임 설치</string>
     <string name="setup_tool_files">파일</string>
     <string name="setup_tool_files_hint">파일 탐색 및 관리</string>
     <string name="setup_tool_protons">Proton 버전</string>
@@ -2091,4 +2088,19 @@
     <plurals name="games_already_n">
         <item quantity="other">%1$d개는 이미 게임에 있음</item>
     </plurals>
+    <string name="achievements_title">도전 과제</string>
+    <string name="achievements_count">%2$d개 중 %1$d개 달성</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">달성 · %1$d</string>
+    <string name="achievements_group_locked">미달성 · %1$d</string>
+    <string name="achievements_group_hidden">숨겨짐 · %1$d</string>
+    <string name="achievements_hidden">숨겨진 도전 과제</string>
+    <string name="achievements_hidden_detail">달성하면 세부 정보가 표시됩니다.</string>
+    <string name="achievements_all">모든 도전 과제 달성</string>
+    <string name="achievements_reading">불러오는 중…</string>
+    <string name="achievements_signed_out">도전 과제를 보려면 %1$s에 로그인하세요.</string>
+    <string name="achievements_unreachable">%1$s에 연결할 수 없습니다. 온라인 상태에서 다시 확인하세요.</string>
+    <string name="achievements_none">%1$s에 이 게임의 도전 과제가 없습니다.</string>
+    <string name="achievements_show_all">모두 보기(%1$d)</string>
+    <string name="achievements_dialog_title">도전 과제 · %1$s</string>
 </resources>

app/src/main/res/values-ru/strings.xml

@@ -526,7 +526,7 @@
     <string name="drawer_game_running">игра запущена</string>
     <string name="drawer_reapplied">повторно применено при запуске %1$s</string>
     <string name="drawer_original">Оригинал</string>
-    <string name="drawer_components_note">Скачивайте, импортируйте и удаляйте на странице «Компоненты».</string>
+    <string name="drawer_components_note">Импортируйте и удаляйте на странице «Компоненты».</string>
     <string name="setup_check_done">Готово</string>
     <string name="setup_check_warn">Требует внимания</string>
     <string name="setup_check_busy">Обработка</string>
@@ -596,9 +596,6 @@
     <string name="setup_choose_home">Выбрать главный экран</string>
     <string name="setup_choose">Выбрать</string>
     <string name="setup_linux_apps">Приложения Linux (бета)</string>
-    <string name="setup_store">Магазин Flathub</string>
-    <string name="setup_store_on">Показывается в меню. Некоторые приложения могут не запускаться; журналы в Download/DroidDeck.</string>
-    <string name="setup_store_off">Устанавливать приложения и игры Linux из Flathub</string>
     <string name="setup_tool_files">Файлы</string>
     <string name="setup_tool_files_hint">Просмотр и управление файлами</string>
     <string name="setup_tool_protons">Версии Proton</string>
@@ -1076,4 +1073,19 @@
         <item quantity="many">%1$d уже в «Играх»</item>
         <item quantity="other">%1$d уже в «Играх»</item>
     </plurals>
+    <string name="achievements_title">Достижения</string>
+    <string name="achievements_count">Получено %1$d из %2$d</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">Получены · %1$d</string>
+    <string name="achievements_group_locked">Не получены · %1$d</string>
+    <string name="achievements_group_hidden">Скрытые · %1$d</string>
+    <string name="achievements_hidden">Скрытое достижение</string>
+    <string name="achievements_hidden_detail">Подробности появятся после получения.</string>
+    <string name="achievements_all">Все достижения получены</string>
+    <string name="achievements_reading">Загрузка…</string>
+    <string name="achievements_signed_out">Войдите в %1$s, чтобы увидеть свои достижения.</string>
+    <string name="achievements_unreachable">Не удалось связаться с %1$s. Проверьте снова, когда будете в сети.</string>
+    <string name="achievements_none">В %1$s нет достижений для этой игры.</string>
+    <string name="achievements_show_all">Показать все (%1$d)</string>
+    <string name="achievements_dialog_title">Достижения · %1$s</string>
 </resources>

app/src/main/res/values-zh-rCN/strings.xml

@@ -564,7 +564,7 @@
     <string name="drawer_game_running">游戏运行中</string>
     <string name="drawer_reapplied">于启动 %1$s 时重新应用</string>
     <string name="drawer_original">原件</string>
-    <string name="drawer_components_note">在“组件”页面下载、导入和删除。</string>
+    <string name="drawer_components_note">在“组件”页面导入和删除。</string>
     <string name="setup_check_done">完成</string>
     <string name="setup_check_warn">需要处理</string>
     <string name="setup_check_busy">处理中</string>
@@ -638,9 +638,6 @@
     <string name="setup_choose_home">选择主屏幕应用</string>
     <string name="setup_choose">选择</string>
     <string name="setup_linux_apps">Linux 应用（测试版）</string>
-    <string name="setup_store">Flathub 商店</string>
-    <string name="setup_store_on">显示在菜单中。部分应用可能无法启动；日志位于 Download/DroidDeck。</string>
-    <string name="setup_store_off">从 Flathub 安装 Linux 应用和游戏</string>
     <string name="setup_tool_files">文件</string>
     <string name="setup_tool_files_hint">浏览和管理文件</string>
     <string name="setup_tool_protons">Proton 版本</string>
@@ -2091,4 +2088,19 @@
     <plurals name="games_already_n">
         <item quantity="other">%1$d 个已在游戏中</item>
     </plurals>
+    <string name="achievements_title">成就</string>
+    <string name="achievements_count">已解锁 %1$d / %2$d</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">已解锁 · %1$d</string>
+    <string name="achievements_group_locked">未解锁 · %1$d</string>
+    <string name="achievements_group_hidden">隐藏 · %1$d</string>
+    <string name="achievements_hidden">隐藏成就</string>
+    <string name="achievements_hidden_detail">解锁后显示详情。</string>
+    <string name="achievements_all">已解锁全部成就</string>
+    <string name="achievements_reading">读取中…</string>
+    <string name="achievements_signed_out">登录 %1$s 以查看你的成就。</string>
+    <string name="achievements_unreachable">无法连接到 %1$s。请在联网后再查看。</string>
+    <string name="achievements_none">%1$s 未列出此游戏的成就。</string>
+    <string name="achievements_show_all">显示全部 %1$d 项</string>
+    <string name="achievements_dialog_title">成就 · %1$s</string>
 </resources>

app/src/main/res/values-zh-rHK/strings.xml

@@ -564,7 +564,7 @@
     <string name="drawer_game_running">遊戲執行中</string>
     <string name="drawer_reapplied">於 %1$s 啟動時重新套用</string>
     <string name="drawer_original">原始</string>
-    <string name="drawer_components_note">請在「元件」頁面下載、匯入及刪除。</string>
+    <string name="drawer_components_note">請在「元件」頁面匯入及刪除。</string>
     <string name="setup_check_done">完成</string>
     <string name="setup_check_warn">需要處理</string>
     <string name="setup_check_busy">處理中</string>
@@ -638,9 +638,6 @@
     <string name="setup_choose_home">選擇主畫面應用程式</string>
     <string name="setup_choose">選擇</string>
     <string name="setup_linux_apps">Linux 應用程式（測試版）</string>
-    <string name="setup_store">Flathub 商店</string>
-    <string name="setup_store_on">顯示在選單中。部分應用程式可能無法啟動；記錄位於 Download/DroidDeck。</string>
-    <string name="setup_store_off">從 Flathub 安裝 Linux 應用程式和遊戲</string>
     <string name="setup_tool_files">檔案</string>
     <string name="setup_tool_files_hint">瀏覽及管理檔案</string>
     <string name="setup_tool_protons">Proton 版本</string>
@@ -2091,4 +2088,19 @@
     <plurals name="games_already_n">
         <item quantity="other">%1$d 個已在遊戲中</item>
     </plurals>
+    <string name="achievements_title">成就</string>
+    <string name="achievements_count">已解鎖 %1$d / %2$d</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">已解鎖 · %1$d</string>
+    <string name="achievements_group_locked">未解鎖 · %1$d</string>
+    <string name="achievements_group_hidden">隱藏 · %1$d</string>
+    <string name="achievements_hidden">隱藏成就</string>
+    <string name="achievements_hidden_detail">解鎖後會顯示詳情。</string>
+    <string name="achievements_all">已解鎖全部成就</string>
+    <string name="achievements_reading">正在讀取…</string>
+    <string name="achievements_signed_out">登入 %1$s 以查看你的成就。</string>
+    <string name="achievements_unreachable">無法連接 %1$s。請在連線後再查看。</string>
+    <string name="achievements_none">%1$s 未列出此遊戲的成就。</string>
+    <string name="achievements_show_all">顯示全部 %1$d 項</string>
+    <string name="achievements_dialog_title">成就 · %1$s</string>
 </resources>

app/src/main/res/values-zh-rTW/strings.xml

@@ -564,7 +564,7 @@
     <string name="drawer_game_running">遊戲執行中</string>
     <string name="drawer_reapplied">已在啟動 %1$s 時重新套用</string>
     <string name="drawer_original">原始</string>
-    <string name="drawer_components_note">請在「元件」頁面下載、匯入和刪除。</string>
+    <string name="drawer_components_note">請在「元件」頁面匯入和刪除。</string>
     <string name="setup_check_done">完成</string>
     <string name="setup_check_warn">需要處理</string>
     <string name="setup_check_busy">處理中</string>
@@ -638,9 +638,6 @@
     <string name="setup_choose_home">選擇主螢幕應用程式</string>
     <string name="setup_choose">選擇</string>
     <string name="setup_linux_apps">Linux 應用程式（測試版）</string>
-    <string name="setup_store">Flathub 商店</string>
-    <string name="setup_store_on">顯示在選單中。部分應用程式可能無法啟動；日誌位於 Download/DroidDeck。</string>
-    <string name="setup_store_off">從 Flathub 安裝 Linux 應用程式和遊戲</string>
     <string name="setup_tool_files">檔案</string>
     <string name="setup_tool_files_hint">瀏覽和管理檔案</string>
     <string name="setup_tool_protons">Proton 版本</string>
@@ -2091,4 +2088,19 @@
     <plurals name="games_already_n">
         <item quantity="other">%1$d 個已在遊戲中</item>
     </plurals>
+    <string name="achievements_title">成就</string>
+    <string name="achievements_count">已解鎖 %1$d / %2$d</string>
+    <string name="achievements_count_short">%1$d / %2$d</string>
+    <string name="achievements_group_unlocked">已解鎖 · %1$d</string>
+    <string name="achievements_group_locked">未解鎖 · %1$d</string>
+    <string name="achievements_group_hidden">隱藏 · %1$d</string>
+    <string name="achievements_hidden">隱藏成就</string>
+    <string name="achievements_hidden_detail">解鎖後會顯示詳細資訊。</string>
+    <string name="achievements_all">已解鎖所有成就</string>
+    <string name="achievements_reading">正在讀取…</string>
+    <string name="achievements_signed_out">登入 %1$s 以查看你的成就。</string>
+    <string name="achievements_unreachable">無法連線到 %1$s。請在連上網路後再查看。</string>
+    <string name="achievements_none">%1$s 沒有列出這款遊戲的成就。</string>
+    <string name="achievements_show_all">顯示全部 %1$d 項</string>
+    <string name="achievements_dialog_title">成就 · %1$s</string>
 </resources>