wip: multi-controller session and pad bridge changes

feat: the built-in pad can be a DualShock 4 or DualSense, its touchpad fed by the trackpads (#559 )
feat: the built-in pad's controller type switches from the session menu while Steam runs (#558 )
2026-10-15 03:37:09 -04:00 · 2026-10-14 12:16:24 -04:00 · 2026-10-11 04:21:31 +00:00 · 2026-10-11 00:12:53 -04:00 · 2026-10-11 03:24:22 +00:00 · 2026-10-10 23:20:09 -04:00
588 changed files with 85371 additions and 6497 deletions
@@ -0,0 +1,101 @@
+name: Build desktop package (KDE Plasma)
+
+# The desktop the app installs into its Linux runtime on first use: KDE Plasma as SteamOS's desktop
+# mode has it, the closure of tools/desktop-kde/seeds.txt over Arch Linux ARM minus what the runtime
+# already carries, plus tools/desktop-kde/overlay (tools/desktop-kde/build.sh), every package
+# signature-checked. Published as a release in Droid-Deck/DroidDeck-Components with DroidDeck's
+# other components; the apk pins it in tools/desktop-kde/release.env (tag, sha256, size). A
+# published tag is never rebuilt: the packages are Arch Linux ARM's current ones, so a rebuild
+# would not match the pinned sha256. A changed package gets a new tag (desktop-kde-r2, ...) and a
+# release.env update.
+on:
+  push:
+    paths:
+      - 'tools/desktop-kde/**'
+      - '.github/workflows/build-desktop-kde.yml'
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Release tag to publish as (e.g. desktop-kde-r1); empty = artifact only'
+        required: false
+        default: ''
+
+permissions:
+  contents: write
+
+jobs:
+  kwin:
+    runs-on: ubuntu-24.04-arm
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build KWin with nested desktop scaling
+        run: |
+          sudo apt-get update -qq && sudo apt-get install -y -qq zstd xz-utils gpgv patch binutils >/dev/null
+          bash tools/desktop-kde/build-kwin.sh out/kwin
+      - uses: actions/upload-artifact@v4
+        with:
+          name: desktop-kde-kwin
+          retention-days: 7
+          path: out/kwin/
+  build:
+    needs: kwin
+    runs-on: ubuntu-24.04
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: desktop-kde-kwin
+          path: out/kwin
+      - uses: actions/create-github-app-token@v2
+        id: components-token
+        if: github.event_name == 'workflow_dispatch' && inputs.tag != ''
+        with:
+          app-id: ${{ vars.DROIDDECK_CI_APP_ID }}
+          private-key: ${{ secrets.DROIDDECK_CI_APP_KEY }}
+          owner: Droid-Deck
+          repositories: DroidDeck-Components
+      - name: Refuse a published tag
+        if: github.event_name == 'workflow_dispatch' && inputs.tag != ''
+        env:
+          GH_TOKEN: ${{ steps.components-token.outputs.token }}
+        run: |
+          if gh release view '${{ inputs.tag }}' -R Droid-Deck/DroidDeck-Components >/dev/null 2>&1; then
+            echo "::error::${{ inputs.tag }} is already published, and published tags are never replaced: use a new tag"
+            exit 1
+          fi
+      - name: Build
+        run: |
+          set -euo pipefail
+          sudo apt-get update -qq && sudo apt-get install -y -qq zstd xz-utils gpgv >/dev/null
+          KDE_KWIN_OVERRIDE="$PWD/out/kwin" tools/desktop-kde/build.sh out
+          cp out/kwin/desktop-kde.kwin.txt out/
+          echo "size $(stat -c %s out/desktop-kde.tar.zst) sha256 $(cat out/desktop-kde.sha256)"
+      # The package itself too, briefly: enough to try a build on a device before publishing it.
+      - uses: actions/upload-artifact@v4
+        with:
+          name: desktop-kde
+          retention-days: 7
+          compression-level: 0
+          path: |
+            out/desktop-kde.tar.zst
+            out/desktop-kde.packages.txt
+            out/desktop-kde.kwin.txt
+            out/desktop-kde.sha256
+      - name: Publish
+        if: github.event_name == 'workflow_dispatch' && inputs.tag != ''
+        env:
+          GH_TOKEN: ${{ steps.components-token.outputs.token }}
+          GH_REPO: Droid-Deck/DroidDeck-Components
+        run: |
+          set -euo pipefail
+          TAG='${{ inputs.tag }}'
+          if gh release view "$TAG" >/dev/null 2>&1; then
+            echo "::error::$TAG is already published in DroidDeck-Components, and published tags are never replaced: use a new tag"
+            exit 1
+          fi
+          gh release create "$TAG" --latest=false --prerelease=false --title "$TAG" \
+            --notes "KDE Plasma desktop package for DroidDeck's Linux runtime ($GITHUB_REPOSITORY tools/desktop-kde, $GITHUB_SHA). size $(stat -c %s out/desktop-kde.tar.zst), sha256 $(cat out/desktop-kde.sha256). desktop-kde.packages.txt lists the signature-checked Arch Linux ARM packages it was built from." \
+            out/desktop-kde.tar.zst out/desktop-kde.sha256 out/desktop-kde.packages.txt out/desktop-kde.kwin.txt
+          gh release edit "$TAG" --latest=false --prerelease=false
@@ -1,49 +0,0 @@
-name: Build wlroots (patched)
-
-# The desktop's wlroots (Arch Linux ARM's wlroots0.20, what the desktop package's labwc links)
-# rebuilt with tools/wlroots/patches: a Vulkan DMA-BUF allocator for the Adreno node, which is not
-# a DRM device, so labwc's vulkan and gles2 renderers can start. Built in an Arch Linux ARM
-# container on an arm64 runner and published as a release asset the apk build fetches
-# (tools/wlroots/release.env names the tag and sha). The hosted desktop package is never changed.
-on:
-  push:
-    paths:
-      - 'tools/wlroots/**'
-      - '.github/workflows/build-wlroots.yml'
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Release tag to publish as (e.g. wlroots-0.20.2-p1); empty = artifact only'
-        required: false
-        default: ''
-
-permissions:
-  contents: write
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04-arm
-    timeout-minutes: 90
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build in Arch Linux ARM
-        run: |
-          set -euo pipefail
-          docker run --rm -v "$PWD:/work" -w /work menci/archlinuxarm:base-devel bash tools/wlroots/build-in-arch.sh
-          sudo chown -R "$(id -u):$(id -g)" .
-      - uses: actions/upload-artifact@v4
-        with:
-          name: wlroots-patched
-          path: |
-            wlroots.tzst
-            wlroots.tzst.sha256
-      - name: Publish
-        if: github.event_name == 'workflow_dispatch' && inputs.tag != ''
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          set -euo pipefail
-          gh release create "${{ inputs.tag }}" --latest=false --prerelease=false --title "${{ inputs.tag }}" --notes "wlroots 0.20.2 with tools/wlroots/patches (Vulkan DMA-BUF allocator for non-DRM GPU nodes); staged by the apk at /usr/local/lib/droiddeck-wlroots for the desktop's GPU renderers. sha256 $(cut -d' ' -f1 wlroots.tzst.sha256)" wlroots.tzst wlroots.tzst.sha256 || gh release upload "${{ inputs.tag }}" wlroots.tzst wlroots.tzst.sha256 --clobber
-          # A component the apk fetches by tag, never something users install: it must not
-          # become the repo's Latest release or appear as a pre-release, also when re-uploaded.
-          gh release edit "${{ inputs.tag }}" --latest=false --prerelease=false
@@ -44,6 +44,19 @@ jobs:
          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
          fetch-depth: 0

+      - name: Check co-authors
+        if: github.event_name == 'pull_request'
+        run: |
+          set -euo pipefail
+          git fetch --no-tags origin main
+          base=$(git merge-base origin/main HEAD)
+          messages=$(git log --format=%B "$base..HEAD")
+          messages+=$'\n'"$(jq -r '.pull_request.title, (.pull_request.body // "")' "$GITHUB_EVENT_PATH")"
+          if grep -Eiq '^[[:space:]]*Co-authored-by:.*(Claude|Anthropic|OpenAI|ChatGPT|GPT|Copilot|Cursor|Gemini|Codex|Devin|Windsurf|Codeium|Amazon Q|Tabnine|Cody|\[bot\])' <<<"$messages"; then
+            echo "::error::AI and bot identities cannot be co-authors; remove the Co-authored-by trailer."
+            exit 1
+          fi
+
      - name: The packages a signed build ships as
        id: variants
        run: echo "list=$(awk '!/^#/ && NF { print $1 }' tools/release/variants.txt | jq -R . | jq -sc .)" >> "$GITHUB_OUTPUT"
@@ -57,6 +70,22 @@ jobs:
            exit 1
          fi

+      - name: Version bumps are isolated
+        if: github.event_name == 'pull_request'
+        run: |
+          set -euo pipefail
+          git fetch --no-tags origin main
+          base=$(git merge-base origin/main HEAD)
+          diff=$(git diff -U0 "$base..HEAD" -- app/build.gradle)
+          grep -Eq '^[+-][[:space:]]*version(Code|Name)[[:space:]]' <<<"$diff" || exit 0
+          other_files=$(git diff --name-only "$base..HEAD" | grep -v '^app/build.gradle$' || true)
+          other_gradle=$(grep -E '^[+-]' <<<"$diff" | grep -Ev '^(---|\+\+\+)' | grep -Ev '^[+-][[:space:]]*version(Code|Name)[[:space:]]' || true)
+          if [[ -n "$other_files" || -n "$other_gradle" ]]; then
+            echo "::error::versionCode/versionName changes must be isolated in their own PR"
+            echo "A version PR may only change the versionCode/versionName lines in app/build.gradle." >> "$GITHUB_STEP_SUMMARY"
+            exit 1
+          fi
+
      - name: Merge onto main, or say what conflicts
        if: github.event_name == 'pull_request'
        run: |
@@ -157,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/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/*') }}
+          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') }}

      - name: Build libfakeinput.so and libblsession.so (glibc aarch64)
        if: steps.preloads.outputs.cache-hit != 'true'
@@ -179,6 +208,13 @@ jobs:
          aarch64-linux-gnu-gcc -shared -fPIC -O2 -Wall -pthread \
            -o "$D/libblfastpath.so" tools/proot/fastpath/fastpath.c -ldl
          aarch64-linux-gnu-strip --strip-unneeded "$D/libblfastpath.so"
+          aarch64-linux-gnu-gcc -shared -fPIC -O2 -Wall -nostdlib -ffreestanding -fno-stack-protector \
+            -fno-tree-loop-distribute-patterns -Wl,-z,defs -o "$D/libblaudit.so" tools/proot/fastpath/audit.c
+          aarch64-linux-gnu-strip --strip-unneeded "$D/libblaudit.so"
+          # Force-SSBS adapter, preloaded into a game's Wine only when the game asks for it.
+          aarch64-linux-gnu-gcc -shared -fPIC -O2 -Wall -pthread \
+            -o "$D/libssbs.so" tools/linuxfs/ssbs/ssbs_adapter.c -ldl
+          aarch64-linux-gnu-strip --strip-unneeded "$D/libssbs.so"
          mkdir -p "$D/usr/local/bin"
          aarch64-linux-gnu-gcc -O2 -Wall -Wextra -o "$D/usr/local/bin/droiddeck-clipboard" tools/linuxfs/clipboard/clipboard.c -ldl
          aarch64-linux-gnu-strip --strip-unneeded "$D/usr/local/bin/droiddeck-clipboard"
@@ -190,20 +226,12 @@ jobs:
          done
          if [ -f tools/gamescope/release.env ]; then
            . tools/gamescope/release.env
-            gh release download "${GAMESCOPE_TAG}" -R "${GITHUB_REPOSITORY}" -p gamescope.tzst -O gamescope.tzst
+            gh release download "${GAMESCOPE_TAG}" -R "${GAMESCOPE_REPO:-${GITHUB_REPOSITORY}}" -p gamescope.tzst -O gamescope.tzst
            echo "${GAMESCOPE_SHA256}  gamescope.tzst" | sha256sum -c -
            tar --use-compress-program=unzstd -xf gamescope.tzst -C "$D"
            test -f "$D/usr/local/bin/gamescope"
            rm gamescope.tzst
          fi
-          if [ -f tools/wlroots/release.env ]; then
-            . tools/wlroots/release.env
-            gh release download "${WLROOTS_TAG}" -R "${GITHUB_REPOSITORY}" -p wlroots.tzst -O wlroots.tzst
-            echo "${WLROOTS_SHA256}  wlroots.tzst" | sha256sum -c -
-            tar --use-compress-program=unzstd -xf wlroots.tzst -C "$D"
-            test -f "$D/usr/local/lib/droiddeck-wlroots/libwlroots-0.20.so"
-            rm wlroots.tzst
-          fi
          . tools/linuxfs/uruntime.env
          curl -fsSL --retry 3 -o uruntime "https://github.com/VHSgunzo/uruntime/releases/download/${URUNTIME_VERSION}/${URUNTIME_ASSET}"
          echo "${URUNTIME_SHA256}  uruntime" | sha256sum -c -
@@ -230,20 +258,68 @@ jobs:
          install -Dm644 tools/mangoapp/mangoapp "$D/usr/local/bin/mangoapp"
          rm -rf mango-pkgs
          ls -l "$M"
+          # The Windows components installer's tools (tools/msitools/packages.txt).
+          T="$D/usr/local/lib/droiddeck-msitools"
+          mkdir -p "$T" msi-pkgs
+          grep -v '^#' tools/msitools/packages.txt | while read -r sum url; do
+            [ -n "$url" ] || continue
+            curl -fsSL --retry 3 -o msi-pkgs/pkg.tar.xz "$url"
+            echo "$sum  msi-pkgs/pkg.tar.xz" | sha256sum -c -
+            tar -xJf msi-pkgs/pkg.tar.xz -C msi-pkgs
+            rm msi-pkgs/pkg.tar.xz
+          done
+          install -m644 msi-pkgs/usr/bin/msiinfo "$T/msiinfo"
+          install -m644 msi-pkgs/usr/bin/cabextract "$T/cabextract"
+          # 7-Zip (the full build with its format plugin) opens installer .exe wrappers.
+          install -m644 msi-pkgs/usr/lib/7zip/7z "$T/7z"
+          install -m644 msi-pkgs/usr/lib/7zip/7z.so "$T/7z.so"
+          for so in libmsi-1.0.so.0 libgsf-1.so.114 libgcab-1.0.so.0; do
+            cp -L "msi-pkgs/usr/lib/$so" "$T/$so"
+          done
+          for f in NOTICE GPL-2 GPL-3 LGPL-2.1 7zip-License 7zip-unRarLicense; do
+            install -Dm644 "tools/msitools/licenses/$f" "$D/usr/local/share/licenses/droiddeck-msitools/$f"
+          done
+          rm -rf msi-pkgs
+          ls -l "$T"
          install -Dm644 tools/linuxfs/desktop/droiddeck-desktop "$D/usr/local/bin/droiddeck-desktop"
          install -Dm644 tools/linuxfs/desktop/droiddeck-gpu "$D/usr/local/bin/droiddeck-gpu"
          install -Dm644 tools/linuxfs/desktop/droiddeck-desktop-gpu "$D/usr/local/bin/droiddeck-desktop-gpu"
-          install -Dm644 tools/linuxfs/desktop/autostart "$D/etc/xdg/labwc/autostart"
-          install -Dm644 tools/linuxfs/desktop/rc.xml "$D/etc/xdg/labwc/rc.xml"
-          install -Dm644 tools/linuxfs/desktop/panel.conf "$D/etc/xdg/lxqt/panel.conf"
+          install -Dm644 tools/linuxfs/desktop/kwin_wayland_wrapper "$D/usr/local/bin/kwin_wayland_wrapper"
          install -Dm644 tools/linuxfs/desktop/firefox-droiddeck.js "$D/usr/lib/firefox/defaults/pref/droiddeck.js"
          ls -lR "$D"

+      # The Debian 11 image the preloads are compiled in comes from a release on this repo
+      # (published once by ci-debian-image.yml, pinned in tools/linuxfs/debian-image.env): the
+      # public registry mirrors rate-limit the shared runner addresses and failed builds on a
+      # busy evening. Only if that download fails is the image pulled, with retries.
+      - name: Fetch the Debian image the preloads build in
+        if: steps.preloads.outputs.cache-hit != 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          . tools/linuxfs/debian-image.env
+          image=public.ecr.aws/docker/library/debian:bullseye
+          if gh release download "$DEBIAN_IMAGE_TAG" -R "$GITHUB_REPOSITORY" -p "$DEBIAN_IMAGE_ASSET" -O /tmp/debian-image.tar.zst \
+             && { [ -z "$DEBIAN_IMAGE_SHA256" ] || echo "$DEBIAN_IMAGE_SHA256  /tmp/debian-image.tar.zst" | sha256sum -c -; }; then
+            zstd -dc /tmp/debian-image.tar.zst | docker load
+            rm -f /tmp/debian-image.tar.zst
+          else
+            echo "::warning::the hosted Debian image could not be fetched; pulling from the registry instead"
+            for attempt in 1 2 3 4 5; do
+              docker pull "$image" && break
+              [ "$attempt" -lt 5 ] || { echo "::error::could not pull $image after $attempt attempts"; exit 1; }
+              echo "pull attempt $attempt failed (registry busy?); retrying in $((attempt * 30)) s"
+              sleep $((attempt * 30))
+            done
+          fi
+          docker image ls "$image"
+
      - name: Build the x86 preloads FEX guests load (glibc 2.31)
        if: steps.preloads.outputs.cache-hit != 'true'
        run: |
          set -euo pipefail
-          docker run --rm -v "$PWD:/src" -w /src debian:bullseye bash -c '
+          docker run --rm -v "$PWD:/src" -w /src public.ecr.aws/docker/library/debian:bullseye bash -c '
            set -euo pipefail
            printf "deb http://archive.debian.org/debian bullseye main\ndeb http://archive.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list
            apt-get -o Acquire::Check-Valid-Until=false update -qq
@@ -291,6 +367,11 @@ jobs:
          set -euo pipefail
          curl -fsSL -o pa.tar.gz https://github.com/pulseaudio/pulseaudio/archive/refs/tags/v13.0.tar.gz
          mkdir -p pa13 && tar -xzf pa.tar.gz -C pa13 --strip-components=1 && rm pa.tar.gz
+      # DirectAudio - the game driver (one set per Wine audio interface), the Android-side helper and
+      # the Steam client's sinks - comes from a pinned release of The412Banner/directaudio, checksummed,
+      # exactly like gamescope; nothing compiled for audio is kept in this repo.
+      - name: Fetch DirectAudio (tools/directaudio/release.env)
+        run: tools/directaudio/fetch.sh "$PWD" "$PWD/sink-out"
      - name: Build the AAudio sink into the audio bundle
        run: |
          set -euo pipefail
@@ -300,12 +381,12 @@ jobs:
          tar --use-compress-program=unzstd -xf app/src/main/assets/pulseaudio.tzst -C pa-bundle
          test ! -f pa-bundle/modules/arm64/module-aaudio-sink.so
          install -m755 sink-out/module-aaudio-sink.so pa-bundle/modules/arm64/module-aaudio-sink.so
-          install -m755 sink-out/module-directaudio-sink.so pa-bundle/modules/arm64/module-directaudio-sink.so
+          install -m755 sink-out/module-directaudio-native-sink.so pa-bundle/modules/arm64/module-directaudio-native-sink.so
          (cd pa-bundle && tar --use-compress-program='zstd -19' -cf ../pulseaudio.tzst .)
-          mv pulseaudio.tzst app/src/main/assets/pulseaudio.tzst
-          tar --use-compress-program=unzstd -tf app/src/main/assets/pulseaudio.tzst | grep -c '\.so$'
+          mkdir -p app/build/prepared-assets
+          mv pulseaudio.tzst app/build/prepared-assets/pulseaudio.tzst
+          tar --use-compress-program=unzstd -tf app/build/prepared-assets/pulseaudio.tzst | grep -c '\.so$'
          rm -rf pa-bundle sink-out
-
      - name: Cache proot
        id: proot
        uses: actions/cache@v4
@@ -324,30 +405,40 @@ jobs:
      - name: Check the preloads
        run: |
          set -euo pipefail
-          D=app/src/main/assets/linuxfs
-          NEED=$(readelf -d "$D/libfakeinput.so" | sed -n 's/.*NEEDED.*\[\(.*\)\]/\1/p')
-          for bad in libstdc++.so.6 libgcc_s.so.1; do
-            if printf '%s\n' "$NEED" | grep -qx "$bad"; then
-              echo "::error::libfakeinput.so links $bad - the C++ runtime must stay static"; exit 1
-            fi
-          done
-          syms() { readelf -Ws "$1" | awk '$4 == "FUNC" && $5 == "GLOBAL" {sub(/@.*/, "", $8); print $8}'; }
-          FAKE=$(syms "$D/libfakeinput.so")
-          for sym in open openat ioctl read close poll ppoll select stat fstat access scandir; do
-            grep -qx "$sym" <<<"$FAKE" || { echo "::error::libfakeinput.so does not export $sym"; exit 1; }
-          done
-          # The static C++ runtime stays private: every session process preloads this library,
-          # and an exported personality routine takes over other programs' unwinding (shadPS4
-          # aborted in pthread_exit).
-          if grep -qxE '__gxx_personality_v0|__cxa_throw|_Unwind_Resume' <<<"$FAKE"; then
-            echo "::error::libfakeinput.so exports the C++ runtime"; exit 1
-          fi
-          SESSION=$(syms "$D/libblsession.so")
-          for sym in socket bind getsockname setsockopt statfs statvfs syscall shm_open shm_unlink mmap mmap64 munmap; do
-            grep -qx "$sym" <<<"$SESSION" || { echo "::error::libblsession.so does not export $sym"; exit 1; }
-          done
-          test -f "$D/usr/local/bin/droiddeck-session"
-          test -f "$D/usr/local/bin/droiddeck-proton-extra"
+          bash tools/linuxfs/check-preloads.sh app/src/main/assets/linuxfs
+
+      # The store download engines (app/src/main/rust/stores) are Rust, built by Gradle's
+      # buildRustStores task through cargo-ndk. rustup and cargo are on the runner image; the Android
+      # target and cargo-ndk are added here. Cache = cargo registry + cargo-ndk + the crate's target
+      # tree, keyed on the rustc version and Cargo.lock, so a source-only change rebuilds this crate
+      # on top of the cached dependency objects, and a lockfile change still starts from the
+      # previous objects (restore-keys).
+      - name: Rust toolchain for the store engines (aarch64-linux-android)
+        id: rust
+        run: |
+          set -euo pipefail
+          rustup target add aarch64-linux-android
+          echo "rustc=$(rustc -V | awk '{print $2}')" >> "$GITHUB_OUTPUT"
+          rustc -V; cargo -V
+
+      - name: Cache cargo registry and the store engines' target
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry/index
+            ~/.cargo/registry/cache
+            ~/.cargo/git/db
+            ~/.cargo/bin/cargo-ndk
+            app/src/main/rust/stores/target
+          key: stores-${{ steps.rust.outputs.rustc }}-${{ hashFiles('app/src/main/rust/stores/Cargo.lock') }}
+          restore-keys: |
+            stores-${{ steps.rust.outputs.rustc }}-
+
+      - name: cargo-ndk
+        run: |
+          set -euo pipefail
+          command -v cargo-ndk >/dev/null || cargo install cargo-ndk --locked
+          cargo ndk --version

      - name: Cache the CMake build tree
        uses: actions/cache@v4
@@ -363,10 +454,46 @@ jobs:
        id: build
        env:
          DROIDDECK_BUILD_LABEL: ${{ steps.build-label.outputs.label }}
+          SGDB_API_KEY: ${{ secrets.SGDB_API_KEY }}
        run: |
          set -o pipefail
+          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
+          python3 tools/release/runtime_inputs.py apk app/build/outputs/apk/release/app-release.apk
+
+      - name: Check the store engines' library
+        # The exports Kotlin binds must be in the apk's libdroiddeckstores.so, or the stores fail on
+        # the device with an UnsatisfiedLinkError instead of here. The lockfile check is the
+        # reproducibility guard: cargo must not have had to re-resolve anything.
+        run: |
+          set -euo pipefail
+          NDK="${ANDROID_NDK_LATEST_HOME:-${ANDROID_NDK_HOME:-$ANDROID_NDK_ROOT}}"
+          python3 tools/release/check_android_libraries.py app/build/outputs/apk/release/app-release.apk \
+            --readelf "$NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-readelf"
+          git diff --stat -- app/src/main/rust/stores/Cargo.lock
+          git diff --exit-code -- app/src/main/rust/stores/Cargo.lock \
+            || { echo "::error::Cargo.lock changed during the build; commit the regenerated lockfile (uploaded as stores-cargo-lock)"; exit 1; }
+
+      - name: Store engines host unit tests
+        # The crate's #[test] functions are pure host-side logic (manifest parsing, chunk plans,
+        # assembly from a cache, hashes), so a plain `cargo test` on the runner's own architecture
+        # runs them; the Android build above compiles none of them. Informational on this first
+        # run - the point is to learn whether they pass - and bounded so a hang can never hold
+        # the apk. Make it blocking once it is known green.
+        timeout-minutes: 10
+        continue-on-error: true
+        run: |
+          cd app/src/main/rust/stores
+          cargo test --locked 2>&1 | tail -60
+
+      - name: Upload the regenerated Cargo.lock
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: stores-cargo-lock
+          path: app/src/main/rust/stores/Cargo.lock
+          if-no-files-found: ignore

      - name: Steam import and game environment tests
        run: python3 -m unittest discover -s tools/tests -p 'test_*.py'
@@ -374,27 +501,6 @@ jobs:
      - name: Unit tests
        run: ./gradlew testReleaseUnitTest --console=plain -PndkVersion="$NDK_VERSION"

-      - name: Check the native dependency closure
-        run: |
-          set -euo pipefail
-          APK=$(find app/build/outputs/apk -name '*.apk' | head -1)
-          WORK=$(mktemp -d)
-          unzip -q "$APK" 'lib/arm64-v8a/*' -d "$WORK"
-          cd "$WORK/lib/arm64-v8a"
-          SYSTEM="libc.so libm.so libdl.so liblog.so libandroid.so libz.so libvulkan.so libstdc++.so
-                  libGLESv2.so libEGL.so libnativewindow.so libjnigraphics.so libaaudio.so
-                  libOpenSLES.so libmediandk.so libcamera2ndk.so libsync.so libneuralnetworks.so"
-          fail=0
-          for so in *.so; do
-            for need in $(readelf -d "$so" | sed -n 's/.*NEEDED.*\[\(.*\)\]/\1/p'); do
-              [ -f "$need" ] && continue
-              case " $(echo $SYSTEM) " in *" $need "*) continue ;; esac
-              echo "::error::$so needs $need, which is neither in the apk nor a platform library"
-              fail=1
-            done
-          done
-          exit $fail
-
      - name: Sign with the testkey (v1 + v2 + v3)
        run: |
          set -euo pipefail
@@ -0,0 +1,55 @@
+name: Publish the CI Debian image
+
+# Pulls the Debian 11 image the x86 preloads build in, once, and publishes it as a release asset
+# on this repo so build.yml never depends on a registry mirror's rate limit. Run it again (with a
+# new tag) only to refresh the image; tools/linuxfs/debian-image.env names the one builds use.
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Release tag to publish to (a new -rN tag for a refresh; builds pin the one in tools/linuxfs/debian-image.env)'
+        required: true
+        default: 'ci-debian-bullseye-r2'
+      replace:
+        description: 'Overwrite the asset if the release already has one (changes its checksum: re-pin it in debian-image.env)'
+        type: boolean
+        default: false
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    steps:
+      - name: Pull, save and publish
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ inputs.tag }}
+          REPLACE: ${{ inputs.replace }}
+        run: |
+          set -euo pipefail
+          image=public.ecr.aws/docker/library/debian:bullseye
+          # A published image is pinned by checksum in the build; never replace one by accident.
+          if [ "$REPLACE" != true ] && gh release view "$TAG" -R "$GITHUB_REPOSITORY" --json assets -q '.assets[].name' 2>/dev/null | grep -qx debian-bullseye.tar.zst; then
+            echo "::error::$TAG already carries debian-bullseye.tar.zst; publish to a new tag, or set replace and re-pin tools/linuxfs/debian-image.env"
+            exit 1
+          fi
+          for attempt in 1 2 3 4 5 6; do
+            docker pull "$image" && break
+            [ "$attempt" -lt 6 ] || { echo "::error::could not pull $image"; exit 1; }
+            echo "pull attempt $attempt failed (registry busy?); retrying in $((attempt * 30)) s"
+            sleep $((attempt * 30))
+          done
+          docker image inspect "$image" --format 'image id {{.Id}} created {{.Created}}'
+          docker save "$image" | zstd -19 -T0 -o debian-bullseye.tar.zst
+          sha256sum debian-bullseye.tar.zst | tee SHA256SUMS
+          ls -l debian-bullseye.tar.zst
+          if ! gh release view "$TAG" -R "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release create "$TAG" -R "$GITHUB_REPOSITORY" --title "CI Debian 11 image ($TAG)" --latest=false \
+              --notes "The debian:bullseye image build.yml compiles the x86 preloads in (glibc 2.31), saved with docker save and compressed with zstd. Pulled from public.ecr.aws/docker/library/debian:bullseye on $(date -u +%Y-%m-%d); image id $(docker image inspect "$image" --format '{{.Id}}'). Pinned in tools/linuxfs/debian-image.env."
+          fi
+          gh release upload "$TAG" -R "$GITHUB_REPOSITORY" debian-bullseye.tar.zst SHA256SUMS --clobber
+          { echo "Published \`$TAG\`:"; echo; echo '```'; cat SHA256SUMS; echo '```'; } >> "$GITHUB_STEP_SUMMARY"
@@ -13,13 +13,28 @@ permissions:
  contents: read
  pull-requests: read

+concurrency:
+  group: pr-release-${{ github.event.pull_request.number }}
+  cancel-in-progress: false
+  queue: max
+
 jobs:
  cleanup:
    runs-on: ubuntu-24.04
    timeout-minutes: 5
    steps:
+      - name: Check the current PR state
+        id: state
+        env:
+          GH_TOKEN: ${{ github.token }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+        run: |
+          set -euo pipefail
+          state=$(gh api "repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER" --jq .state)
+          echo "closed=$([ "$state" = closed ] && echo true || echo false)" >> "$GITHUB_OUTPUT"
      # A token of the org's "DroidDeck CI Publisher" app, as build.yml's announce job uses.
      - uses: actions/create-github-app-token@v2
+        if: ${{ steps.state.outputs.closed == 'true' }}
        id: ci-token
        with:
          app-id: ${{ vars.DROIDDECK_CI_APP_ID }}
@@ -27,6 +42,7 @@ jobs:
          owner: Droid-Deck
          repositories: DroidDeck-CI
      - name: Delete the test build
+        if: ${{ steps.state.outputs.closed == 'true' }}
        env:
          GH_TOKEN: ${{ steps.ci-token.outputs.token }}
          PR_NUMBER: ${{ github.event.pull_request.number }}
@@ -42,6 +58,19 @@ jobs:
          done
          [ "$found" = 1 ] || echo "No test build for PR #$PR_NUMBER"

+      - uses: actions/checkout@v4
+        if: ${{ steps.state.outputs.closed == 'true' }}
+        with:
+          ref: main
+          persist-credentials: false
+      - name: Retire the Discord PR announcement
+        if: ${{ steps.state.outputs.closed == 'true' }}
+        env:
+          WEBHOOK: ${{ secrets.DISCORD_PR_BUILDS_WEBHOOK }}
+          GH_TOKEN: ${{ github.token }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+        run: python3 tools/release/pr_discord.py retire
+
  catalog:
    needs: cleanup
    if: ${{ always() }}
@@ -26,6 +26,7 @@ permissions:
 concurrency:
  group: pr-release-${{ github.event_name == 'pull_request_target' && github.event.pull_request.number || github.event_name == 'workflow_run' && github.event.workflow_run.pull_requests[0].number || inputs.pr_number }}
  cancel-in-progress: false
+  queue: max

 jobs:
  authorize:
@@ -178,6 +179,10 @@ jobs:
      issues: write
      pull-requests: write
    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          persist-credentials: false
      - uses: actions/download-artifact@v4
        with:
          pattern: droiddeck-pr-signed-*
@@ -307,39 +312,27 @@ jobs:
          $NEXT
          EOF
          )
-          id=$(gh api "repos/$GITHUB_REPOSITORY/issues/$PR_NUMBER/comments" --paginate \
-            --jq ".[] | select(.body | startswith(\"$mark\")) | .id" | head -1 || true)
+          comment=$(gh api "repos/$GITHUB_REPOSITORY/issues/$PR_NUMBER/comments" --paginate --slurp | \
+            jq "[.[][] | select(.user.login == \"github-actions[bot]\") | select(.body | startswith(\"$mark\"))] | first // {}")
+          id=$(jq -r '.id // empty' <<<"$comment")
          if [ -n "$id" ]; then
+            state=$(jq -r '.body | split("\n")[] | select(startswith("<!-- droiddeck-discord: ") and endswith(" -->"))' <<<"$comment")
+            if [ -n "$state" ]; then body=$(printf '%s\n%s' "$body" "$state"); fi
            gh api -X PATCH "repos/$GITHUB_REPOSITORY/issues/comments/$id" -f body="$body" >/dev/null
          else
            gh api -X POST "repos/$GITHUB_REPOSITORY/issues/$PR_NUMBER/comments" -f body="$body" >/dev/null
          fi

-      # Asked for (the label, a manual run): always announced. Signed on its own after a push:
-      # only a PR's first test build is, and later ones update its release quietly.
-      - name: Post to Discord
-        if: ${{ always() && steps.publish.outcome == 'success' && (needs.authorize.outputs.automatic != 'true' || steps.publish.outputs.first == 'true') }}
+      - name: Update the Discord PR announcement
+        if: ${{ always() && steps.publish.outcome == 'success' }}
        env:
-          WEBHOOK: ${{ secrets.DISCORD_BUILDS_WEBHOOK }}
+          WEBHOOK: ${{ secrets.DISCORD_PR_BUILDS_WEBHOOK }}
          GH_TOKEN: ${{ github.token }}
          PR_NUMBER: ${{ needs.authorize.outputs.pr_number }}
          HEAD_SHA: ${{ needs.authorize.outputs.head_sha }}
          RELEASE: ${{ steps.publish.outputs.release }}
          APK: ${{ steps.publish.outputs.apk }}
-        run: |
-          set -euo pipefail
-          if [ -z "$WEBHOOK" ]; then
-            echo "::notice::No DISCORD_BUILDS_WEBHOOK secret; nothing posted"
-            exit 0
-          fi
-          short=${HEAD_SHA:0:7}
-          title=$(gh api "repos/$GITHUB_REPOSITORY/pulls/$PR_NUMBER" --jq .title)
-          what="[#$PR_NUMBER]($GITHUB_SERVER_URL/$GITHUB_REPOSITORY/pull/$PR_NUMBER): $title"
-          get=$(printf 'Download: [standard APK](<%s>) · [all variants](<%s>)' "$APK" "$RELEASE")
-          content=$(printf '**New signed PR test build** \`pr-%s\` · \`%s\`\n%s\n_Not merged — for testing._\n%s' "$PR_NUMBER" "$short" "$what" "$get")
-          jq -n --arg content "$content" '{content: $content, allowed_mentions: {parse: []}}' |
-            curl -fsS -H 'Content-Type: application/json' -d @- "$WEBHOOK" -o /dev/null
-          echo "Posted: $content"
+        run: python3 tools/release/pr_discord.py publish

  catalog:
    needs: publish
@@ -13,6 +13,7 @@ permissions:
 concurrency:
  group: update-app-catalog
  cancel-in-progress: false
+  queue: max

 jobs:
  catalog:
@@ -13,7 +13,12 @@ captures/
 app/src/main/assets/linuxfs/
 app/src/main/jniLibs/arm64-v8a/libproot.so
 app/src/main/jniLibs/arm64-v8a/.proot-inputs
+app/src/main/jniLibs/arm64-v8a/.proot-outputs
 app/src/main/jniLibs/arm64-v8a/libproot-loader.so
+app/src/main/jniLibs/arm64-v8a/libdirectaudiorelay.so
+# The store download engines (app/src/main/rust/stores) are cross-compiled by Gradle into
+# app/build/rustJniLibs; cargo's own build tree stays next to the crate. Neither is source.
+app/src/main/rust/stores/target/
 app/src/main/assets/droiddeck-esync/

 # Kotlin compiler session files (build-tool state, never source).
@@ -34,3 +39,4 @@ __pycache__/

 # Local signing with the release key (tools/build_local.sh); holds a password.
 .signing.env
+app/src/main/assets/directaudio/
@@ -15,21 +15,25 @@ DroidDeck brings the SteamOS experience to Android: Valve's Steam client in Big

 ## Requirements and install

-Use Android 9 or newer on a supported Adreno device (730 or newer, or 8xx). Mali, Xclipse, PowerVR, and Adreno 710 are unsupported. No root is required. Allow about 3 GB for the runtime and 1.1 GB more for the desktop and emulators. Install the APK from [Releases](https://github.com/Droid-Deck/DroidDeck/releases), install the Linux runtime, then press **Play** and sign in. Steam downloads on first launch. Install **Desktop & apps** to use the desktop and emulators. The **Store** installs Linux apps and games from Flathub (ARM64 builds) with Flatpak; with additional options to install Appimages and set up scripts.
+Use Android 9 or newer on a supported Adreno device (730 or newer, or 8xx). Adreno 6xx is experimental: DirectX 11 uses DXVK 2 and may run, and DirectX 12 games can still crash. Mali, Xclipse, PowerVR, and Adreno 710 are unsupported. No root is required. Allow about 3 GB for the runtime and 1.1 GB more for the desktop and emulators. Install the APK from [Releases](https://github.com/Droid-Deck/DroidDeck/releases), install the Linux runtime, then press **Play** and sign in. Steam downloads on first launch. Install **Desktop & apps** to use the desktop and emulators. The **Store** installs Linux apps and games from Flathub (ARM64 builds) with Flatpak; with additional options to install Appimages and set up scripts. **Stores** (Setup › Stores › "Show Stores in the rail") signs in to GOG, Epic Games and Amazon Games, browses their catalogs and libraries, downloads games into the Games storage and adds each one to the Steam client as a non-Steam game, so it launches through Proton like everything else; the cog on its chip row sets which tab a store opens on and the download speed tier.

 Before Steam launches, you must turn off **Restrict child processes** in Developer options. If this option is not available in developer settings (Android 12 and 13 devices), first launch of Steam will present a "Fix it for me" button, which will help automate the setup process.

 ## Community

-Join the [DroidDeck Discord](https://discord.gg/JRGAvawjsm) for help, Preview builds, and device reports. Bug reports go in its **#bug-reports** forum; attach the session folder from `Download/DroidDeck/` so the logs come with it.
+Join the [DroidDeck Discord](https://discord.gg/JRGAvawjsm) for help, Preview builds, and device reports. Bug reports go in its **#bug-reports** forum; attach the zip from **Share logs** (Setup, or the session drawer) so the logs come with it.

 ## Build

-Run `tools/build_local.sh` with Docker, Java 17, the Android SDK/NDK, and `zstd` installed. It builds the ARM64 audio sinks from PulseAudio 13.0 and packages them into the APK at `app/build/outputs/apk/release/app-release.apk`. Set `DROIDDECK_PA13_SOURCE_DIR` to an existing PulseAudio 13.0 source directory to skip downloading it. To install the APK on an attached device, run `tools/deploy_local.sh`.
+Run `tools/build_local.sh` with Docker, Java 17, the Android SDK/NDK, Rust through rustup, GitHub CLI, Python 3, and `zstd` installed. It prepares the same native libraries, pinned components and audio sinks as CI, then checks the APK's assets, JNI exports and dependencies. The APK is at `app/build/outputs/apk/release/app-release.apk`. Set `DROIDDECK_PA13_SOURCE_DIR` to an existing PulseAudio 13.0 source directory to skip downloading it. Set `DROIDDECK_SIGNING_ENV` to a signing environment file to install over a release build; relative keystore paths resolve beside that file. To install on an attached device, run `tools/deploy_local.sh`.
+
+After preparation, ordinary `./gradlew :app:assembleRelease` builds can reuse the verified inputs. If native sources, component pins or staged files change, packaging stops with instructions to rerun the helper. Generated audio stays under `app/build/`; the tracked base bundle is never modified. `./gradlew -PskipRust=true :app:testDebugUnitTest` needs no native preparation. For an APK without store engines, use `DROIDDECK_SKIP_RUST=1 tools/build_local.sh`; it omits cached engine libraries too.
+
+Run the helper and preload regression suite with `bash tools/test_local.sh`. On macOS it runs in Linux through Docker, matching the helpers' runtime and CI instead of compiling Linux preloads against macOS headers.

 ## Limits

-Compatibility and performance vary by device; hardware validation is limited. Desktop compositing uses software rendering. Firefox sandboxing is reduced under proot. See the session logs in `Download/DroidDeck/` when diagnosing problems.
+Compatibility and performance vary by device; hardware validation is limited. Desktop compositing uses software rendering. Firefox sandboxing is reduced under proot. Logs are kept app-private (`files/logs/`, the last 30 sessions); **Share logs** packs the newest session, with the stores and tool logs, into one scrubbed zip.

 ## Credits and licence

@@ -59,6 +59,19 @@ def ciBuild = providers.environmentVariable('GITHUB_ACTIONS').getOrNull() == 'tr
 def releaseSigner = rootProject.file('keystore/release-signer.sha256').text.trim()
 // When the source was committed, for "built 3 hours ago": fixed per commit, so it costs no rebuilds.
 def commitTime = (gitValue(['show', '-s', '--format=%ct', 'HEAD']) ?: '0').with { it.isLong() ? it : '0' }
+// The desktop package this apk installs (tools/desktop-kde/release.env): published once per tag in
+// DroidDeck-Components, pinned here with its checksum like gamescope and the esync packs, so the
+// desktop scripts in the apk always get the package they were made for.
+def desktopKde = rootProject.file('tools/desktop-kde/release.env').readLines()
+    .findAll { it.contains('=') && !it.startsWith('#') }
+    .collectEntries { def kv = it.split('=', 2); [(kv[0].trim()): kv[1].trim()] }
+def desktopRemovalSources = new groovy.json.JsonSlurper().parse(file('src/main/assets/desktop-removal/sources.json'))
+if (desktopRemovalSources.archives[desktopKde.DESKTOP_KDE_TAG] != desktopKde.DESKTOP_KDE_SHA256) {
+    throw new GradleException('Desktop removal inventories do not match the pinned archive')
+}
+if (!file('src/main/assets/desktop-removal/versions.txt').readLines().contains(desktopKde.DESKTOP_KDE_TAG)) {
+    throw new GradleException('Regenerate desktop removal inventories for ' + desktopKde.DESKTOP_KDE_TAG)
+}
 // tools/release/variants.txt as "package=suffix;...", so the updater picks the apk of the package it runs as.
 def variantSuffixes = rootProject.file('tools/release/variants.txt').readLines()
    .findAll { it.trim() && !it.startsWith('#') }
@@ -79,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 10
-        versionName "0.3.0"
+        versionCode 12
+        versionName "0.3.2"
        buildConfigField "String", "BUILD_LABEL", "\"${escapedBuildLabel}\""
        buildConfigField "String", "SOURCE_COMMIT", "\"${sourceCommit}\""
        buildConfigField "int", "PR_NUMBER", "${prNumber}"
@@ -88,6 +101,11 @@ android {
        buildConfigField "String", "RELEASE_SIGNER", "\"${releaseSigner}\""
        buildConfigField "long", "COMMIT_TIME", "${commitTime}L * 1000L"
        buildConfigField "String", "VARIANT_SUFFIXES", "\"${variantSuffixes}\""
+        buildConfigField "String", "SGDB_API_KEY", "\"${System.getenv("SGDB_API_KEY") ?: project.findProperty("sgdbApiKey") ?: ""}\""
+        buildConfigField "String", "DESKTOP_KDE_TAG", "\"${desktopKde.DESKTOP_KDE_TAG}\""
+        buildConfigField "String", "DESKTOP_KDE_URL", "\"https://github.com/${desktopKde.DESKTOP_KDE_REPO}/releases/download/${desktopKde.DESKTOP_KDE_TAG}/desktop-kde.tar.zst\""
+        buildConfigField "String", "DESKTOP_KDE_SHA256", "\"${desktopKde.DESKTOP_KDE_SHA256}\""
+        buildConfigField "long", "DESKTOP_KDE_SIZE", "${desktopKde.DESKTOP_KDE_SIZE}L"

        ndk {
            abiFilters 'arm64-v8a'
@@ -165,6 +183,8 @@ android {
    testOptions {
        // Plain JVM tests: a stray android.util.Log call returns a default instead of throwing.
        unitTests.returnDefaultValues = true
+        // Robolectric tests start activities whose text is now all string resources.
+        unitTests.includeAndroidResources = true
    }

    compileOptions {
@@ -186,10 +206,82 @@ def stageSessionScripts = tasks.register('stageSessionScripts', Copy) {
 }
 tasks.named('preBuild').configure { dependsOn(stageSessionScripts) }

+// Prepared audio lives under build/, so native builds never rewrite the tracked base bundle.
+// Copying into one asset root also prevents an old base bundle winning a duplicate asset merge.
+def runtimeAssetsDir = layout.buildDirectory.dir('runtimeAssets')
+def stageRuntimeAssets = tasks.register('stageRuntimeAssets', Sync) {
+    dependsOn(stageSessionScripts)
+    from(layout.projectDirectory.dir('src/main/assets')) { exclude 'pulseaudio.tzst' }
+    from(layout.buildDirectory.dir('prepared-assets'))
+    into(runtimeAssetsDir)
+}
+android.sourceSets.main.assets.setSrcDirs([runtimeAssetsDir])
+tasks.named('preBuild').configure { dependsOn(stageRuntimeAssets) }
+
+// Unit tests and previews remain usable without Docker. Packaging an APK requires the complete
+// runtime payload prepared by the local helper or CI, with matching sources and output hashes.
+def verifyRuntimeInputs = tasks.register('verifyRuntimeInputs', Exec) {
+    // The session scripts are re-copied into the asset tree by stageSessionScripts; with parallel
+    // task execution this check once hashed a file mid-copy and failed a main build. Hash only
+    // once the staging has finished.
+    mustRunAfter(stageSessionScripts, stageRuntimeAssets)
+    workingDir rootProject.projectDir
+    commandLine 'python3', 'tools/release/runtime_inputs.py', 'verify'
+}
+tasks.configureEach { task ->
+    if (task.name in ['packageDebug', 'packageRelease']) task.dependsOn(verifyRuntimeInputs)
+}
+
+// The GOG / Epic / Amazon download engines are Rust (app/src/main/rust/stores, ported from
+// Bannerlator's bl-steam-client crate). cargo-ndk cross-compiles them for arm64-v8a into the build
+// directory, which is one more jniLibs source below: nothing compiled is committed, the same rule
+// the preloads, proot and the DirectAudio relay follow. cargo-ndk exports the NDK clang/llvm-ar as
+// the C compiler for the one C-compiling crate (ring, under rustls) - the step Bannerlator's CI
+// does by hand - and reads the NDK from ANDROID_NDK_HOME, which is set to the NDK this build pins.
+// -PskipRust=true builds without the library, for a checkout with no Rust toolchain: the stores
+// then report themselves unavailable instead of the build failing.
+def rustCrateDir = layout.projectDirectory.dir('src/main/rust/stores')
+def rustJniLibsDir = layout.buildDirectory.dir('rustJniLibs')
+def skipRust = (project.findProperty('skipRust') ?: 'false').toString().toBoolean()
+def buildRustStores = tasks.register('buildRustStores', Exec) {
+    description = 'Cross-compiles the store download engines (libdroiddeckstores.so) with cargo-ndk.'
+    onlyIf { !skipRust }
+    inputs.dir(rustCrateDir.dir('src'))
+    inputs.files(rustCrateDir.file('Cargo.toml'), rustCrateDir.file('Cargo.lock'))
+    inputs.property('ndkVersion', android.ndkVersion)
+    if (!skipRust) inputs.property('rustToolchain', providers.exec {
+        environment 'PATH', "${System.getProperty('user.home')}/.cargo/bin${File.pathSeparator}${System.getenv('PATH')}"
+        commandLine 'rustup', 'run', 'stable', 'rustc', '-Vv'
+    }.standardOutput.asText)
+    outputs.dir(rustJniLibsDir)
+    workingDir rustCrateDir
+    // The configuration cache serialises the task, so everything it needs is resolved here, not
+    // in doFirst. ~/.cargo/bin is where rustup puts cargo and cargo-ndk; an IDE-launched Gradle
+    // does not always have it on PATH.
+    def cargoBin = "${System.getProperty('user.home')}/.cargo/bin"
+    environment 'PATH', "${cargoBin}${File.pathSeparator}${System.getenv('PATH')}"
+    environment 'ANDROID_NDK_HOME', android.ndkDirectory.absolutePath
+    environment 'CARGO_TERM_COLOR', 'never'
+    if (!skipRust) environment 'RUSTC', providers.exec {
+        commandLine 'rustup', 'which', '--toolchain', 'stable', 'rustc'
+    }.standardOutput.asText.get().trim()
+    // --platform 26 = minSdkVersion: the engines link against the API 26 libc, like the C++ code.
+    // Homebrew's cargo/rustc can precede rustup on macOS and use a different sysroot, despite
+    // rustup reporting the Android target installed. Run both through the selected toolchain.
+    commandLine 'rustup', 'run', 'stable', 'cargo', 'ndk', '--target', 'arm64-v8a', '--platform', '26',
+        '--output-dir', rustJniLibsDir.get().asFile.absolutePath,
+        'build', '--release', '--locked'
+}
+// Skipping Rust must omit its library even if another build left a cached .so behind.
+if (!skipRust) android.sourceSets.main.jniLibs.srcDir(rustJniLibsDir)
+tasks.named('preBuild').configure { dependsOn(buildRustStores) }
+
 dependencies {
    // The runtime tarball is a zstd-compressed tar.
    implementation 'com.github.luben:zstd-jni:1.5.2-3@aar'
    implementation 'org.apache.commons:commons-compress:1.27.1'
+    // Bannerlator's Windows components come as .tar.xz (WinComponents).
+    implementation 'org.tukaani:xz:1.10'
    // The UI: every menu, dialog and overlay is Compose. The session's SurfaceView and the
    // on-screen pad are Views underneath it, which is what they are in every Compose app.
    implementation platform('androidx.compose:compose-bom:2024.02.00')
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <application>
-        <!-- Debug builds only. Android grants DUMP to adb shell; release APKs have no bridge. -->
-        <activity
-            android:name=".agent.AgentStartActivity"
-            android:exported="true"
-            android:excludeFromRecents="true"
-            android:noHistory="true"
-            android:permission="android.permission.DUMP"
-            android:theme="@style/SessionTheme" />
-        <provider
-            android:name=".agent.AgentBridgeProvider"
-            android:authorities="${applicationId}.agent"
-            android:exported="true"
-            android:permission="android.permission.DUMP"
-            android:grantUriPermissions="false" />
-    </application>
-</manifest>
@@ -1,167 +0,0 @@
-package com.droiddeck.launcher.agent
-
-import android.Manifest
-import android.content.ContentProvider
-import android.content.ContentValues
-import android.content.Context
-import android.content.pm.PackageManager
-import android.database.Cursor
-import android.net.Uri
-import android.os.Binder
-import android.os.Bundle
-import android.os.Process
-import com.droiddeck.launcher.BuildConfig
-import com.droiddeck.launcher.runtime.LinuxRuntime
-import com.droiddeck.launcher.runtime.LinuxRuntimeInstaller
-import com.droiddeck.launcher.session.SessionArtifacts
-import com.droiddeck.launcher.session.SessionEvents
-import com.droiddeck.launcher.session.SessionPhase
-import com.droiddeck.launcher.session.SessionPaths
-import com.droiddeck.launcher.session.SessionService
-import com.droiddeck.launcher.session.SessionState
-import org.json.JSONArray
-import org.json.JSONObject
-import java.io.File
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-/** A shell-only control surface, installed only by debug builds. */
-class AgentBridgeProvider : ContentProvider() {
-    override fun onCreate(): Boolean {
-        val appContext = context?.applicationContext ?: return false
-        Thread({
-            try {
-                SessionArtifacts.finishAbandoned(appContext)
-            } finally {
-                recoveryComplete.countDown()
-            }
-        }, "agent-recover-artifacts").start()
-        return true
-    }
-
-    override fun call(method: String, arg: String?, extras: Bundle?): Bundle {
-        val context = requireNotNull(context)
-        if (Binder.getCallingUid() != Process.myUid() &&
-            context.checkCallingPermission(Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED
-        ) {
-            throw SecurityException("android.permission.DUMP is required")
-        }
-
-        val response = try {
-            when (method) {
-                "state" -> state(context).put("ok", true)
-                "start" -> error("USE_DROIDDECKCTL", "Start sessions with tools/droiddeckctl so Android launches a visible Activity")
-                "stop" -> stop(context)
-                "resume" -> resume(context)
-                else -> error("UNKNOWN_COMMAND", "Unknown agent command '$method'")
-            }
-        } catch (e: Exception) {
-            error("COMMAND_FAILED", e.message ?: e.javaClass.simpleName)
-        }
-        return Bundle().apply { putString(RESULT_JSON, response.toString()) }
-    }
-
-    private fun state(context: Context): JSONObject {
-        val runtimeVersion = LinuxRuntimeInstaller.installedVersion(context)
-        val dir = SessionState.logDirectory ?: SessionState.logFile?.parentFile ?: latestSessionDirectory()
-        val session = JSONObject()
-            .put("id", SessionState.sessionId ?: dir?.name ?: JSONObject.NULL)
-            .put("phase", SessionState.phase.name)
-            .put("running", SessionState.running)
-            .put("mode", SessionState.mode)
-            .put("program", SessionState.program ?: JSONObject.NULL)
-            .put("steamUi", SessionState.steamUi ?: JSONObject.NULL)
-            .put("steamUrl", SessionState.steamUrl ?: JSONObject.NULL)
-            .put("suspended", SessionState.suspended)
-            .put("pip", SessionState.pipActive)
-            .put("firstFrame", SessionState.firstFrameSeen)
-            .put("output", JSONArray().put(SessionState.outputSize.first).put(SessionState.outputSize.second))
-            .put("refreshHz", SessionState.refreshHz.toDouble())
-            .put("lastTransitionAt", SessionState.lastTransitionAt)
-            .put("guestPid", SessionState.guestPid.takeIf { it > 1 } ?: JSONObject.NULL)
-            .put("installing", SessionState.installing ?: JSONObject.NULL)
-            .put("logDir", dir?.absolutePath ?: JSONObject.NULL)
-            .put("eventsFile", dir?.let { File(it, "events.jsonl").absolutePath } ?: JSONObject.NULL)
-            .put("artifactsAvailable", dir?.isDirectory ?: false)
-            .put("artifactsComplete", dir?.let { File(it, ".complete").isFile } ?: false)
-
-        val failure = if (SessionState.failureCode == null) JSONObject.NULL else JSONObject()
-            .put("code", SessionState.failureCode)
-            .put("message", SessionState.failureMessage ?: JSONObject.NULL)
-            .put("status", SessionState.failureStatus ?: JSONObject.NULL)
-        session.put("failure", failure)
-
-        return JSONObject()
-            .put("schema", 1)
-            .put("build", BuildConfig.BUILD_LABEL)
-            .put("appVersion", context.packageManager.getPackageInfo(context.packageName, 0).versionName)
-            .put("runtime", JSONObject()
-                .put("installed", LinuxRuntime.isInstalled(context))
-                .put("version", runtimeVersion ?: JSONObject.NULL))
-            .put("session", session)
-    }
-
-    private fun latestSessionDirectory(): File? {
-        val parent = LinuxRuntime.debugLogDir()
-        return parent.listFiles { file -> file.isDirectory && file.name.startsWith("session-") }
-            ?.maxWithOrNull(compareBy<File> { it.lastModified() }.thenBy { it.name })
-    }
-
-    private fun stop(context: Context): JSONObject {
-        if (SessionState.running) {
-            SessionService.stop(context)
-            return JSONObject().put("ok", true).put("command", "stop")
-        }
-        if (SessionState.phase == SessionPhase.STOPPING) {
-            return JSONObject().put("ok", true).put("command", "stop")
-        }
-        if (SessionState.phase in STARTING_PHASES) {
-            SessionState.stopRequested = true
-            SessionEvents.transition(SessionPhase.STOPPING, "session.stop_requested")
-            return JSONObject().put("ok", true).put("command", "stop")
-        }
-        return error("NO_ACTIVE_SESSION", "There is no session to stop")
-    }
-
-    private fun resume(context: Context): JSONObject {
-        if (!SessionState.running || !SessionState.suspended) {
-            return error("SESSION_NOT_SUSPENDED", "There is no suspended session to resume")
-        }
-        SessionService.resume(context)
-        return JSONObject().put("ok", true).put("command", "resume")
-    }
-
-    private fun error(code: String, message: String) = JSONObject()
-        .put("ok", false)
-        .put("error", JSONObject().put("code", code).put("message", message))
-
-    override fun query(uri: Uri, projection: Array<out String>?, selection: String?, selectionArgs: Array<out String>?, sortOrder: String?): Cursor? = null
-    override fun getType(uri: Uri): String? = null
-    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
-    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
-    override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?): Int = 0
-
-    companion object {
-        const val RESULT_JSON = "json"
-        private val recoveryComplete = CountDownLatch(1)
-
-        fun awaitRecovery() {
-            try {
-                if (!recoveryComplete.await(90, TimeUnit.SECONDS)) {
-                    throw IllegalStateException("Session artifact recovery did not finish")
-                }
-            } catch (e: InterruptedException) {
-                Thread.currentThread().interrupt()
-                throw IllegalStateException("Interrupted while recovering session artifacts", e)
-            }
-        }
-
-        private val STARTING_PHASES = setOf(
-            SessionPhase.PREPARING,
-            SessionPhase.INSTALLING_RUNTIME,
-            SessionPhase.STARTING_COMPOSITOR,
-            SessionPhase.STARTING_GUEST,
-            SessionPhase.STARTING_STEAM,
-        )
-    }
-}
@@ -8,6 +8,8 @@
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <!-- Store download progress and "installed" / "failed" notices (Android 13+). -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
    <!-- The session keeps running while the app is not on screen: a foreground service holds the
         process at perceptible priority, and a high-performance WiFi lock keeps a backgrounded
         download from being throttled to nothing by the radio's power-save. -->
@@ -28,6 +30,9 @@
    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <!-- Installs DroidDeck's own updates (Updates page) over itself, after the user allows it. -->
    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+    <!-- A paired Steam Controller, read over Bluetooth LE out of lizard mode (SteamControllerBle).
+         Granted at install below targetSdk 31; no scan, so no location. -->
+    <uses-permission android:name="android.permission.BLUETOOTH" />

    <uses-feature android:name="android.hardware.vulkan.version" android:version="0x401000" android:required="true" />
    <uses-feature android:name="android.hardware.gamepad" android:required="false" />
@@ -71,6 +76,10 @@
                <action android:name="android.intent.action.CREATE_SHORTCUT" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
+            <intent-filter>
+                <action android:name="com.droiddeck.launcher.LAUNCH_GAME" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
        </activity>

        <!-- Android owns the Home key. This small translucent Home handler routes the resulting
@@ -123,6 +132,21 @@
            android:screenOrientation="sensorLandscape"
            android:theme="@style/AppTheme" />

+        <!-- A store's own sign-in page (GOG, Epic Games, Amazon Games) in a WebView. -->
+        <activity
+            android:name=".stores.StoreLoginActivity"
+            android:exported="false"
+            android:screenOrientation="sensorLandscape"
+            android:theme="@style/AppTheme" />
+
+        <activity
+            android:name=".agent.AgentStartActivity"
+            android:exported="true"
+            android:excludeFromRecents="true"
+            android:noHistory="true"
+            android:permission="android.permission.DUMP"
+            android:theme="@style/SessionTheme" />
+
        <activity
            android:name=".SessionActivity"
            android:exported="false"
@@ -151,6 +175,11 @@
        <service
            android:name=".core.WirelessAdbPairingService"
            android:exported="false" />
+        <!-- Keeps the process alive while a store (GOG, Epic, Amazon) game downloads. -->
+        <service
+            android:name=".stores.download.StoreDownloadService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync" />
        <!-- Hands a zipped session folder to the share sheet; nothing else is exposed. -->
        <provider
            android:name="androidx.core.content.FileProvider"
@@ -173,5 +202,11 @@
                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
            </intent-filter>
        </provider>
+        <provider
+            android:name=".agent.AgentBridgeProvider"
+            android:authorities="${applicationId}.agent"
+            android:exported="true"
+            android:permission="android.permission.DUMP"
+            android:grantUriPermissions="false" />
    </application>
 </manifest>
@@ -0,0 +1,49 @@
+{
+  "archives": {
+    "lxqt-r1": "c2bb860b3b1688287451e2495be5db313ec07f8c8af501dfac2768a9f417bc86",
+    "desktop-kde-r1": "55747e75d0ec055ab7ea1e92a757f3be227cc3205bb9101f5b53cadef6318579",
+    "desktop-kde-r2": "9ba832677b498654136c69d8c8330434d17e4d53cd099acac9bde3ba429b35bf",
+    "emulators-r1": "a1f4806a9663d28f424b4cab1277e0ede80a92e69de5bc063cdc8b45af220164"
+  },
+  "desktopApplications": {
+    "ark-26.08.1-1-aarch64.pkg.tar.xz": "93e2c2b75ff20cd29b4f312ed1979ef6f27255b93232b93bfcdb31239903c1d4",
+    "breeze-6.7.5-1-aarch64.pkg.tar.xz": "1d7f4eb9d8d234caaea23621909f5233d19462c2f058afeeb54bed7b81bd03bd",
+    "breeze-gtk-6.7.5-1-any.pkg.tar.xz": "a0f59bc4fc426879c8f8a97f6dcc707fb7d1b52913da5eb7e9db83777b6957b7",
+    "breeze-icons-6.30.0-1-aarch64.pkg.tar.xz": "4bae4689032501156687a227024e56554820747644953c67fc8d2e2b6b0b045a",
+    "dolphin-26.08.1-1-aarch64.pkg.tar.xz": "fef738ab8132d3eba1156b98c116699ce0a5efcb4cb462efbacdcf4c47f79a23",
+    "firefox-157.0.1-1-aarch64.pkg.tar.xz": "d142fdb8a339a65eca7cea6a2bba5b29202386166abd9d59851d6757c9eb2163",
+    "gwenview-26.08.1-1-aarch64.pkg.tar.xz": "a9dc7d5ab73fa677905d5a57248b1b9b404b6b16e862958cc7443d387f684a47",
+    "kate-26.08.1-1-aarch64.pkg.tar.xz": "acf50710042746f243a3b219a1ae0f788e338f3dd9d75093e8bb671a618b83b6",
+    "kde-cli-tools-6.7.5-1-aarch64.pkg.tar.xz": "af466398a912a994a97fadfe46aff401d88a90d7fdce7e843dc4218098fa38ac",
+    "kde-gtk-config-6.7.5-1-aarch64.pkg.tar.xz": "ba6cb4cb01dbb3f2c247f2f6973ede3b64c0849f89340217b51dfbf11cb8cb5c",
+    "kinfocenter-6.7.5-1-aarch64.pkg.tar.xz": "f3d5416db96b50f9a5b8a284d82ae21d834a8cce646010abdd7087491c399b0b",
+    "konsole-26.08.1-1-aarch64.pkg.tar.xz": "1ecf87c0d11d620ebe4aeafb02788e0d5f4fe9019ad9c5d9f1011c43237dd5ec",
+    "kscreen-6.7.5-1-aarch64.pkg.tar.xz": "8fbaa6fedf93edeba021a5416b551663654919b27c2ee237d696ec0b0ce7d5b7",
+    "kwin-6.7.5-1-aarch64.pkg.tar.xz": "a7535710c74b90359f80306134b2b7581132cbac508dc84b7e07ef275cc8c3fe",
+    "mpv-1:0.41.0-6-aarch64.pkg.tar.xz": "6c89d00736820210a3c7f32af4cf95d155191d463f9df8bd22137c45f30a554a",
+    "plasma-desktop-6.7.5-1-aarch64.pkg.tar.xz": "b266dd42cea965b5ab1cc1ae600877e9d3bc83ec642c61fe1669c4457e641a55",
+    "plasma-integration-6.7.5-1-aarch64.pkg.tar.xz": "daa96da14d9a4d12c0d9c0341e1be6836a9a437c469d61da5e9844d51e2606cf",
+    "plasma-pa-6.7.5-1-aarch64.pkg.tar.xz": "02dbefe9d3e0069b2bb37cac2a6be18b8f0a1887c87704a0716e7a9268eadcd8",
+    "plasma-workspace-6.7.5-1-aarch64.pkg.tar.xz": "3a1455857afaa9ccf342ab6167f0f15794ee9d248b0925398ea6f62f12730a86",
+    "spectacle-1:6.7.5-1-aarch64.pkg.tar.xz": "0c9837412ea6119edef18bcb0a8fceb74634cb35be0ca78b3e1dd1ff2443866e",
+    "systemsettings-6.7.5-1-aarch64.pkg.tar.xz": "b02b6a726857d5125c92d1ec95379216c7a3bc1f187a3b46e88c0d056b29ce70",
+    "xdg-desktop-portal-kde-6.7.5-1-aarch64.pkg.tar.xz": "2c57d17d34d577023eb9cd7b0fca1ba9163549afe60450f6271aa148af099ef2"
+  },
+  "legacyApplications": {
+    "featherpad-1.6.3-1-aarch64.pkg.tar.xz": "fcac55215815c0b712453f9bcc09abfe4b518e36025a111a7a7598ef04913f3d",
+    "labwc-0.20.2-1-aarch64.pkg.tar.xz": "bcd4cc3945165b0fdd33c0117cd7b9dfd05cf8c327326c37f3c3a27ef23ee5ca",
+    "lximage-qt-2.4.0-1-aarch64.pkg.tar.xz": "5d6bdd5472ea6bcb4b993b36df3ab7010bb2e62b36a78a649708fc9a52cb0928",
+    "lxqt-config-2.4.0-1-aarch64.pkg.tar.xz": "4b601d798fc7689ee76787dbef8c8958c02429ee60248cd99d950c919dbefba5",
+    "lxqt-panel-2.4.1-1-aarch64.pkg.tar.xz": "a141e0f8049e73f859d843510c6f45d6ed9087c990bcebf44f5f2430621024c4",
+    "lxqt-qtplugin-2.4.0-3-aarch64.pkg.tar.xz": "61c8f828be73111ee0bd5e3163b0d64c2098dd0189710a190f42be11137695cf",
+    "lxqt-runner-2.4.0-1-aarch64.pkg.tar.xz": "5afa74652a37366ea4e7774cf33379977582fbdca599cef1005ebf637cbcae4b",
+    "lxqt-session-2.4.0-2-aarch64.pkg.tar.xz": "e9c7c8a0011859029622ad202e0d3826e4e5bc8d64659031f6efa211456ff6eb",
+    "lxqt-themes-2.4.0-1-any.pkg.tar.xz": "7ea16c62a1fa70cdac13cb3f8fdcdaad299ae1f5bd514acfda671484755787bf",
+    "lxqt-wayland-session-0.4.1-1-any.pkg.tar.xz": "cd8dc11f5035469d23b6bbd937a90593402428c43de37517412aa43fe1fc6b10",
+    "papirus-icon-theme-20260801-1-any.pkg.tar.xz": "4aae3f47b800a60d6fd360e55adc581408ceaafc481c5a420a681741a3966510",
+    "pcmanfm-qt-2.4.1-1-aarch64.pkg.tar.xz": "7ec1a6b39dd0e4055b39f0e2c0549ea263d83004e1b821fb9e42f1d7f5fff0f9",
+    "qterminal-2.4.0-1-aarch64.pkg.tar.xz": "aa4adc9c9d47641b9452ec8d879038a9cb4762c3b6b5299045fac968fd0ed22d",
+    "swaybg-1.2.2-1-aarch64.pkg.tar.xz": "a26caa16ca7d581b5ca05758677058b4b60af10dc8d83e447ad6824b762b48b8",
+    "wlr-randr-0.5.0-1-aarch64.pkg.tar.xz": "58c3651c6a15dc8f95a310c7e225f759aa766be2fb3c0981a9a8b567854675b3"
+  }
+}
@@ -0,0 +1,2 @@
+desktop-kde-r1
+desktop-kde-r2
@@ -1,115 +0,0 @@
-# DirectAudio for the Linux Steam client (relay build)
-
-This is the driver for games that run under **Valve's ARM64 Proton inside a Linux
-runtime on Android** - Bannerlator's linuxfs session with the native Steam client -
-where the game process is a glibc process and cannot touch Android's audio
-libraries itself.
-
-Two pieces, both required:
-
-| piece | what it is | where it runs |
-|---|---|---|
-| `aarch64-unix/winedirectaudio.so` + the two PE shells | the Wine `mmdevapi` driver, glibc build, **no AAudio inside** | in the game, inside the Linux rootfs |
-| `directaudio-relay` | a small bionic program that owns the AAudio output and microphone streams | on the Android side, under the app's uid |
-
-They meet over a unix socket. The driver connects, sends its launch config, and
-gets back two shared-memory rings: one it fills with mixed game audio, one the
-helper fills with microphone audio. The helper plays and records; the driver
-keeps doing everything else it always did.
-
-## Which Proton
-
-Built inside `ValveSoftware/wine` at `proton_11.0`. The private `mmdevapi`
-interface it implements is byte-identical across **Proton 11.0 (ARM64)**,
-**Proton Experimental (ARM64)** and our own Wine-11 layers (checked 2026-09-19),
-so this one build serves any of them. A future Proton on a Wine 12 base will
-need a rebuild - the interface is not versioned, and a mismatch is silence, not
-an error.
-
-## Installing the driver next to Proton (not into it)
-
-Steam verifies and updates its Proton depots, so files added under
-`steamapps/common/Proton .../files/lib/wine/` will not survive. Put the driver
-in a directory of its own and point Wine at it:
-
-```
-<somewhere>/directaudio/lib/wine/aarch64-unix/winedirectaudio.so
-<somewhere>/directaudio/lib/wine/aarch64-windows/winedirectaudio.drv
-<somewhere>/directaudio/lib/wine/i386-windows/winedirectaudio.drv
-```
-
-and set, for the game process:
-
-```
-WINEDLLPATH=<somewhere>/directaudio/lib/wine
-```
-
-Wine searches `WINEDLLPATH` entries with the per-arch subdirectories appended,
-so both the PE shell and the unixlib are found there. In Bannerlator's runtime
-the natural place to export it is the `bannerlator-proton` compatibility-tool
-wrapper, which every Proton launch goes through.
-
-## Selecting the driver
-
-`mmdevapi` only tries the drivers named in the registry (or its built-in
-`pulse,alsa,oss,coreaudio` list, which does not know about this one). Set, in the
-game's prefix:
-
-```
-wine reg add "HKCU\Software\Wine\Drivers" /v Audio /d directaudio /f
-```
-
-Under Proton the prefix is `compatdata/<appid>/pfx`; run the command with that
-prefix as `WINEPREFIX` using Proton's own `bin-arm64/wine`, or write the key from
-the wrapper before it hands off to Proton.
-
-## Running the helper
-
-```
-directaudio-relay --socket <path> [--log]
-```
-
- Run it **under the app's uid**, the way the app already runs its PulseAudio
-  daemon. Android checks `RECORD_AUDIO` against the calling uid, so a helper
-  started any other way can play but cannot record.
- Start it **before** the game: the driver asks "is a helper there?" once, when
-  Wine picks an audio driver, and falls back to unavailable if not.
- The socket path must be reachable from inside the Linux rootfs. Bannerlator
-  binds the app's files directory and its runtime directory into the session at
-  their own paths, so any socket under either works unchanged on both sides.
- The helper serves any number of game processes; each gets its own streams.
-  It exits on `SIGTERM`; a game exiting tears down that game's streams only.
-
-## Telling the driver where the helper is
-
-```
-BANNER_AUDIO_DIRECT_RELAY=<the same socket path>
-```
-
-Unset, the driver looks for `$XDG_RUNTIME_DIR/directaudio-relay`.
-
-## Everything else is unchanged
-
-All `BANNER_AUDIO_DIRECT_*` knobs mean what they mean in the in-process build:
-`_PERF`, `_ADAPTIVE`, `_DECAY`, `_MS`, `_MAXMS`, `_BF`, `_MBF`, `_EXCLUSIVE`,
-`_WATCHDOG`, `_STALL_MS`, `_DECAY_*`, `_LOG`, `_PERIOD_MS`, `_MINPERIOD_MS`, and
-the live-config mailbox `_RUNTIME` (the helper watches the file; it must be a
-path the helper can read on the Android side). **`BANNER_AUDIO_DIRECT_MIC=1`**
-exposes the capture endpoint exactly as before: the helper opens the input
-stream (`VOICE_COMMUNICATION` preset) when the game connects and makes it hot on
-the game's first capture start.
-
-One thing is different: there is one extra hand-off, the ring. The helper's
-callback pulls a burst from it, so the driver keeps two bursts queued (about 8 ms
-on a 192-frame device) on top of the AAudio buffer the presets control, and the
-helper raises that if a callback ever finds the ring short. `get_latency` reports
-the sum, so a game that sizes its own buffers from it still sees the truth.
-
-## Proving it is running
-
- Helper side: `logcat -s DA-Relay:I` shows `hello from <exe>`, then `open: buffer
-  ... ring target ...`, then `capture open` / `capture start` for the mic.
- Game side: the session log carries `DirectAudio: relay: connected - ...`.
- The game process's `/proc/<pid>/maps` shows `winedirectaudio.so` and **no**
-  `libaaudio.so` (it is in the helper's maps instead). The AudioFlinger track is
-  owned by the helper's pid.
@@ -1,4 +0,0 @@
-directaudio linux-wine11 relay build
-source 3548a4a730e8d01cb0cb0268d51a2fb8f23dcd33
-wine ValveSoftware/wine@proton_11.0
-unixlib.h sha256 fdbed263338d0719c4d12e02b045c23721de33219ec8878e4c2d7ebc9efcbe09
@@ -44,6 +44,11 @@ add_subdirectory(waylandcomp)
 add_library(sdnative SHARED sdnative/sdnative.c)
 target_link_libraries(sdnative log)

+# The device info window's Vulkan section: the phone's own driver, asked once through the system
+# loader (opened with dlopen, so a phone without Vulkan still loads the app).
+add_library(deviceinfo SHARED deviceinfo/vkinfo.c)
+target_link_libraries(deviceinfo dl)
+
 # Rebuild Termux terminal-emulator's PTY JNI helper with the app's NDK instead of carrying its
 # prebuilt libtermux.so with a redundant libstdc++.so dependency.
 add_library(termux SHARED termux/termux.c)
@@ -0,0 +1,112 @@
+// What the phone's own Vulkan driver says about its GPU, for the app's device info window: one
+// instance on the system loader, the first physical device's properties, a few limits and the
+// extensions DXVK and VKD3D-Proton lean on. Returned as "key=value" lines; nothing is kept open.
+#include <dlfcn.h>
+#include <jni.h>
+#include <stdio.h>
+#include <string.h>
+#define VK_NO_PROTOTYPES
+#include <vulkan/vulkan.h>
+
+#define LINE(...) do { if (used < sizeof(out)) used += snprintf(out + used, sizeof(out) - used, __VA_ARGS__); } while (0)
+
+static const char *const EXTENSIONS[] = {
+    "VK_EXT_robustness2", "VK_EXT_transform_feedback", "VK_EXT_custom_border_color",
+    "VK_KHR_dynamic_rendering", "VK_EXT_extended_dynamic_state3", "VK_EXT_descriptor_indexing",
+    "VK_KHR_timeline_semaphore", "VK_EXT_mesh_shader", "VK_KHR_ray_query",
+};
+
+static const char *type_name(VkPhysicalDeviceType type) {
+    switch (type) {
+        case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: return "integrated GPU";
+        case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: return "discrete GPU";
+        case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: return "virtual GPU";
+        case VK_PHYSICAL_DEVICE_TYPE_CPU: return "CPU";
+        default: return "other";
+    }
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_droiddeck_launcher_gpu_VulkanInfo_nativeQuery(JNIEnv *env, jclass clazz) {
+    static char out[4096];
+    size_t used = 0;
+    out[0] = 0;
+    void *lib = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL);
+    if (!lib) { LINE("error=no Vulkan loader\n"); return (*env)->NewStringUTF(env, out); }
+    PFN_vkGetInstanceProcAddr gipa = (PFN_vkGetInstanceProcAddr) dlsym(lib, "vkGetInstanceProcAddr");
+    PFN_vkCreateInstance create = gipa ? (PFN_vkCreateInstance) gipa(NULL, "vkCreateInstance") : NULL;
+    PFN_vkEnumerateInstanceVersion instanceVersion = gipa ? (PFN_vkEnumerateInstanceVersion) gipa(NULL, "vkEnumerateInstanceVersion") : NULL;
+    if (!create) { LINE("error=no vkCreateInstance\n"); dlclose(lib); return (*env)->NewStringUTF(env, out); }
+    uint32_t loader = VK_API_VERSION_1_0;
+    if (instanceVersion) instanceVersion(&loader);
+    LINE("loader=%u.%u.%u\n", VK_API_VERSION_MAJOR(loader), VK_API_VERSION_MINOR(loader), VK_API_VERSION_PATCH(loader));
+
+    VkApplicationInfo app = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pApplicationName = "DroidDeck device info",
+                              .apiVersion = loader >= VK_API_VERSION_1_1 ? VK_API_VERSION_1_1 : VK_API_VERSION_1_0 };
+    VkInstanceCreateInfo info = { .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, .pApplicationInfo = &app };
+    VkInstance instance = VK_NULL_HANDLE;
+    if (create(&info, NULL, &instance) != VK_SUCCESS) { LINE("error=vkCreateInstance failed\n"); dlclose(lib); return (*env)->NewStringUTF(env, out); }
+
+#define GET(name) PFN_##name name = (PFN_##name) gipa(instance, #name)
+    GET(vkDestroyInstance); GET(vkEnumeratePhysicalDevices); GET(vkGetPhysicalDeviceProperties);
+    GET(vkGetPhysicalDeviceProperties2); GET(vkGetPhysicalDeviceMemoryProperties);
+    GET(vkEnumerateDeviceExtensionProperties); GET(vkGetPhysicalDeviceFeatures);
+    uint32_t count = 1;
+    VkPhysicalDevice device = VK_NULL_HANDLE;
+    VkResult listed = vkEnumeratePhysicalDevices ? vkEnumeratePhysicalDevices(instance, &count, &device) : VK_ERROR_INITIALIZATION_FAILED;
+    if ((listed != VK_SUCCESS && listed != VK_INCOMPLETE) || count == 0 || !device || !vkGetPhysicalDeviceProperties) {
+        LINE("error=no Vulkan device\n");
+    } else {
+        VkPhysicalDeviceProperties p;
+        vkGetPhysicalDeviceProperties(device, &p);
+        LINE("device=%s\n", p.deviceName);
+        LINE("type=%s\n", type_name(p.deviceType));
+        LINE("api=%u.%u.%u\n", VK_API_VERSION_MAJOR(p.apiVersion), VK_API_VERSION_MINOR(p.apiVersion), VK_API_VERSION_PATCH(p.apiVersion));
+        // Qualcomm packs its driver version as 10.10.12 bits, the same layout as VK_MAKE_VERSION.
+        LINE("driver_version=%u.%u.%u\n", p.driverVersion >> 22, (p.driverVersion >> 12) & 0x3ff, p.driverVersion & 0xfff);
+        LINE("vendor_id=0x%04x\ndevice_id=0x%08x\n", p.vendorID, p.deviceID);
+        LINE("max_image_2d=%u\n", p.limits.maxImageDimension2D);
+
+        // Driver name and build string (Vulkan 1.2 or VK_KHR_driver_properties).
+        uint32_t extCount = 0;
+        if (vkEnumerateDeviceExtensionProperties) vkEnumerateDeviceExtensionProperties(device, NULL, &extCount, NULL);
+        static VkExtensionProperties exts[512];
+        if (extCount > 512) extCount = 512;
+        if (extCount && vkEnumerateDeviceExtensionProperties) vkEnumerateDeviceExtensionProperties(device, NULL, &extCount, exts);
+        int driverProps = p.apiVersion >= VK_API_VERSION_1_2;
+        for (uint32_t i = 0; i < extCount; i++)
+            if (!strcmp(exts[i].extensionName, "VK_KHR_driver_properties")) driverProps = 1;
+        if (driverProps && vkGetPhysicalDeviceProperties2) {
+            VkPhysicalDeviceDriverProperties driver = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES };
+            VkPhysicalDeviceProperties2 p2 = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, .pNext = &driver };
+            vkGetPhysicalDeviceProperties2(device, &p2);
+            LINE("driver_name=%s\n", driver.driverName);
+            LINE("driver_info=%s\n", driver.driverInfo);
+            LINE("conformance=%u.%u.%u.%u\n", driver.conformanceVersion.major, driver.conformanceVersion.minor,
+                 driver.conformanceVersion.subminor, driver.conformanceVersion.patch);
+        }
+        LINE("extension_count=%u\n", extCount);
+        for (size_t e = 0; e < sizeof(EXTENSIONS) / sizeof(*EXTENSIONS); e++) {
+            int has = 0;
+            for (uint32_t i = 0; i < extCount && !has; i++) has = !strcmp(exts[i].extensionName, EXTENSIONS[e]);
+            LINE("ext.%s=%s\n", EXTENSIONS[e], has ? "yes" : "no");
+        }
+        if (vkGetPhysicalDeviceFeatures) {
+            VkPhysicalDeviceFeatures f;
+            vkGetPhysicalDeviceFeatures(device, &f);
+            LINE("geometry_shader=%s\ntessellation_shader=%s\ntexture_bc=%s\n",
+                 f.geometryShader ? "yes" : "no", f.tessellationShader ? "yes" : "no", f.textureCompressionBC ? "yes" : "no");
+        }
+        if (vkGetPhysicalDeviceMemoryProperties) {
+            VkPhysicalDeviceMemoryProperties m;
+            vkGetPhysicalDeviceMemoryProperties(device, &m);
+            VkDeviceSize largest = 0;
+            for (uint32_t i = 0; i < m.memoryHeapCount; i++)
+                if ((m.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) && m.memoryHeaps[i].size > largest) largest = m.memoryHeaps[i].size;
+            LINE("device_heap_mb=%llu\n", (unsigned long long) (largest >> 20));
+        }
+    }
+    if (vkDestroyInstance) vkDestroyInstance(instance, NULL);
+    dlclose(lib);
+    return (*env)->NewStringUTF(env, out);
+}
@@ -136,6 +136,7 @@ JNIEXPORT jint JNICALL Java_com_termux_terminal_JNI_createSubprocess(
            if (!arg_utf8) return throw_runtime_exception(env, "GetStringUTFChars() failed for argv");
            argv[i] = strdup(arg_utf8);
            (*env)->ReleaseStringUTFChars(env, arg_java_string, arg_utf8);
+            (*env)->DeleteLocalRef(env, arg_java_string);
        }
        argv[size] = NULL;
    }
@@ -151,6 +152,7 @@ JNIEXPORT jint JNICALL Java_com_termux_terminal_JNI_createSubprocess(
            if (!env_utf8) return throw_runtime_exception(env, "GetStringUTFChars() failed for env");
            envp[i] = strdup(env_utf8);
            (*env)->ReleaseStringUTFChars(env, env_java_string, env_utf8);
+            (*env)->DeleteLocalRef(env, env_java_string);
        }
        envp[size] = NULL;
    }
@@ -160,7 +162,7 @@ JNIEXPORT jint JNICALL Java_com_termux_terminal_JNI_createSubprocess(
    char const* cmd_utf8 = (*env)->GetStringUTFChars(env, cmd, NULL);
    int ptm = create_subprocess(env, cmd_utf8, cmd_cwd, argv, envp, &procId, rows, columns);
    (*env)->ReleaseStringUTFChars(env, cmd, cmd_utf8);
-    (*env)->ReleaseStringUTFChars(env, cmd, cmd_cwd);
+    (*env)->ReleaseStringUTFChars(env, cwd, cmd_cwd);

    if (argv) {
        for (char** tmp = argv; *tmp; ++tmp) free(*tmp);
@@ -17,6 +17,7 @@ add_library(droiddeckwayland SHARED
        src/wl_clipboard.c
        src/wl_text_input.c
        src/wl_toplevel_icon.c
+        src/wl_single_pixel.c
        src/wl_color_mgmt.c
        src/hdr_compose.c
        src/blend_pass.c
@@ -31,6 +32,7 @@ add_library(droiddeckwayland SHARED
        generated/wlr-data-control-unstable-v1-protocol.c
        generated/text-input-unstable-v3-protocol.c
        generated/xdg-toplevel-icon-v1-protocol.c
+        generated/single-pixel-buffer-v1-protocol.c
        generated/banner-ahb-v1-protocol.c
        src/framegen_bridge.c
        src/framegen_jni.c
@@ -0,0 +1,61 @@
+/* Generated by wayland-scanner 1.26.0 */
+
+/*
+ * Copyright © 2022 Simon Ser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_buffer_interface;
+
+static const struct wl_interface *single_pixel_buffer_v1_types[] = {
+	&wl_buffer_interface,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+};
+
+static const struct wl_message wp_single_pixel_buffer_manager_v1_requests[] = {
+	{ "destroy", "", single_pixel_buffer_v1_types + 0 },
+	{ "create_u32_rgba_buffer", "nuuuu", single_pixel_buffer_v1_types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface wp_single_pixel_buffer_manager_v1_interface = {
+	"wp_single_pixel_buffer_manager_v1", 1,
+	2, wp_single_pixel_buffer_manager_v1_requests,
+	0, NULL,
+};
+
@@ -0,0 +1,142 @@
+/* Generated by wayland-scanner 1.26.0 */
+
+#ifndef SINGLE_PIXEL_BUFFER_V1_SERVER_PROTOCOL_H
+#define SINGLE_PIXEL_BUFFER_V1_SERVER_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-server.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+struct wl_client;
+struct wl_resource;
+
+/**
+ * @page page_single_pixel_buffer_v1 The single_pixel_buffer_v1 protocol
+ * single pixel buffer factory
+ *
+ * @section page_desc_single_pixel_buffer_v1 Description
+ *
+ * This protocol extension allows clients to create single-pixel buffers.
+ *
+ * Compositors supporting this protocol extension should also support the
+ * viewporter protocol extension. Clients may use viewporter to scale a
+ * single-pixel buffer to a desired size.
+ *
+ * Warning! The protocol described in this file is currently in the testing
+ * phase. Backward compatible changes may be added together with the
+ * corresponding interface version bump. Backward incompatible changes can
+ * only be done by creating a new major version of the extension.
+ *
+ * @section page_ifaces_single_pixel_buffer_v1 Interfaces
+ * - @subpage page_iface_wp_single_pixel_buffer_manager_v1 - global factory for single-pixel buffers
+ * @section page_copyright_single_pixel_buffer_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2022 Simon Ser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct wl_buffer;
+struct wp_single_pixel_buffer_manager_v1;
+
+#ifndef WP_SINGLE_PIXEL_BUFFER_MANAGER_V1_INTERFACE
+#define WP_SINGLE_PIXEL_BUFFER_MANAGER_V1_INTERFACE
+/**
+ * @page page_iface_wp_single_pixel_buffer_manager_v1 wp_single_pixel_buffer_manager_v1
+ * @section page_iface_wp_single_pixel_buffer_manager_v1_desc Description
+ *
+ * The wp_single_pixel_buffer_manager_v1 interface is a factory for
+ * single-pixel buffers.
+ * @section page_iface_wp_single_pixel_buffer_manager_v1_api API
+ * See @ref iface_wp_single_pixel_buffer_manager_v1.
+ */
+/**
+ * @defgroup iface_wp_single_pixel_buffer_manager_v1 The wp_single_pixel_buffer_manager_v1 interface
+ *
+ * The wp_single_pixel_buffer_manager_v1 interface is a factory for
+ * single-pixel buffers.
+ */
+extern const struct wl_interface wp_single_pixel_buffer_manager_v1_interface;
+#endif
+
+/**
+ * @ingroup iface_wp_single_pixel_buffer_manager_v1
+ * @struct wp_single_pixel_buffer_manager_v1_interface
+ */
+struct wp_single_pixel_buffer_manager_v1_interface {
+	/**
+	 * destroy the manager
+	 *
+	 * Destroy the wp_single_pixel_buffer_manager_v1 object.
+	 *
+	 * The child objects created via this interface are unaffected.
+	 */
+	void (*destroy)(struct wl_client *client,
+			struct wl_resource *resource);
+	/**
+	 * create a 1×1 buffer from 32-bit RGBA values
+	 *
+	 * Create a single-pixel buffer from four 32-bit RGBA values.
+	 *
+	 * Unless specified in another protocol extension, the RGBA values
+	 * use pre-multiplied alpha.
+	 *
+	 * The width and height of the buffer are 1.
+	 *
+	 * The r, g, b and a arguments valid range is from UINT32_MIN (0)
+	 * to UINT32_MAX (0xffffffff).
+	 *
+	 * These arguments should be interpreted as a percentage, i.e. -
+	 * UINT32_MIN = 0% of the given color component - UINT32_MAX = 100%
+	 * of the given color component
+	 * @param r value of the buffer's red channel
+	 * @param g value of the buffer's green channel
+	 * @param b value of the buffer's blue channel
+	 * @param a value of the buffer's alpha channel
+	 */
+	void (*create_u32_rgba_buffer)(struct wl_client *client,
+				       struct wl_resource *resource,
+				       uint32_t id,
+				       uint32_t r,
+				       uint32_t g,
+				       uint32_t b,
+				       uint32_t a);
+};
+
+
+/**
+ * @ingroup iface_wp_single_pixel_buffer_manager_v1
+ */
+#define WP_SINGLE_PIXEL_BUFFER_MANAGER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_wp_single_pixel_buffer_manager_v1
+ */
+#define WP_SINGLE_PIXEL_BUFFER_MANAGER_V1_CREATE_U32_RGBA_BUFFER_SINCE_VERSION 1
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif
@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="single_pixel_buffer_v1">
+  <copyright>
+    Copyright © 2022 Simon Ser
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="single pixel buffer factory">
+    This protocol extension allows clients to create single-pixel buffers.
+
+    Compositors supporting this protocol extension should also support the
+    viewporter protocol extension. Clients may use viewporter to scale a
+    single-pixel buffer to a desired size.
+
+    Warning! The protocol described in this file is currently in the testing
+    phase. Backward compatible changes may be added together with the
+    corresponding interface version bump. Backward incompatible changes can
+    only be done by creating a new major version of the extension.
+  </description>
+
+  <interface name="wp_single_pixel_buffer_manager_v1" version="1">
+    <description summary="global factory for single-pixel buffers">
+      The wp_single_pixel_buffer_manager_v1 interface is a factory for
+      single-pixel buffers.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        Destroy the wp_single_pixel_buffer_manager_v1 object.
+
+        The child objects created via this interface are unaffected.
+      </description>
+    </request>
+
+    <request name="create_u32_rgba_buffer">
+      <description summary="create a 1×1 buffer from 32-bit RGBA values">
+        Create a single-pixel buffer from four 32-bit RGBA values.
+
+        Unless specified in another protocol extension, the RGBA values use
+        pre-multiplied alpha.
+
+        The width and height of the buffer are 1.
+
+        The r, g, b and a arguments valid range is from UINT32_MIN (0)
+        to UINT32_MAX (0xffffffff).
+        
+        These arguments should be interpreted as a percentage, i.e.
+        - UINT32_MIN = 0% of the given color component
+        - UINT32_MAX = 100% of the given color component
+      </description>
+      <arg name="id" type="new_id" interface="wl_buffer"/>
+      <arg name="r" type="uint" summary="value of the buffer's red channel"/>
+      <arg name="g" type="uint" summary="value of the buffer's green channel"/>
+      <arg name="b" type="uint" summary="value of the buffer's blue channel"/>
+      <arg name="a" type="uint" summary="value of the buffer's alpha channel"/>
+    </request>
+  </interface>
+</protocol>
@@ -745,6 +745,21 @@ static void take_shm(struct surface *s, struct wl_shm_buffer *shm, struct wl_res
    if (ci && ci->asked_feedback) ci->shm_frames++;  /* since it asked for GPU buffers */
 }

+/* A single-pixel buffer (wl_single_pixel.c) as a 1x1 image, which the surface's viewport stretches. */
+static void take_pixel(struct surface *s, const uint8_t bgra[4], struct wl_resource *buffer) {
+    if (s->shm_img && (vkp_image_width(s->shm_img) != 1 || vkp_image_height(s->shm_img) != 1)) {
+        vkp_image_destroy(s->shm_img);
+        s->shm_img = NULL;
+    }
+    if (!s->shm_img) s->shm_img = vkp_image_create_shm(1, 1);
+    if (s->shm_img) vkp_image_upload_shm(s->shm_img, bgra, 4);
+    wl_buffer_send_release(buffer);
+    s->buf_w = 1;
+    s->buf_h = 1;
+    s->buf_alpha = bgra[3] != 0xff;
+    s->has_content = s->shm_img != NULL;
+}
+
 /* The window the app's performance HUD follows: the latest one at least as big as the last to
 * start presenting GPU frames (take_dmabuf) (X11 binds the HUD to the _MESA_DRV window and counts X presents instead). JNI upcalls. */
 static struct surface *g_hud_surface;
@@ -1084,6 +1099,7 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) {
        struct wl_resource *buffer = s->pending_buffer;
        struct dmabuf_buffer *db = get_dmabuf(buffer);
        struct wl_shm_buffer *shm = buffer && !db ? wl_shm_buffer_get(buffer) : NULL;
+        uint8_t pixel[4];

        /* The previous content is replaced before reaching the screen. */
        feedback_discard_all(&s->feedback);
@@ -1113,6 +1129,9 @@ static void surface_commit(struct wl_client *c, struct wl_resource *r) {
        } else if (shm) {
            drop_dmabuf(s, 1);
            take_shm(s, shm, buffer);
+        } else if (single_pixel_buffer_get(buffer, pixel)) {
+            drop_dmabuf(s, 1);
+            take_pixel(s, pixel, buffer);
        } else {
            drop_dmabuf(s, 1);
            s->has_content = 0;
@@ -1661,15 +1680,24 @@ static void bind_desktop(struct wl_client *c, void *data, uint32_t ver, uint32_t
 static void output_release(struct wl_client *c, struct wl_resource *r) { wl_resource_destroy(r); }
 static const struct wl_output_interface output_impl = { .release = output_release };

-static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t id) {
-    struct wl_resource *r = wl_resource_create(c, &wl_output_interface, ver, id);
-    if (!r) { wl_client_post_no_memory(c); return; }
-    wl_resource_set_implementation(r, &output_impl, NULL, NULL);
-    wl_output_send_geometry(r, 0, 0, 340, 190, WL_OUTPUT_SUBPIXEL_UNKNOWN,
-                            "DroidDeck", "Wayland", WL_OUTPUT_TRANSFORM_NORMAL);
+/* Every bound wl_output, so a resized output (a foldable opening) can send its new mode. */
+static struct wl_list g_outputs;
+static void output_resource_destroy(struct wl_resource *r) { wl_list_remove(wl_resource_get_link(r)); }
+
+static void output_send_mode(struct wl_resource *r) {
    wl_output_send_mode(r, WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED,
                        g_output_w > 0 ? g_output_w : 1920, g_output_h > 0 ? g_output_h : 1080,
                        g_output_refresh_mhz > 0 ? g_output_refresh_mhz : 60000);
+}
+
+static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t id) {
+    struct wl_resource *r = wl_resource_create(c, &wl_output_interface, ver, id);
+    if (!r) { wl_client_post_no_memory(c); return; }
+    wl_resource_set_implementation(r, &output_impl, NULL, output_resource_destroy);
+    wl_list_insert(&g_outputs, wl_resource_get_link(r));
+    wl_output_send_geometry(r, 0, 0, 340, 190, WL_OUTPUT_SUBPIXEL_UNKNOWN,
+                            "DroidDeck", "Wayland", WL_OUTPUT_TRANSFORM_NORMAL);
+    output_send_mode(r);
    if (ver >= WL_OUTPUT_NAME_SINCE_VERSION) {
        wl_output_send_name(r, "DroidDeck-1");
        wl_output_send_description(r, "DroidDeck display");
@@ -3200,6 +3228,23 @@ static void key_event(uint32_t evdev, int pressed) {
    wl_display_flush_clients(g_display);
 }

+/* The output changed size under a running session (a foldable opened or closed, with the
+ * session following the screen). Every client that has had its first configure is told the new
+ * size: gamescope's Wayland backend and the desktop's KWin both resize their output to it, and
+ * the next buffers they commit fill the new panel instead of being letterboxed onto it. */
+static void output_resized(void) {
+    struct surface *s;
+    struct wl_resource *r;
+    wl_resource_for_each(r, &g_outputs) {
+        output_send_mode(r);
+        if (wl_resource_get_version(r) >= 2) wl_output_send_done(r);
+    }
+    wl_list_for_each(s, &g_surfaces, link)
+        if (s->xdg_toplevel && s->toplevel_committed) send_toplevel_configure(s);
+    droiddeck_log("display", "output resized to %dx%d", g_output_w, g_output_h);
+    wl_display_flush_clients(g_display);
+}
+
 /* wl event-loop callback: drain queued input events written by the Android UI thread. */
 static int on_input_readable(int fd, uint32_t mask, void *data) {
    struct input_msg m;
@@ -3212,6 +3257,7 @@ static int on_input_readable(int fd, uint32_t mask, void *data) {
        case 5: on_vsync(((int64_t)m.p1 << 32) | (uint32_t)m.p2); break;
        case 6: pointer_delta(m.p1 / 256.0, m.p2 / 256.0); break; /* relative motion, 1/256 px */
        case 7: deliver_touch(&m); break;
+        case 8: output_resized(); break;
        default: deliver_pointer(&m); break;
        }
    }
@@ -3242,6 +3288,14 @@ void droiddeck_wayland_send_key(int evdev, int state) {
    (void)n;
 }

+/* Called from JNI after g_output_w/h changed: the compositor thread re-sends the size. */
+void droiddeck_wayland_output_resized(void) {
+    if (g_input_pipe[1] < 0) return;
+    struct input_msg m = { 8, 0, 0, 0, 0 };
+    ssize_t n = write(g_input_pipe[1], &m, sizeof(m));
+    (void)n;
+}
+
 /* Called from JNI on every screen refresh (Choreographer). */
 void droiddeck_wayland_vsync(int64_t frame_time_ns) {
    if (g_input_pipe[1] < 0) return;
@@ -3439,6 +3493,7 @@ static struct wl_listener g_client_created = { .notify = on_client_created };
 int droiddeck_wayland_run(void) {
    wl_list_init(&g_surfaces);
    wl_list_init(&g_toplevels);
+    wl_list_init(&g_outputs);
    wl_list_init(&g_constraints);
    wl_list_init(&g_relative_pointers);
    open_session_log();
@@ -122,4 +122,5 @@ void droiddeck_ext_init(struct wl_display *display) {
    clipboard_init(display);
    text_input_init(display);
    toplevel_icon_init(display);
+    single_pixel_init(display);
 }
@@ -48,3 +48,6 @@ void text_input_host_commit(const char *utf8, size_t len);
 void text_input_host_preedit(const char *utf8, size_t len, int cursor_begin, int cursor_end);
 void text_input_host_delete(int before, int after);
 void toplevel_icon_init(struct wl_display *display);
+void single_pixel_init(struct wl_display *display);
+/* A wp_single_pixel_buffer_manager_v1 buffer: 1 and its pixel (B, G, R, A, premultiplied), else 0. */
+int single_pixel_buffer_get(struct wl_resource *buffer, uint8_t bgra[4]);
@@ -160,6 +160,11 @@ static const char *vk_result_name(VkResult r);
 static pthread_mutex_t g_req_lock = PTHREAD_MUTEX_INITIALIZER;
 static ANativeWindow *g_req_window;
 static int g_req_pending;
+/* A detach was asked for since the compositor thread last looked. A rebind (null, then the same
+ * window) to rebuild the swapchain at a new size can land in full before the thread gets to it,
+ * and would otherwise read as the same window handed over again - nothing rebuilt, and the old
+ * size's buffers scaled onto the rotated or refolded panel. */
+static int g_req_detached;

 /* Scale mode + alignment (app values, see vk_present.h); written from any thread, read per frame. */
 static volatile int g_mode = VKP_MODE_STRETCH, g_align = VKP_ALIGN_CENTER;
@@ -252,6 +257,7 @@ void vk_present_set_window(ANativeWindow *window) {
    if (g_req_pending && g_req_window && g_req_window != window) superseded = g_req_window;
    g_req_window = window;
    g_req_pending = 1;
+    if (!window) g_req_detached = 1;
    pthread_mutex_unlock(&g_req_lock);
    if (superseded) ANativeWindow_release(superseded);
 }
@@ -261,13 +267,20 @@ int vkp_apply_window_request(void) {
    pthread_mutex_lock(&g_req_lock);
    if (!g_req_pending) { pthread_mutex_unlock(&g_req_lock); return 0; }
    w = g_req_window;
+    const int detached = g_req_detached;
    g_req_window = NULL;
    g_req_pending = 0;
+    g_req_detached = 0;
    pthread_mutex_unlock(&g_req_lock);
    if (w == g_window) {
        /* The same window handed over again (ANativeWindow_fromSurface adds a reference each time). */
        if (w) ANativeWindow_release(w);
-        return 0;
+        if (!w || !detached) return 0;
+        /* ... after a detach: a rebind for a resized surface. Rebuilt at its size on the next frame. */
+        sc_layer_window_gone();
+        destroy_swapchain();
+        droiddeck_log("gpu", "screen surface rebound: rebuilding the swapchain at its new size");
+        return 1;
    }
    sc_layer_window_gone();  /* the layer (if any) belongs to the old window */
    destroy_swapchain(); /* recreated against the new window on the next frame */
@@ -1516,6 +1529,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
                       const struct vkp_hdr_frame *hf, int *how) {
    if (how) *how = 0;
    vkp_apply_window_request();
+    check_surface_changed(); /* a rotation or a fold the rebind did not cover: rebuild at the new size */
    if (g_dev_state == -2) return -1;
    if (dev_init() != 0 || !g_window || scene_w <= 0 || scene_h <= 0) return -1;

@@ -2099,6 +2113,7 @@ static int pass_begin_impl(int scene_w, int scene_h, const struct vkp_draw *draw
                           const struct vkp_hdr_frame *hf, int *rw, int *rh) {
    if (g_pass.active) vkp_pass_abort();
    if (g_dev_state == -2 || dev_init() != 0 || !g_window || scene_w <= 0 || scene_h <= 0) return -1;
+    check_surface_changed(); /* as in render_impl: the effects pass maps onto the output's size */
    if (!g_swapchain && swap_init() != 0) return -1; /* the mapping is in output pixels */
    update_map(scene_w, scene_h);
    if (!g_map.valid) return -1;
@@ -30,6 +30,7 @@ extern int  droiddeck_cursor_serial(void);
 extern void droiddeck_wayland_send_key(int evdev, int state);
 extern void droiddeck_wayland_send_scene_input(int type, int a, int b);
 extern void droiddeck_wayland_vsync(int64_t frame_time_ns);
+extern void droiddeck_wayland_output_resized(void);
 extern volatile int g_fps_limit;
 extern volatile int g_hide_shell;
 extern volatile int g_zero_copy;
@@ -401,6 +402,17 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetOutputSize(JNIEnv
    g_output_h = h > 0 ? h : 0;
 }

+/* The output's size changed while the compositor runs (a foldable opening or closing with the
+ * session following the screen): store it and have the compositor thread tell the clients. */
+JNIEXPORT void JNICALL
+Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeResizeOutput(JNIEnv *env, jclass clazz, jint w, jint h) {
+    (void)env; (void)clazz;
+    if (w <= 0 || h <= 0) return;
+    g_output_w = w;
+    g_output_h = h;
+    droiddeck_wayland_output_resized();
+}
+
 /* Fullscreen mode + screen alignment (Container.FULLSCREEN_* / ALIGN_* values): how the scene is
 * fitted onto the output. Any thread, any time; the next frame uses it. */
 JNIEXPORT void JNICALL
@@ -0,0 +1,51 @@
+/*
+ * wp_single_pixel_buffer_manager_v1 (version 1): a wl_buffer of one pixel of one colour, which a
+ * client stretches over a surface with wp_viewporter. KWin's Wayland backend - the desktop's KWin
+ * nested in this compositor - refuses to start without it. The surface takes the pixel as a 1x1
+ * image, the way it takes a wl_shm buffer (compositor.c, take_pixel).
+ */
+#include <stdlib.h>
+#include "droiddeck_ext.h"
+#include "single-pixel-buffer-v1-server-protocol.h"
+
+struct single_pixel {
+    uint8_t bgra[4]; /* premultiplied, as wl_shm's ARGB8888 lies in memory */
+};
+
+static void buffer_destroy(struct wl_client *c, struct wl_resource *r) { wl_resource_destroy(r); }
+static const struct wl_buffer_interface buffer_impl = { .destroy = buffer_destroy };
+
+static void buffer_free(struct wl_resource *r) { free(wl_resource_get_user_data(r)); }
+
+int single_pixel_buffer_get(struct wl_resource *buffer, uint8_t bgra[4]) {
+    if (!buffer || !wl_resource_instance_of(buffer, &wl_buffer_interface, &buffer_impl)) return 0;
+    struct single_pixel *p = wl_resource_get_user_data(buffer);
+    for (int i = 0; i < 4; i++) bgra[i] = p->bgra[i];
+    return 1;
+}
+
+static void mgr_destroy(struct wl_client *c, struct wl_resource *r) { wl_resource_destroy(r); }
+static void mgr_create_buffer(struct wl_client *c, struct wl_resource *r, uint32_t id,
+                              uint32_t red, uint32_t green, uint32_t blue, uint32_t alpha) {
+    struct single_pixel *p = calloc(1, sizeof(*p));
+    struct wl_resource *buffer = p ? wl_resource_create(c, &wl_buffer_interface, 1, id) : NULL;
+    if (!buffer) { free(p); wl_client_post_no_memory(c); return; }
+    /* The protocol's values span the whole u32 range; the top byte is the 8-bit channel. */
+    p->bgra[0] = blue >> 24;
+    p->bgra[1] = green >> 24;
+    p->bgra[2] = red >> 24;
+    p->bgra[3] = alpha >> 24;
+    wl_resource_set_implementation(buffer, &buffer_impl, p, buffer_free);
+}
+static const struct wp_single_pixel_buffer_manager_v1_interface mgr_impl = {
+    .destroy = mgr_destroy, .create_u32_rgba_buffer = mgr_create_buffer,
+};
+static void bind_manager(struct wl_client *c, void *data, uint32_t ver, uint32_t id) {
+    struct wl_resource *r = wl_resource_create(c, &wp_single_pixel_buffer_manager_v1_interface, ver, id);
+    if (!r) { wl_client_post_no_memory(c); return; }
+    wl_resource_set_implementation(r, &mgr_impl, NULL, NULL);
+}
+
+void single_pixel_init(struct wl_display *display) {
+    wl_global_create(display, &wp_single_pixel_buffer_manager_v1_interface, 1, NULL, bind_manager);
+}
@@ -11,15 +11,26 @@ import com.droiddeck.launcher.session.GpuClockPin
 * sandboxes are started through (BwrapSpawner).
 */
 class App : Application() {
+    override fun attachBaseContext(base: android.content.Context) =
+        super.attachBaseContext(com.droiddeck.launcher.core.AppLanguage.wrap(base))
+
+    override fun onConfigurationChanged(newConfig: android.content.res.Configuration) {
+        super.onConfigurationChanged(newConfig)
+        com.droiddeck.launcher.core.AppLanguage.systemChanged(newConfig)
+    }
+
    override fun onCreate() {
        super.onCreate()
        CrashHandler.install(this)
-        // Before anything else touches the session prefs, so the first session already runs in Deck mode.
-        com.droiddeck.launcher.session.SessionPrefs.settleDeckModeDefault(this)
        com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this)
        com.droiddeck.launcher.update.AppUpdates.init(this)
        GpuClockPin.clearLeftover(this)
        BwrapSpawner.start(this)
        com.droiddeck.launcher.frontend.GameFileSync.start(this)
+        // The game stores the Stores section can talk to; the native engine loads only when one needs it.
+        com.droiddeck.launcher.stores.StoresState.init(this)
+        com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.gog.GogBackend)
+        com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.epic.EpicBackend)
+        com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.amazon.AmazonBackend)
    }
 }
@@ -63,7 +63,7 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
        if (compBusy != null) return
        compBusy = label
        Thread({
-            val message = runCatching(work).getOrElse { e -> "$label failed: ${e.message ?: e.javaClass.simpleName}" }
+            val message = runCatching(work).getOrElse { e -> activity.getString(R.string.main_action_failed, label, e.message ?: e.javaClass.simpleName) }
            ui.post {
                compBusy = null
                android.widget.Toast.makeText(activity, message, android.widget.Toast.LENGTH_LONG).show()
@@ -79,7 +79,7 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
            val cat = runCatching { ComponentsManager.catalog(activity, true) }.getOrNull()
            ui.post {
                compChecking = false
-                if (cat == null || cat.items.isEmpty()) android.widget.Toast.makeText(activity, "The Nightlies could not be reached", android.widget.Toast.LENGTH_LONG).show()
+                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 }
            }
        }, "components-catalog").start()
@@ -91,8 +91,8 @@ internal class ComponentsMenu(private val activity: android.app.Activity, privat
        Thread({
            val message = runCatching {
                val pkg = ComponentsManager.download(activity, item) { pc -> ui.post { if (compDownloads.containsKey(item.file)) compDownloads = compDownloads + (item.file to pc) } }
-                "Stored ${pkg.version}"
-            }.getOrElse { e -> "Download failed: ${e.message ?: e.javaClass.simpleName}" }
+                activity.getString(R.string.comp_stored, pkg.version)
+            }.getOrElse { e -> activity.getString(R.string.comp_download_failed, e.message ?: e.javaClass.simpleName) }
            ui.post {
                compDownloads = compDownloads - item.file
                android.widget.Toast.makeText(activity, message, android.widget.Toast.LENGTH_SHORT).show()
@@ -19,6 +19,8 @@ internal class DeckyMenu(private val activity: android.app.Activity, private val
    var deckyChecking by mutableStateOf(false)
    var deckyStage by mutableStateOf<String?>(null)
    var deckyPercent by mutableIntStateOf(-1)
+    /** True while the stage is the plugin's binary download (DeckyManager.downloadingBinary). */
+    var deckyDownloadingBinary by mutableStateOf(false)
    var deckySupervisor by mutableStateOf(false)
    var deckyReleaseRequest = 0

@@ -41,11 +43,11 @@ internal class DeckyMenu(private val activity: android.app.Activity, private val

    fun installDecky(release: DeckyManager.Release) {
        if (deckyStage != null || SessionState.running) return
-        deckyStage = "Starting…"; deckyPercent = -1
+        deckyStage = activity.getString(R.string.store_starting); deckyPercent = -1
        Thread({
            val problem = runCatching {
                DeckyManager.install(activity, release) { label, value -> ui.post { deckyStage = label; deckyPercent = value } }
-            }.getOrElse { error -> "Decky install failed: ${error.message ?: error.javaClass.simpleName}" }
+            }.getOrElse { error -> activity.getString(R.string.decky_install_failed, error.message ?: error.javaClass.simpleName) }
            ui.post {
                deckyStage = null; deckyPercent = -1; deckyInstalled = DeckyManager.installed(activity)
                if (problem != null) android.widget.Toast.makeText(activity, problem, android.widget.Toast.LENGTH_LONG).show()
@@ -55,16 +57,17 @@ internal class DeckyMenu(private val activity: android.app.Activity, private val

    fun importPluginZip(archive: File) {
        if (deckyStage != null || SessionState.running || deckyInstalled == null) return
-        deckyStage = "Starting plugin import…"; deckyPercent = -1
+        deckyStage = activity.getString(R.string.decky_plugin_starting); deckyPercent = -1
        Thread({
            val problem = runCatching {
                DeckyManager.installPluginZip(activity, archive) { label, value ->
-                    ui.post { deckyStage = label; deckyPercent = value }
+                    val binary = DeckyManager.downloadingBinary
+                    ui.post { deckyStage = label; deckyPercent = value; deckyDownloadingBinary = binary }
                }
-            }.getOrElse { error -> "Plugin import failed: ${error.message ?: error.javaClass.simpleName}" }
+            }.getOrElse { error -> activity.getString(R.string.decky_plugin_failed, error.message ?: error.javaClass.simpleName) }
            ui.post {
-                deckyStage = null; deckyPercent = -1
-                val message = problem ?: "Plugin installed. Restart Steam to load it."
+                deckyStage = null; deckyPercent = -1; deckyDownloadingBinary = false
+                val message = problem ?: activity.getString(R.string.decky_plugin_installed)
                android.widget.Toast.makeText(activity, message, android.widget.Toast.LENGTH_LONG).show()
            }
        }, "import-decky-plugin").start()
@@ -37,7 +37,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
    /** The latest Banners-Turnip release as each driver menu offers it (see [refreshReleaseRows]). */
    var linuxDownloads by mutableStateOf<List<com.droiddeck.launcher.ui.DownloadRow>>(emptyList())
    var androidDownloads by mutableStateOf<List<com.droiddeck.launcher.ui.DownloadRow>>(emptyList())
-    var releaseStatus by mutableStateOf("Not checked yet - tap refresh to look for new drivers")
+    // Empty until the first refresh: the activity has no context yet while its fields are made.
+    var releaseStatus by mutableStateOf("")
    var releaseChecking by mutableStateOf(false)
    var canRestoreBundled by mutableStateOf(false)
    /** Asset name -> download percent, while it downloads. */
@@ -57,10 +58,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
    private var autoCheckedThisProcess = false

    fun state() = GpuDriversState(
-        gpuName = gpu.name, gpuFamily = gpu.family.label, soc = gpu.soc, supportText = gpu.supportText,
+        gpuName = gpu.displayName(activity), gpuFamily = gpu.family.label(activity), soc = gpu.soc, supportText = gpu.supportText(activity),
        supported = gpu.support == GpuInfo.Support.TESTED, unsupported = gpu.support == GpuInfo.Support.UNSUPPORTED,
        auto = mode == SessionPrefs.GPU_DRIVERS_AUTO, pairs = pairRows, busy = pairBusy, percent = pairPercent,
-        autoStatus = autoStatus, releaseStatus = releaseStatus, checking = releaseChecking,
+        autoStatus = autoStatus, releaseStatus = releaseStatus.ifEmpty { activity.getString(R.string.drivers_not_checked) }, checking = releaseChecking,
        linuxRows = linuxRows, linuxSelected = linuxSelected, androidRows = androidRows, androidSelected = androidSelected,
        linuxDownloads = linuxDownloads, androidDownloads = androidDownloads, canRestoreBundled = canRestoreBundled,
        activeBundle = activeBundle,
@@ -73,10 +74,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
        fun origin(id: String) = if (TurnipReleases.isDownloaded(activity, id)) DriverRow.DOWNLOADED else DriverRow.IMPORTED
        val bundles = DriverBundle.all(activity)
        fun bundleRow(id: String, linux: Boolean) = bundles.firstOrNull { (if (linux) it.linuxId else it.androidId) == id }?.let {
-            DriverRow(id, it.label, "Android + Linux: sets the ${if (linux) "display" else "runtime"} driver with it", true, DriverRow.BUNDLE)
+            DriverRow(id, it.label, activity.getString(if (linux) R.string.drivers_bundle_sets_display else R.string.drivers_bundle_sets_runtime), true, DriverRow.BUNDLE)
        }
        linuxRows = LinuxVulkanDriver.optionValues(activity).map { id ->
-            if (id.isEmpty()) DriverRow("", "Runtime default", "the Turnip built into the runtime", false)
+            if (id.isEmpty()) DriverRow("", activity.getString(R.string.gpu_runtime_default), activity.getString(R.string.drivers_runtime_builtin), false)
            else bundleRow(id, linux = true) ?: DriverRow(
                id, lm.getDriverName(id),
                listOfNotNull(
@@ -92,8 +93,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
        val auto = td.autoId()
        androidRows = buildList {
            add(DriverRow(
-                TurnipDriver.AUTO, "Auto - picked by GPU",
-                if (auto == "system") "system Vulkan: no bundled build for this GPU" else "${td.displayName(auto)} (bundled)",
+                TurnipDriver.AUTO, activity.getString(R.string.gpu_auto_by_gpu),
+                if (auto == "system") activity.getString(R.string.drivers_system_vulkan) else activity.getString(R.string.drivers_bundled, td.displayName(auto)),
                false,
            ))
            for (id in td.visibleBundled()) add(DriverRow(id, td.displayName(id), td.driverVersion(id), true, DriverRow.BUNDLED))
@@ -109,7 +110,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
    /** One line for the settings row that opens this: "Auto · WinNative · Balanced". */
    fun summary(): String {
        val active = pairRows.firstOrNull { it.active }?.name ?: activeBundle
-        return (if (mode == SessionPrefs.GPU_DRIVERS_AUTO) "Auto" else "Manual") + (active?.let { " · $it" } ?: "")
+        val label = activity.getString(if (mode == SessionPrefs.GPU_DRIVERS_AUTO) R.string.common_auto else R.string.drivers_manual)
+        return active?.let { activity.getString(R.string.drivers_summary, label, it) } ?: label
    }

    /** The pairs the last check found, with what is installed and in use; this GPU's first. */
@@ -125,7 +127,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
            val mb = p.assets.sumOf { it.size } / 1_048_576.0
            PairRow(
                key = p.key, name = p.name, version = p.version,
-                detail = if (!p.complete) "Only one half is published right now" else "%.0f MB for both".format(mb),
+                detail = if (!p.complete) activity.getString(R.string.drivers_half_published) else activity.getString(R.string.drivers_pair_size, mb),
                recommended = p.key == recommended, suits = p.suits(gpu), complete = p.complete,
                installed = displayId != null && linuxId != null,
                active = displayId != null && linuxId != null &&
@@ -153,11 +155,11 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
        if (!force && autoCheckedThisProcess) return
        autoCheckedThisProcess = true
        if (DriverPairs.recommendedKey(gpu, emptyList()) == null) {
-            autoStatus = "No drivers to set: ${gpu.supportText.lowercase()}"
+            autoStatus = activity.getString(R.string.drivers_none_to_set, gpu.supportText(activity).lowercase())
            return
        }
        releaseChecking = true
-        autoStatus = "Checking for the latest drivers…"
+        autoStatus = activity.getString(R.string.drivers_checking_latest)
        Thread({
            val cached = TurnipReleases.cached(activity)
            val stale = cached == null || System.currentTimeMillis() - cached.checkedAt > 24 * 3_600_000L ||
@@ -172,9 +174,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                val pair = pairs.firstOrNull { it.key == key }
                val row = pairRows.firstOrNull { it.key == key }
                when {
-                    row?.active == true -> autoStatus = "Up to date" + (problem?.let { " (couldn't check: $it)" } ?: "")
+                    row?.active == true -> autoStatus = problem?.let { activity.getString(R.string.drivers_up_to_date_check_failed, it) }
+                        ?: activity.getString(R.string.upd_current_status)
                    pair == null || !pair.complete ->
-                        autoStatus = problem?.let { "Couldn't check: $it" } ?: "The recommended drivers aren't published right now"
+                        autoStatus = problem?.let { activity.getString(R.string.upd_couldnt_check, it) } ?: activity.getString(R.string.drivers_recommended_unpublished)
                    else -> installPair(pair, auto = true)
                }
            }
@@ -197,7 +200,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
        if (!pair.complete) return
        pairBusy = pair.key
        pairPercent = 0
-        if (auto) autoStatus = "Downloading ${pair.name} ${pair.version}…"
+        if (auto) autoStatus = activity.getString(R.string.drivers_downloading_pair, pair.name, pair.version)
        Thread({
            val lm = LinuxVulkanDriverManager(activity)
            val td = TurnipDriver(activity)
@@ -217,7 +220,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                    val displayChanged = SessionPrefs.androidDriver(activity) != displayId
                    SessionPrefs.setAndroidDriver(activity, displayId)
                    SessionPrefs.setLinuxDriver(activity, linuxId)
-                    val restart = if (displayChanged && CompositorHost.isStarted) " The display driver applies after DroidDeck restarts." else ""
+                    val restart = displayChanged && CompositorHost.isStarted
                    if (auto) {
                        val previous = SessionPrefs.gpuAutoInstalled(activity)
                        for (id in previous - setOf(displayId, linuxId)) {
@@ -230,14 +233,18 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                            TurnipReleases.forget(activity, id)
                        }
                        SessionPrefs.setGpuAutoInstalled(activity, setOf(displayId, linuxId))
-                        autoStatus = (if (downloaded) "Updated to" else "Switched to") + " ${pair.name} ${pair.version}.$restart"
+                        autoStatus = activity.getString(
+                            if (downloaded) { if (restart) R.string.drivers_updated_to_restart else R.string.drivers_updated_to }
+                            else { if (restart) R.string.drivers_switched_to_restart else R.string.drivers_switched_to },
+                            pair.name, pair.version,
+                        )
                    } else {
-                        android.widget.Toast.makeText(activity, "Using ${pair.name} ${pair.version}.$restart", android.widget.Toast.LENGTH_LONG).show()
+                        android.widget.Toast.makeText(activity, activity.getString(if (restart) R.string.drivers_using_restart else R.string.drivers_using, pair.name, pair.version), android.widget.Toast.LENGTH_LONG).show()
                    }
                }.onFailure { e ->
                    Log.w(TAG, "driver pair ${pair.key}", e)
-                    val why = if (e is IllegalArgumentException) e.message else "Download failed: ${e.message}"
-                    if (auto) autoStatus = why ?: "Download failed"
+                    val why = if (e is IllegalArgumentException) e.message else activity.getString(R.string.comp_download_failed, e.message)
+                    if (auto) autoStatus = why ?: activity.getString(R.string.user_apps_download_failed)
                    else android.widget.Toast.makeText(activity, why, android.widget.Toast.LENGTH_LONG).show()
                }
                refreshDrivers()
@@ -298,7 +305,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                        try {
                            LinuxVulkanDriverManager(activity).installDriver(uri, name)
                        } catch (runtime: IllegalArgumentException) {
-                            throw IllegalArgumentException("Not a driver zip: neither an AdrenoTools driver, a -Linux Turnip nor an Android + Linux bundle")
+                            throw IllegalArgumentException(activity.getString(R.string.drivers_not_a_driver))
                        }
                    }
                }
@@ -307,10 +314,11 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                e.message
            } catch (e: Exception) {
                Log.w(TAG, "driver import", e)
-                "Import failed: ${e.message}"
+                activity.getString(R.string.drivers_import_failed, e.message)
            }
            ui.post {
-                val done = bundle?.let { useBundle(it) } ?: "Imported ${name ?: "driver"}"
+                val done = bundle?.let { useBundle(it) }
+                    ?: name?.let { activity.getString(R.string.comp_imported, it) } ?: activity.getString(R.string.drivers_imported_unnamed)
                android.widget.Toast.makeText(
                    activity, problem ?: done,
                    if (problem != null || bundle != null) android.widget.Toast.LENGTH_LONG else android.widget.Toast.LENGTH_SHORT,
@@ -340,8 +348,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
        val displayChanged = SessionPrefs.androidDriver(activity) != bundle.androidId
        DriverBundle.select(activity, bundle)
        if (mode == SessionPrefs.GPU_DRIVERS_AUTO) setMode(false)
-        return "Using ${bundle.label} as both the runtime and display driver." +
-            if (displayChanged && CompositorHost.isStarted) " The display driver applies after DroidDeck restarts." else ""
+        return activity.getString(
+            if (displayChanged && CompositorHost.isStarted) R.string.drivers_using_bundle_restart else R.string.drivers_using_bundle,
+            bundle.label,
+        )
    }

    /**
@@ -354,7 +364,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
        if (bundle != null) {
            DriverBundle.remove(activity, bundle)
            TurnipReleases.forget(activity, bundle.id)
-            android.widget.Toast.makeText(activity, "Deleted ${bundle.label} (both drivers)", android.widget.Toast.LENGTH_SHORT).show()
+            android.widget.Toast.makeText(activity, activity.getString(R.string.drivers_deleted_bundle, bundle.label), android.widget.Toast.LENGTH_SHORT).show()
            refreshDrivers()
            return
        }
@@ -367,7 +377,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
            if (SessionPrefs.androidDriver(activity) == id) SessionPrefs.setAndroidDriver(activity, TurnipDriver.AUTO)
        }
        TurnipReleases.forget(activity, id)
-        android.widget.Toast.makeText(activity, "Deleted ${id}", android.widget.Toast.LENGTH_SHORT).show()
+        android.widget.Toast.makeText(activity, activity.getString(R.string.drivers_deleted, id), android.widget.Toast.LENGTH_SHORT).show()
        refreshDrivers()
    }

@@ -378,26 +388,28 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
            .filter { it.bundle || it.linux == linux }
            .filter { a -> installedIdOf(a) == null }
            .map { a ->
-                val mb = "%.1f MB".format(a.size / 1_048_576.0)
+                val mb = activity.getString(R.string.common_size_mb, a.size / 1_048_576.0)
                com.droiddeck.launcher.ui.DownloadRow(a.name, "${a.source} ${a.tag}", "${a.label} · $mb", releaseProgress[a.name])
            }
        linuxDownloads = rows(linux = true)
        androidDownloads = rows(linux = false)
        if (!releaseChecking) releaseStatus = when (check) {
-            null -> "Not checked yet - tap refresh to look for new drivers"
-            else -> "Latest: " + check.latest.joinToString(" · ") { "${it.first} ${it.second}" } +
-                (if (check.failed.isEmpty()) "" else " · ${check.failed.joinToString()} unreachable") +
-                " · checked ${ago(check.checkedAt)}"
+            null -> activity.getString(R.string.drivers_not_checked)
+            else -> {
+                val latest = check.latest.joinToString(" · ") { "${it.first} ${it.second}" }
+                if (check.failed.isEmpty()) activity.getString(R.string.drivers_release_status, latest, ago(check.checkedAt))
+                else activity.getString(R.string.drivers_release_status_failed, latest, check.failed.joinToString(), ago(check.checkedAt))
+            }
        }
    }

    private fun ago(t: Long): String {
        val m = ((System.currentTimeMillis() - t) / 60_000).coerceAtLeast(0)
        return when {
-            m < 1 -> "just now"
-            m < 60 -> "$m min ago"
-            m < 48 * 60 -> "${m / 60} h ago"
-            else -> "${m / (24 * 60)} days ago"
+            m < 1 -> activity.getString(R.string.upd_just_now)
+            m < 60 -> activity.resources.getQuantityString(R.plurals.drivers_ago_minutes, m.toInt(), m)
+            m < 48 * 60 -> activity.resources.getQuantityString(R.plurals.drivers_ago_hours, (m / 60).toInt(), m / 60)
+            else -> activity.resources.getQuantityString(R.plurals.drivers_ago_days, (m / (24 * 60)).toInt(), m / (24 * 60))
        }
    }

@@ -405,16 +417,16 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
    fun checkLatestTurnip() {
        if (releaseChecking) return
        releaseChecking = true
-        releaseStatus = "Checking Banners-Turnip, WinNative and DroidDeck…"
+        releaseStatus = activity.getString(R.string.drivers_checking_sources)
        Thread({
            val problem = try { TurnipReleases.refresh(activity); null } catch (e: Exception) {
-                Log.w(TAG, "latest Turnip check", e); e.message ?: "check failed"
+                Log.w(TAG, "latest Turnip check", e); e.message ?: activity.getString(R.string.drivers_check_failed)
            }
            ui.post {
                releaseChecking = false
                refreshReleaseRows()
                refreshPairs()
-                if (problem != null) releaseStatus = "Couldn't check: $problem"
+                if (problem != null) releaseStatus = activity.getString(R.string.upd_couldnt_check, problem)
            }
        }, "turnip-release-check").start()
    }
@@ -433,13 +445,16 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl
                e.message
            } catch (e: Exception) {
                Log.w(TAG, "release driver download", e)
-                "Download failed: ${e.message}"
+                activity.getString(R.string.comp_download_failed, e.message)
            }
            ui.post {
                releaseProgress.remove(assetName)
-                val pick = if (asset.bundle) "pick it in either list to set both drivers" else "pick it in the menu"
+                val installed = activity.getString(
+                    if (asset.bundle) R.string.drivers_installed_pick_either else R.string.drivers_installed_pick,
+                    asset.name.removeSuffix(".zip"),
+                )
                android.widget.Toast.makeText(
-                    activity, problem ?: "Installed ${asset.name.removeSuffix(".zip")} - $pick",
+                    activity, problem ?: installed,
                    android.widget.Toast.LENGTH_LONG,
                ).show()
                refreshDrivers()
@@ -7,8 +7,14 @@ import com.droiddeck.launcher.session.SessionService

 /** Receives the system Home launch and routes it without consuming KEYCODE_HOME. */
 class HomeActivity : Activity() {
+    override fun attachBaseContext(newBase: android.content.Context) {
+        super.attachBaseContext(newBase)
+        com.droiddeck.launcher.core.AppLanguage.applyTo(this, newBase)
+    }
+
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
+        requestedOrientation = com.droiddeck.launcher.session.SessionPrefs.orientation(this)
        routeHome()
    }

@@ -24,7 +24,7 @@ internal class ProtonMenu(private val activity: android.app.Activity, private va
        if (protonBusyId != null || SessionState.running) return
        ProtonExtras.unqueue(activity, tool)
        protonBusyId = id
-        protonStage = "Starting…"
+        protonStage = activity.getString(R.string.store_starting)
        protonPercent = -1
        Thread({
            val problem = ProtonExtras.install(activity, tool) { label, value ->
@@ -44,7 +44,7 @@ internal class ProtonMenu(private val activity: android.app.Activity, private va
        val tool = ProtonExtras.tools.firstOrNull { it.id == id } ?: return
        if (protonBusyId != null || SessionState.running) return
        protonBusyId = id
-        protonStage = "Removing ${tool.name}…"
+        protonStage = activity.getString(R.string.main_removing_named, tool.name)
        protonPercent = -1
        Thread({
            ProtonExtras.remove(activity, tool)
@@ -46,7 +46,7 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl
        onAllowInstalls = {
            askPermission = false
            runCatching { activity.startActivity(SelfInstaller.permissionIntent(activity)) }
-                .onFailure { error = "Couldn't open Android's \"Install unknown apps\" setting"; pending = null }
+                .onFailure { error = activity.getString(R.string.upd_unknown_apps_failed); pending = null }
        },
        onDismissPermission = { askPermission = false; pending = null },
    )
@@ -77,7 +77,7 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl
                    catalog = it
                    follow = AppUpdates.follow(activity, it)
                    error = null
-                }.onFailure { if (force) error = "Couldn't check: ${it.message ?: it.javaClass.simpleName}" }
+                }.onFailure { if (force) error = activity.getString(R.string.upd_couldnt_check, it.message ?: it.javaClass.simpleName) }
            }
        }, "app-updates").start()
    }
@@ -90,20 +90,20 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl

    private fun install(r: AppUpdates.Release) {
        if (stage != null) return
-        val apk = r.apk ?: run { error = "This build has no download for this copy of DroidDeck"; return }
-        AppUpdates.installBlock(r)?.let { error = it; return }
-        if (SessionState.running) { error = "Stop the running session first, then update"; return }
+        val apk = r.apk ?: run { error = activity.getString(R.string.upd_no_download); return }
+        AppUpdates.installBlock(r)?.let { error = it.message(activity); return }
+        if (SessionState.running) { error = activity.getString(R.string.upd_stop_first); return }
        if (!SelfInstaller.canInstall(activity)) { pending = r; askPermission = true; return }
        error = null
-        stage = "Downloading"
+        stage = activity.getString(R.string.upd_stage_downloading)
        percent = 0
        Thread({
            val result = runCatching {
                val file = SelfInstaller.download(activity, apk) { pct -> ui.post { percent = pct } }
-                ui.post { stage = "Installing"; percent = -1 }
+                ui.post { stage = activity.getString(R.string.upd_stage_installing); percent = -1 }
                SelfInstaller.install(activity, file)
            }
-            result.onFailure { e -> ui.post { stage = null; error = e.message ?: "The update failed" } }
+            result.onFailure { e -> ui.post { stage = null; error = e.message ?: activity.getString(R.string.upd_failed) } }
        }, "app-update-install").start()
    }

@@ -114,14 +114,14 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl
                PackageInstaller.STATUS_PENDING_USER_ACTION -> {
                    val confirm = if (Build.VERSION.SDK_INT >= 33) intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java)
                    else @Suppress("DEPRECATION") intent.getParcelableExtra(Intent.EXTRA_INTENT)
-                    if (confirm == null) { stage = null; error = "Android didn't offer to install the update"; return }
-                    stage = "Waiting for you to confirm"
+                    if (confirm == null) { stage = null; error = activity.getString(R.string.upd_not_offered); return }
+                    stage = activity.getString(R.string.upd_stage_confirm)
                    activity.startActivity(confirm.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK))
                }
                PackageInstaller.STATUS_SUCCESS -> stage = null
                else -> {
                    stage = null
-                    error = SelfInstaller.describeFailure(status, intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE))
+                    error = SelfInstaller.describeFailure(activity, status, intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE))
                }
            }
        }
@@ -0,0 +1,48 @@
+package com.droiddeck.launcher.agent
+
+import android.content.Context
+
+/**
+ * Who may run code through the agent bridge. Reading state, starting and stopping sessions,
+ * launching and quitting games and sending input only need the shell (the provider's DUMP
+ * permission). Running commands in the guest, evaluating JavaScript in the Steam client, session
+ * environment, binary overrides and preference writes reach inside the app's sandbox - the guest
+ * holds the Steam login - which the shell of a stock device otherwise cannot. They require
+ * Setup > Session > Debugging tools to be on, in every build. The bridge itself cannot turn it on.
+ */
+object AgentAccess {
+    const val MAX_REQUEST_CHARS = 256 * 1024
+    private const val PREFS = "agent"
+    private const val KEY_COMMANDS = "commands"
+
+    /** The preferences file the bridge must never write: set-pref refuses it. */
+    const val PROTECTED_PREFS = PREFS
+
+    fun commandsAllowed(context: Context): Boolean =
+        prefs(context).getBoolean(KEY_COMMANDS, false)
+
+    /** The Setup toggle's own state. */
+    fun commandsEnabled(context: Context): Boolean = prefs(context).getBoolean(KEY_COMMANDS, false)
+
+    fun setCommandsEnabled(context: Context, enabled: Boolean) {
+        prefs(context).edit().putBoolean(KEY_COMMANDS, enabled).apply()
+        if (!enabled) runCatching { AgentEnv.revoke(context) }
+            .onFailure { android.util.Log.w("AgentAccess", "Could not finish clearing debugging experiments") }
+    }
+
+    fun requireCommands(context: Context) {
+        if (!commandsAllowed(context)) throw AgentException(
+            "AGENT_COMMANDS_DISABLED",
+            "Debugging tools are off: turn on Setup > Session > Debugging tools on the device",
+        )
+    }
+
+    fun requireStart(context: Context, request: org.json.JSONObject) {
+        if (request.optString("mode") == "run") requireCommands(context)
+    }
+
+    private fun prefs(context: Context) = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+}
+
+/** A refusal with a stable code, answered as {"ok": false, "error": {code, message}}. */
+class AgentException(val code: String, message: String) : RuntimeException(message)
@@ -0,0 +1,288 @@
+package com.droiddeck.launcher.agent
+
+import com.droiddeck.launcher.session.SessionPaths
+import android.Manifest
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.database.Cursor
+import android.net.Uri
+import android.os.Binder
+import android.os.Bundle
+import android.os.Process
+import android.util.Base64
+import com.droiddeck.launcher.BuildConfig
+import com.droiddeck.launcher.frontend.GameLaunchLink
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.runtime.LinuxRuntimeInstaller
+import com.droiddeck.launcher.session.SessionArtifacts
+import com.droiddeck.launcher.session.SessionEvents
+import com.droiddeck.launcher.session.SessionPhase
+import com.droiddeck.launcher.session.SessionService
+import com.droiddeck.launcher.session.SessionState
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+/**
+ * The shell's control surface (docs/agent-control.md), in every build: the provider and its start
+ * Activity need android.permission.DUMP, held by the shell and privileged or explicitly granted callers. Commands that
+ * reach into the app's sandbox are further gated by [AgentAccess].
+ *
+ * A method's request is JSON, base64-encoded in the "request" extra; every answer is JSON in the
+ * "json" key of the returned Bundle, {"ok": true, ...} or {"ok": false, "error": {code, message}}.
+ */
+class AgentBridgeProvider : ContentProvider() {
+    override fun onCreate(): Boolean {
+        val appContext = context?.applicationContext ?: return false
+        Thread({
+            try {
+                SessionArtifacts.finishAbandoned(appContext)
+            } finally {
+                recoveryComplete.countDown()
+            }
+        }, "agent-recover-artifacts").start()
+        return true
+    }
+
+    override fun call(method: String, arg: String?, extras: Bundle?): Bundle {
+        val context = requireNotNull(context)
+        if (Binder.getCallingUid() != Process.myUid() &&
+            context.checkCallingPermission(Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED
+        ) {
+            throw SecurityException("android.permission.DUMP is required")
+        }
+
+        val response = try {
+            val request = decode(extras?.getString(EXTRA_REQUEST))
+            // Binder identity is the shell's; everything below acts as the app.
+            val token = Binder.clearCallingIdentity()
+            try {
+                dispatch(context, method, request)
+            } finally {
+                Binder.restoreCallingIdentity(token)
+            }
+        } catch (e: AgentException) {
+            error(e.code, e.message ?: e.code)
+        } catch (e: Exception) {
+            error("COMMAND_FAILED", e.message ?: e.javaClass.simpleName)
+        }
+        val json = response.toString().let {
+            if (it.length <= 384 * 1024) it else error("RESPONSE_TOO_LARGE", "Reduce the command output or select fewer fields").toString()
+        }
+        return Bundle().apply { putString(RESULT_JSON, json) }
+    }
+
+    private fun dispatch(context: Context, method: String, request: JSONObject): JSONObject = when (method) {
+        "state" -> state(context).put("ok", true)
+        "start" -> error("USE_DROIDDECKCTL", "Start sessions with tools/droiddeckctl so Android launches a visible Activity")
+        "stop" -> stop(context)
+        "resume" -> resume(context)
+        "launch" -> launch(context, request)
+        "focus" -> guest(context, JSONObject().put("kind", "focus"), 15_000)
+        "quit" -> guest(context, JSONObject().put("kind", "quit").put("appId", request.opt("appId"))
+            .put("timeout", request.optDouble("timeout", 15.0)), timeoutMs(request, 15.0, 30_000))
+        "input" -> AgentInput.handle(request)
+        "ui" -> AgentUi.handle(request)
+        "guest" -> {
+            AgentAccess.requireCommands(context)
+            guest(context, JSONObject(request.toString()).put("kind", "exec"), timeoutMs(request, 30.0, 10_000))
+        }
+        "cdp" -> {
+            AgentAccess.requireCommands(context)
+            guest(context, JSONObject(request.toString()).put("kind", "cdp"), timeoutMs(request, 15.0, 5_000))
+        }
+        "env" -> env(context, request)
+        "override" -> {
+            AgentAccess.requireCommands(context)
+            AgentEnv.override(context, request.optString("name")).put("ok", true).put("command", "override")
+        }
+        "prefs" -> prefs(context, request)
+        "access" -> JSONObject().put("ok", true).put("commands", AgentAccess.commandsAllowed(context))
+            .put("debugBuild", BuildConfig.DEBUG).put("inbox", AgentEnv.inbox(context).absolutePath)
+        else -> error("UNKNOWN_COMMAND", "Unknown agent command '$method'")
+    }
+
+    private fun state(context: Context): JSONObject {
+        val runtimeVersion = LinuxRuntimeInstaller.installedVersion(context)
+        val dir = SessionState.logDirectory ?: SessionState.logFile?.parentFile ?: SessionPaths.sessionFolders(context).lastOrNull()
+        val session = JSONObject()
+            .put("id", SessionState.sessionId ?: dir?.name ?: JSONObject.NULL)
+            .put("phase", SessionState.phase.name)
+            .put("running", SessionState.running)
+            .put("mode", SessionState.mode)
+            .put("program", SessionState.program ?: JSONObject.NULL)
+            .put("steamUi", SessionState.steamUi ?: JSONObject.NULL)
+            .put("steamUrl", SessionState.steamUrl ?: JSONObject.NULL)
+            .put("suspended", SessionState.suspended)
+            .put("pip", SessionState.pipActive)
+            .put("firstFrame", SessionState.firstFrameSeen)
+            .put("output", JSONArray().put(SessionState.outputSize.first).put(SessionState.outputSize.second))
+            .put("refreshHz", SessionState.refreshHz.toDouble())
+            .put("lastTransitionAt", SessionState.lastTransitionAt)
+            .put("guestPid", SessionState.guestPid.takeIf { it > 1 } ?: JSONObject.NULL)
+            .put("installing", SessionState.installing ?: JSONObject.NULL)
+            .put("logDir", dir?.absolutePath ?: JSONObject.NULL)
+            .put("eventsFile", dir?.let { File(it, "events.jsonl").absolutePath } ?: JSONObject.NULL)
+            .put("artifactsAvailable", dir?.isDirectory ?: false)
+            .put("artifactsComplete", dir?.let { File(it, ".complete").isFile } ?: false)
+
+        val failure = if (SessionState.failureCode == null) JSONObject.NULL else JSONObject()
+            .put("code", SessionState.failureCode)
+            .put("message", SessionState.failureMessage ?: JSONObject.NULL)
+            .put("status", SessionState.failureStatus ?: JSONObject.NULL)
+        session.put("failure", failure)
+
+        // gamescope's focus as last published by the guest agent, without the window lists
+        // (the focus command returns those, fresh).
+        val focus = AgentGuest.focus(context)?.let { snap ->
+            JSONObject()
+                .put("focusedApp", snap.opt("focusedApp") ?: JSONObject.NULL)
+                .put("focusedWindow", snap.opt("focusedWindow") ?: JSONObject.NULL)
+                .put("focusableApps", snap.optJSONArray("focusableApps") ?: JSONArray())
+                .put("baselayerAppIds", snap.optJSONArray("baselayerAppIds") ?: JSONArray())
+                .put("seq", snap.optInt("seq"))
+                .put("t", snap.optLong("t"))
+        }
+        session.put("focus", focus ?: JSONObject.NULL)
+
+        val hello = AgentGuest.hello(context)
+        return JSONObject()
+            .put("schema", SCHEMA)
+            .put("build", BuildConfig.BUILD_LABEL)
+            .put("appVersion", context.packageManager.getPackageInfo(context.packageName, 0).versionName)
+            .put("runtime", JSONObject()
+                .put("installed", LinuxRuntime.isInstalled(context))
+                .put("version", runtimeVersion ?: JSONObject.NULL))
+            .put("agent", JSONObject()
+                .put("guest", hello != null)
+                .put("guestFocus", hello?.optBoolean("focus") ?: false)
+                .put("commands", AgentAccess.commandsAllowed(context)))
+            .put("session", session)
+    }
+
+    private fun stop(context: Context): JSONObject {
+        if (SessionState.running) {
+            SessionService.stop(context)
+            return JSONObject().put("ok", true).put("command", "stop")
+        }
+        if (SessionState.phase == SessionPhase.STOPPING) {
+            return JSONObject().put("ok", true).put("command", "stop")
+        }
+        if (SessionState.phase in STARTING_PHASES) {
+            SessionState.stopRequested = true
+            SessionEvents.transition(SessionPhase.STOPPING, "session.stop_requested")
+            return JSONObject().put("ok", true).put("command", "stop")
+        }
+        return error("NO_ACTIVE_SESSION", "There is no session to stop")
+    }
+
+    private fun resume(context: Context): JSONObject {
+        if (!SessionState.running || !SessionState.suspended) {
+            return error("SESSION_NOT_SUSPENDED", "There is no suspended session to resume")
+        }
+        SessionService.resume(context)
+        return JSONObject().put("ok", true).put("command", "resume")
+    }
+
+    private fun launch(context: Context, request: JSONObject): JSONObject {
+        val appId = request.optString("appId")
+        if (!GameLaunchLink.validId(appId)) throw AgentException("INVALID_APP_ID", "appId must be a decimal Steam app id")
+        if (!SessionState.running || SessionState.mode != SessionService.MODE_STEAM) {
+            throw AgentException("NO_STEAM_SESSION", "Games launch inside a running Steam session")
+        }
+        if (!SessionService.launchGame(context, appId)) throw AgentException("LAUNCH_REJECTED", "The session did not accept the launch")
+        SessionEvents.record("agent.launch_requested", mapOf("appId" to appId))
+        return JSONObject().put("ok", true).put("command", "launch").put("appId", appId)
+    }
+
+    private fun env(context: Context, request: JSONObject): JSONObject {
+        AgentAccess.requireCommands(context)
+        val result = when (val op = request.optString("op", "list")) {
+            "list" -> AgentEnv.list(context)
+            "set" -> {
+                val lines = request.optJSONArray("lines") ?: JSONArray()
+                AgentEnv.set(context, List(lines.length()) { lines.optString(it) }, request.optBoolean("persistent"))
+            }
+            "clear" -> AgentEnv.clear(context, request.optString("scope", "next"))
+            else -> throw AgentException("INVALID_REQUEST", "env op '$op' is not list, set or clear")
+        }
+        return result.put("ok", true).put("command", "env")
+    }
+
+    private fun prefs(context: Context, request: JSONObject): JSONObject {
+        AgentAccess.requireCommands(context)
+        val file = request.optString("file")
+        val result = when (val op = request.optString("op", "get")) {
+            "get" -> AgentPrefs.get(context, file)
+            "set" -> AgentPrefs.set(context, file, request.optString("key"), request.optString("type", "string"),
+                if (request.isNull("value")) null else request.optString("value"))
+            else -> throw AgentException("INVALID_REQUEST", "prefs op '$op' is not get or set")
+        }
+        return result.put("ok", true).put("command", "prefs")
+    }
+
+    /** A guest agent request; its own answer already carries ok or error. */
+    private fun guest(context: Context, request: JSONObject, timeoutMs: Long): JSONObject =
+        AgentGuest.call(context, request, timeoutMs)
+
+    /** The guest's own timeout plus slack for the round trip. */
+    private fun timeoutMs(request: JSONObject, defaultSeconds: Double, slackMs: Long): Long {
+        val seconds = if (request.has("timeout")) request.opt("timeout")?.toString()?.toDoubleOrNull()
+            ?: throw AgentException("INVALID_REQUEST", "timeout must be a number") else defaultSeconds
+        if (!seconds.isFinite() || seconds <= 0 || seconds > 600) {
+            throw AgentException("INVALID_REQUEST", "timeout must be a positive number no greater than 600 seconds")
+        }
+        return (seconds * 1000).toLong() + slackMs
+    }
+
+    private fun decode(encoded: String?): JSONObject {
+        if (encoded.isNullOrBlank()) return JSONObject()
+        if (encoded.length > AgentAccess.MAX_REQUEST_CHARS) throw AgentException("INVALID_REQUEST", "The encoded request exceeds 256 KiB")
+        return try {
+            JSONObject(String(Base64.decode(encoded, Base64.DEFAULT), Charsets.UTF_8))
+        } catch (e: Exception) {
+            throw AgentException("INVALID_REQUEST", "The request extra is not base64 JSON")
+        }
+    }
+
+    private fun error(code: String, message: String) = JSONObject()
+        .put("ok", false)
+        .put("error", JSONObject().put("code", code).put("message", message))
+
+    override fun query(uri: Uri, projection: Array<out String>?, selection: String?, selectionArgs: Array<out String>?, sortOrder: String?): Cursor? = null
+    override fun getType(uri: Uri): String? = null
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+    override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?): Int = 0
+
+    companion object {
+        const val RESULT_JSON = "json"
+        const val EXTRA_REQUEST = "request"
+        /** 2 added agent and session.focus; everything in 1 is unchanged. */
+        const val SCHEMA = 2
+        private val recoveryComplete = CountDownLatch(1)
+
+        fun awaitRecovery() {
+            try {
+                if (!recoveryComplete.await(90, TimeUnit.SECONDS)) {
+                    throw IllegalStateException("Session artifact recovery did not finish")
+                }
+            } catch (e: InterruptedException) {
+                Thread.currentThread().interrupt()
+                throw IllegalStateException("Interrupted while recovering session artifacts", e)
+            }
+        }
+
+        private val STARTING_PHASES = setOf(
+            SessionPhase.PREPARING,
+            SessionPhase.INSTALLING_RUNTIME,
+            SessionPhase.STARTING_COMPOSITOR,
+            SessionPhase.STARTING_GUEST,
+            SessionPhase.STARTING_STEAM,
+        )
+    }
+}
@@ -0,0 +1,222 @@
+package com.droiddeck.launcher.agent
+
+import android.content.Context
+import android.util.Log
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.LinkOption.NOFOLLOW_LINKS
+import java.nio.file.StandardOpenOption.READ
+
+/**
+ * Experiment switches an agent sets without touching Download/droiddeck-env or rebuilding the apk:
+ *
+ * - environment lines (KEY=VALUE) for the session, applied after the user's own droiddeck-env, so
+ *   they win. "next" lines are taken by the next session that starts and dropped when it ends;
+ *   "persistent" ones stay until cleared.
+ * - binary overrides: a file pushed to the app's external files (agent-inbox/<name>) is installed
+ *   as /opt/droiddeck-agent/bin/<name> in the rootfs and put first on the next session's PATH -
+ *   a gamescope build under test, say. Removed when that session ends.
+ *
+ * Kept in the app's own files (agent-env.json), never in a place the shell can write.
+ */
+object AgentEnv {
+    private const val TAG = "AgentEnv"
+    private const val FILE = "agent-env.json"
+    private const val GUEST_BIN = "/opt/droiddeck-agent/bin"
+    private const val BASE_PATH = "/usr/local/bin:/usr/bin:/bin"
+    private val NAME = Regex("[A-Za-z0-9._-]{1,64}")
+    private val KEY = Regex("[A-Za-z_][A-Za-z0-9_]*")
+    private val lock = Any()
+
+    fun inbox(context: Context): File = File(context.getExternalFilesDir(null), "agent-inbox")
+
+    fun list(context: Context): JSONObject = synchronized(lock) {
+        AgentAccess.requireCommands(context)
+        load(context)
+    }
+
+    /** Add [lines] for the next session ([persistent] = every session until cleared). */
+    fun set(context: Context, lines: List<String>, persistent: Boolean): JSONObject = synchronized(lock) {
+        AgentAccess.requireCommands(context)
+        if (lines.any { line -> KEY.matchEntire(line.substringBefore('=', "")) == null || !line.contains('=') || line.any { it == '\n' || it == '\r' || it == '\u0000' } }) {
+            throw AgentException("INVALID_ENV", "Environment entries must be single KEY=VALUE lines without NUL bytes")
+        }
+        val state = load(context)
+        val key = if (persistent) "persistent" else "pending"
+        val merged = merge(strings(state.optJSONArray(key)), lines)
+        state.put(key, JSONArray(merged))
+        save(context, state)
+        state
+    }
+
+    /** Drop lines: [scope] is "next", "persistent" or "all". */
+    fun clear(context: Context, scope: String): JSONObject = synchronized(lock) {
+        AgentAccess.requireCommands(context)
+        val state = load(context)
+        when (scope) {
+            "next" -> state.put("pending", JSONArray())
+            "persistent" -> state.put("persistent", JSONArray())
+            "all" -> { state.put("pending", JSONArray()); state.put("persistent", JSONArray()); state.put("pendingOverrides", JSONArray()) }
+            else -> throw AgentException("INVALID_SCOPE", "Scope must be next, persistent or all")
+        }
+        save(context, state)
+        state
+    }
+
+    /** Install agent-inbox/[name] as an override for the next session. */
+    fun override(context: Context, name: String): JSONObject = synchronized(lock) {
+        AgentAccess.requireCommands(context)
+        if (NAME.matchEntire(name) == null || name in setOf(".", "..")) throw AgentException("INVALID_NAME", "Override names are letters, digits, '.', '_' and '-'")
+        val source = File(inbox(context), name)
+        if (Files.isSymbolicLink(source.toPath())) throw AgentException("INVALID_NAME", "The override must be a regular file")
+        if (!source.isFile) throw AgentException("NO_SUCH_FILE", "Push the binary to ${source.path} first")
+        val target = File(bin(context), name)
+        target.parentFile?.mkdirs()
+        val staged = File.createTempFile("override-", ".tmp", target.parentFile)
+        try {
+            Files.newInputStream(source.toPath(), READ, NOFOLLOW_LINKS).use { input -> staged.outputStream().use { input.copyTo(it) } }
+        } catch (e: Exception) {
+            staged.delete()
+            throw AgentException("OVERRIDE_FAILED", "Could not stage the override")
+        }
+        if (!staged.setExecutable(true, false) || !staged.renameTo(target)) {
+            staged.delete()
+            throw AgentException("OVERRIDE_FAILED", "Could not install $name in the rootfs")
+        }
+        source.delete()
+        val state = load(context)
+        state.put("pendingOverrides", JSONArray(merge(strings(state.optJSONArray("pendingOverrides")), listOf(name))))
+        save(context, state)
+        state.put("installed", "$GUEST_BIN/$name")
+    }
+
+    /**
+     * At session start: the lines this session gets, after the user's droiddeck-env. Pending lines
+     * and overrides become this session's own, to be dropped by [endSession].
+     */
+    fun beginSession(context: Context): List<String> = synchronized(lock) {
+        if (!AgentAccess.commandsAllowed(context)) {
+            revoke(context)
+            return@synchronized emptyList()
+        }
+        val state = load(context)
+        val active = strings(state.optJSONArray("pending"))
+        val overrides = strings(state.optJSONArray("pendingOverrides"))
+        state.put("active", JSONArray(active)).put("pending", JSONArray())
+        state.put("activeOverrides", JSONArray(overrides)).put("pendingOverrides", JSONArray())
+        save(context, state)
+        // Anything else there was left by a session that never reached endSession (the app died).
+        bin(context).listFiles()
+            ?.filter { it.name !in overrides }?.forEach { it.delete() }
+        val lines = strings(state.optJSONArray("persistent")) + active
+        val withPath = if (overrides.isEmpty()) lines else lines + "PATH=$GUEST_BIN:${pathOf(lines)}"
+        if (withPath.isNotEmpty()) Log.i(TAG, "agent environment keys for this session: ${withPath.map { it.substringBefore('=') }}")
+        withPath
+    }
+
+    fun revoke(context: Context) = synchronized(lock) {
+        val state = load(context)
+        for (key in listOf("pending", "active", "persistent", "pendingOverrides", "activeOverrides")) state.put(key, JSONArray())
+        save(context, state)
+        bin(context).listFiles()?.forEach { it.delete() }
+    }
+
+    /** At session end: this session's lines and override binaries go. */
+    fun endSession(context: Context) = synchronized(lock) {
+        val state = load(context)
+        val overrides = strings(state.optJSONArray("activeOverrides"))
+        val pending = strings(state.optJSONArray("pendingOverrides"))
+        val bin = bin(context)
+        overrides.filter { it !in pending }.forEach { File(bin, it).delete() }
+        state.put("active", JSONArray()).put("activeOverrides", JSONArray())
+        save(context, state)
+    }
+
+    /** A PATH= line among [lines] (the user's or an agent's) is extended rather than replaced. */
+    private fun pathOf(lines: List<String>) =
+        lines.lastOrNull { it.startsWith("PATH=") }?.substringAfter('=')?.takeIf { it.isNotBlank() } ?: BASE_PATH
+
+    private fun bin(context: Context): File {
+        val root = LinuxRuntime.rootDir(context).canonicalFile.toPath()
+        val directory = root.resolve(GUEST_BIN.removePrefix("/"))
+        var path = directory
+        while (path != root) {
+            if (Files.isSymbolicLink(path)) throw AgentException("OVERRIDE_FAILED", "The override directory must not contain symbolic links")
+            path = path.parent
+        }
+        return directory.toFile()
+    }
+
+    private fun merge(existing: List<String>, added: List<String>): List<String> {
+        val keys = added.map { it.substringBefore('=') }.toSet()
+        return existing.filter { it.substringBefore('=') !in keys } + added
+    }
+
+    private fun strings(array: JSONArray?): List<String> =
+        if (array == null) emptyList() else List(array.length()) { array.optString(it) }.filter { it.isNotEmpty() }
+
+    private fun load(context: Context): JSONObject {
+        val file = File(context.filesDir, FILE)
+        val state = try { if (file.isFile) JSONObject(file.readText()) else JSONObject() } catch (e: Exception) { JSONObject() }
+        for (key in listOf("pending", "active", "persistent", "pendingOverrides", "activeOverrides")) {
+            if (!state.has(key)) state.put(key, JSONArray())
+        }
+        return state
+    }
+
+    private fun save(context: Context, state: JSONObject) {
+        val file = File(context.filesDir, FILE)
+        val staged = File(context.filesDir, "$FILE.tmp")
+        staged.writeText(state.toString())
+        if (!staged.renameTo(file)) {
+            staged.delete()
+            throw AgentException("ENV_WRITE_FAILED", "Could not save the debugging environment")
+        }
+    }
+}
+
+/** Typed writes to the app's SharedPreferences, for driving a settings matrix without the UI. */
+object AgentPrefs {
+    fun set(context: Context, file: String, key: String, type: String, value: String?): JSONObject {
+        AgentAccess.requireCommands(context)
+        validateFile(file)
+        if (file == AgentAccess.PROTECTED_PREFS) throw AgentException("PROTECTED_PREFS", "The agent preferences are set on the device only")
+        if (file.isBlank() || key.isBlank()) throw AgentException("INVALID_PREF", "file and key are required")
+        val prefs = context.getSharedPreferences(file, Context.MODE_PRIVATE)
+        val previous = prefs.all[key]
+        val editor = prefs.edit()
+        try {
+            when (type) {
+                "remove" -> editor.remove(key)
+                "bool" -> editor.putBoolean(key, value?.toBooleanStrictOrNull() ?: throw NumberFormatException("not true/false"))
+                "int" -> editor.putInt(key, value!!.toInt())
+                "long" -> editor.putLong(key, value!!.toLong())
+                "float" -> editor.putFloat(key, value!!.toFloat())
+                "string" -> editor.putString(key, value ?: "")
+                else -> throw AgentException("INVALID_PREF", "type must be bool, int, long, float, string or remove")
+            }
+        } catch (e: RuntimeException) {
+            if (e is AgentException) throw e
+            throw AgentException("INVALID_PREF", "The value is not a $type")
+        }
+        if (!editor.commit()) throw AgentException("PREF_WRITE_FAILED", "Could not write $file/$key")
+        return JSONObject().put("file", file).put("key", key).put("type", type)
+            .put("previous", previous ?: JSONObject.NULL).put("value", prefs.all[key] ?: JSONObject.NULL)
+    }
+
+    fun get(context: Context, file: String): JSONObject {
+        AgentAccess.requireCommands(context)
+        validateFile(file)
+        val all = context.getSharedPreferences(file, Context.MODE_PRIVATE).all
+        return JSONObject().put("file", file).put("values", JSONObject(all.mapValues { it.value ?: JSONObject.NULL }))
+    }
+
+    private fun validateFile(file: String) {
+        if (!Regex("[A-Za-z0-9_-][A-Za-z0-9._-]{0,127}").matches(file)) {
+            throw AgentException("INVALID_PREF", "Preference files must be simple names")
+        }
+    }
+}
@@ -0,0 +1,128 @@
+package com.droiddeck.launcher.agent
+
+import android.content.Context
+import android.os.FileObserver
+import android.util.Log
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.session.SessionEvents
+import com.droiddeck.launcher.session.SessionState
+import org.json.JSONObject
+import java.io.File
+import java.util.UUID
+
+/**
+ * The app's side of the guest agent (tools/linuxfs/overlay/usr/local/bin/droiddeck-agent): requests
+ * go in as files under the session root's agent directory and answers come back the same way, so
+ * whatever runs does so inside the live session with its own environment.
+ */
+object AgentGuest {
+    private const val TAG = "AgentGuest"
+    private const val POLL_MS = 50L
+    private val lock = Any()
+    private var observer: FileObserver? = null
+    private var lastFocusKey: String? = null
+
+    fun dir(context: Context) = File(LinuxRuntime.sessionRoot(context), "agent")
+
+    /**
+     * Before each session: nothing of the last one's daemon, answers or focus may be read as
+     * current. Then watch for the new daemon's hello and focus snapshots, which go into the
+     * session's events.jsonl.
+     */
+    fun reset(context: Context) {
+        synchronized(lock) {
+            observer?.stopWatching()
+            observer = null
+            lastFocusKey = null
+            val dir = dir(context)
+            dir.deleteRecursively()
+            dir.mkdirs()
+            @Suppress("DEPRECATION")
+            observer = object : FileObserver(dir.path, MOVED_TO or CLOSE_WRITE) {
+                override fun onEvent(event: Int, path: String?) {
+                    when (path) {
+                        "hello.json" -> readJson(File(dir, path))?.let {
+                            SessionEvents.record("agent.ready", mapOf("pid" to it.optInt("pid"), "focus" to it.optBoolean("focus")))
+                        }
+                        "focus.json" -> readJson(File(dir, path))?.let(::recordFocus)
+                    }
+                }
+            }.also { it.startWatching() }
+        }
+    }
+
+    /** At the end of a session: no more events for a folder that is being closed. */
+    fun stop() {
+        synchronized(lock) {
+            observer?.stopWatching()
+            observer = null
+        }
+    }
+
+    private fun recordFocus(snapshot: JSONObject) {
+        val fields = linkedMapOf<String, Any?>(
+            "focusedApp" to snapshot.opt("focusedApp"),
+            "focusableApps" to snapshot.optJSONArray("focusableApps")?.toString(),
+            "baselayerAppIds" to snapshot.optJSONArray("baselayerAppIds")?.toString(),
+        )
+        val key = fields.values.joinToString("|")
+        synchronized(lock) {
+            if (key == lastFocusKey) return
+            lastFocusKey = key
+        }
+        SessionEvents.record("focus.changed", fields + ("seq" to snapshot.optInt("seq")))
+    }
+
+    /** The daemon's hello, when it is running in the current session. */
+    fun hello(context: Context): JSONObject? {
+        if (!SessionState.running) return null
+        val hello = readJson(File(dir(context), "hello.json")) ?: return null
+        val pid = hello.optInt("pid", -1)
+        return hello.takeIf { pid > 1 && File("/proc/$pid").exists() }
+    }
+
+    /** The newest focus snapshot the daemon published, when a session is running. */
+    fun focus(context: Context): JSONObject? =
+        if (SessionState.running) readJson(File(dir(context), "focus.json")) else 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)
+        if (!SessionState.running) throw AgentException("NO_ACTIVE_SESSION", "There is no running session")
+        hello(context) ?: throw AgentException("AGENT_UNAVAILABLE", "The guest agent is not running in this session (yet)")
+        val dir = dir(context)
+        val requests = File(dir, "req").apply { mkdirs() }
+        val answers = File(dir, "resp").apply { mkdirs() }
+        val id = UUID.randomUUID().toString()
+        val staged = File(requests, "$id.json.tmp")
+        val published = File(requests, "$id.json")
+        val answer = File(answers, "$id.json")
+        staged.writeText(request.toString())
+        if (!staged.renameTo(published)) {
+            staged.delete()
+            throw AgentException("AGENT_UNAVAILABLE", "Could not hand the request to the guest agent")
+        }
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            if (answer.isFile) {
+                if (answer.length() > 1024 * 1024) {
+                    answer.delete()
+                    throw AgentException("RESPONSE_TOO_LARGE", "The guest response exceeds 1 MiB")
+                }
+                val result = readJson(answer)
+                answer.delete()
+                return result ?: throw AgentException("INVALID_AGENT_RESPONSE", "The guest agent's answer was not JSON")
+            }
+            Thread.sleep(POLL_MS)
+        }
+        published.delete()
+        Log.w(TAG, "no answer to ${request.optString("kind")} in ${timeoutMs}ms")
+        throw AgentException("TIMEOUT", "The guest agent did not answer within ${timeoutMs / 1000}s")
+    }
+
+    private fun readJson(file: File): JSONObject? = try {
+        if (file.isFile && file.length() <= 1024 * 1024) JSONObject(file.readText()) else null
+    } catch (e: Exception) {
+        null
+    }
+}
@@ -0,0 +1,221 @@
+package com.droiddeck.launcher.agent
+
+import com.droiddeck.launcher.input.PadState
+import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.wayland.WaylandCompositor
+import org.json.JSONObject
+
+/**
+ * Input into the running session the way a player gives it: keys and touches through the
+ * compositor (what the session screen sends), and the virtual pad through the same PadBridge the
+ * on-screen controls drive, so games that ignore touch still see a controller.
+ */
+object AgentInput {
+    /** Out of the way of real fingers, which Android numbers from 0. */
+    private const val TOUCH_ID = 9
+    private const val TOUCH_SCALE_X = 1919f
+    private const val TOUCH_SCALE_Y = 1079f
+
+    fun handle(request: JSONObject): JSONObject {
+        if (!SessionState.running || !SessionState.firstFrameSeen) {
+            throw AgentException("SESSION_NOT_READY", "Input needs a running session that has drawn its first frame")
+        }
+        return when (val type = request.optString("type")) {
+            "key" -> key(request)
+            "text" -> text(request)
+            "tap" -> tap(request)
+            "swipe" -> swipe(request)
+            "pad" -> pad(request)
+            "stick" -> stick(request)
+            "trigger" -> trigger(request)
+            else -> throw AgentException("INVALID_INPUT", "Unknown input type '$type'")
+        }.put("ok", true).put("command", "input").put("type", request.optString("type"))
+    }
+
+    private fun key(request: JSONObject): JSONObject {
+        val name = request.optString("key")
+        val code = KEYS[name.uppercase()] ?: name.toIntOrNull()
+            ?: throw AgentException("INVALID_INPUT", "Unknown key '$name' (a name such as ENTER or an evdev code)")
+        val modifiers = request.optJSONArray("modifiers")?.let { array ->
+            List(array.length()) { i ->
+                KEYS[array.optString(i).uppercase()] ?: throw AgentException("INVALID_INPUT", "Unknown modifier '${array.optString(i)}'")
+            }
+        }.orEmpty()
+        when (val action = request.optString("action", "tap")) {
+            "down" -> WaylandCompositor.nativeSendKey(code, 1)
+            "up" -> WaylandCompositor.nativeSendKey(code, 0)
+            "tap" -> {
+                modifiers.forEach { WaylandCompositor.nativeSendKey(it, 1) }
+                WaylandCompositor.nativeSendKey(code, 1)
+                hold(request, 40)
+                WaylandCompositor.nativeSendKey(code, 0)
+                modifiers.asReversed().forEach { WaylandCompositor.nativeSendKey(it, 0) }
+            }
+            else -> throw AgentException("INVALID_INPUT", "Key action '$action' is not tap, down or up")
+        }
+        return JSONObject().put("code", code)
+    }
+
+    /** Typed as key presses (US layout), which reaches X programs that have no text-input support. */
+    private fun text(request: JSONObject): JSONObject {
+        val text = request.optString("text")
+        if (request.optBoolean("commit")) {
+            WaylandCompositor.textInputCommit(text)
+            return JSONObject().put("length", text.length).put("via", "text-input")
+        }
+        val missing = text.filter { TYPED[it] == null }
+        if (missing.isNotEmpty()) throw AgentException("INVALID_INPUT", "Cannot type '${missing.toSet().joinToString("")}' as keys; use commit")
+        val delay = request.optLong("delayMs", 15)
+        for (ch in text) {
+            val (code, shift) = TYPED.getValue(ch)
+            if (shift) WaylandCompositor.nativeSendKey(KEYS.getValue("LEFTSHIFT"), 1)
+            WaylandCompositor.nativeSendKey(code, 1)
+            WaylandCompositor.nativeSendKey(code, 0)
+            if (shift) WaylandCompositor.nativeSendKey(KEYS.getValue("LEFTSHIFT"), 0)
+            Thread.sleep(delay)
+        }
+        return JSONObject().put("length", text.length).put("via", "keys")
+    }
+
+    private fun tap(request: JSONObject): JSONObject {
+        val (x, y) = point(request, "x", "y")
+        WaylandCompositor.nativeSendTouch(0, TOUCH_ID, x, y)
+        hold(request, 60)
+        WaylandCompositor.nativeSendTouch(2, TOUCH_ID, x, y)
+        return JSONObject().put("touch", org.json.JSONArray().put(x).put(y))
+    }
+
+    private fun swipe(request: JSONObject): JSONObject {
+        val (x1, y1) = point(request, "x", "y")
+        val (x2, y2) = point(request, "x2", "y2")
+        val duration = request.optLong("durationMs", 300).coerceIn(16, 10_000)
+        val steps = (duration / 16).toInt().coerceAtLeast(2)
+        WaylandCompositor.nativeSendTouch(0, TOUCH_ID, x1, y1)
+        for (i in 1..steps) {
+            Thread.sleep(duration / steps)
+            WaylandCompositor.nativeSendTouch(1, TOUCH_ID, x1 + (x2 - x1) * i / steps, y1 + (y2 - y1) * i / steps)
+        }
+        WaylandCompositor.nativeSendTouch(2, TOUCH_ID, x2, y2)
+        return JSONObject().put("from", org.json.JSONArray().put(x1).put(y1)).put("to", org.json.JSONArray().put(x2).put(y2))
+    }
+
+    /**
+     * A point in the compositor's touch space (0..1919 x 0..1079 whatever the session's size), from
+     * the session's output pixels (space "output", the default: what the guest draws at) or 0..1
+     * fractions (space "fraction").
+     */
+    private fun point(request: JSONObject, xKey: String, yKey: String): Pair<Int, Int> {
+        if (!request.has(xKey) || !request.has(yKey)) throw AgentException("INVALID_INPUT", "$xKey and $yKey are required")
+        val x = request.getDouble(xKey)
+        val y = request.getDouble(yKey)
+        val (fx, fy) = when (val space = request.optString("space", "output")) {
+            "fraction" -> x to y
+            "output" -> {
+                val (w, h) = SessionState.outputSize
+                x / (w - 1).coerceAtLeast(1) to y / (h - 1).coerceAtLeast(1)
+            }
+            else -> throw AgentException("INVALID_INPUT", "space '$space' is not output or fraction")
+        }
+        return (fx.coerceIn(0.0, 1.0) * TOUCH_SCALE_X).toInt() to (fy.coerceIn(0.0, 1.0) * TOUCH_SCALE_Y).toInt()
+    }
+
+    private fun pad(request: JSONObject): JSONObject {
+        val bridge = SessionState.padBridge ?: throw AgentException("NO_PAD", "The session has no virtual pad")
+        val name = request.optString("button").lowercase()
+        if (name == "qam") {
+            bridge.triggerQam()
+            return JSONObject().put("button", name)
+        }
+        val button = BUTTONS[name]
+        if (button == null && name !in DPAD) throw AgentException("INVALID_INPUT", "Unknown pad button '$name'")
+        val apply = { s: PadState, down: Boolean ->
+            when (name) {
+                "up" -> s.up = down
+                "down" -> s.down = down
+                "left" -> s.left = down
+                "right" -> s.right = down
+                else -> s.press(button!!, down)
+            }
+        }
+        when (val action = request.optString("action", "tap")) {
+            "down" -> bridge.applyTouch { apply(it, true) }
+            "up" -> bridge.applyTouch { apply(it, false) }
+            "tap" -> {
+                bridge.applyTouch { apply(it, true) }
+                hold(request, 120)
+                bridge.applyTouch { apply(it, false) }
+            }
+            else -> throw AgentException("INVALID_INPUT", "Pad action '$action' is not tap, down or up")
+        }
+        return JSONObject().put("button", name)
+    }
+
+    private fun stick(request: JSONObject): JSONObject {
+        val bridge = SessionState.padBridge ?: throw AgentException("NO_PAD", "The session has no virtual pad")
+        val right = request.optString("stick", "left") == "right"
+        val x = request.optDouble("x", 0.0).toFloat().coerceIn(-1f, 1f)
+        val y = request.optDouble("y", 0.0).toFloat().coerceIn(-1f, 1f)
+        bridge.applyTouch { if (right) { it.rightX = x; it.rightY = y } else { it.leftX = x; it.leftY = y } }
+        hold(request, 300)
+        bridge.applyTouch { if (right) { it.rightX = 0f; it.rightY = 0f } else { it.leftX = 0f; it.leftY = 0f } }
+        return JSONObject().put("stick", if (right) "right" else "left")
+    }
+
+    private fun trigger(request: JSONObject): JSONObject {
+        val bridge = SessionState.padBridge ?: throw AgentException("NO_PAD", "The session has no virtual pad")
+        val right = request.optString("trigger", "right") == "right"
+        val value = request.optDouble("value", 1.0).toFloat().coerceIn(0f, 1f)
+        bridge.applyTouch { if (right) it.rightTrigger = value else it.leftTrigger = value }
+        hold(request, 200)
+        bridge.applyTouch { if (right) it.rightTrigger = 0f else it.leftTrigger = 0f }
+        return JSONObject().put("trigger", if (right) "right" else "left")
+    }
+
+    private fun hold(request: JSONObject, defaultMs: Long) =
+        Thread.sleep(request.optLong("holdMs", defaultMs).coerceIn(0, 10_000))
+
+    private val DPAD = setOf("up", "down", "left", "right")
+
+    private val BUTTONS = mapOf(
+        "a" to PadState.A, "b" to PadState.B, "x" to PadState.X, "y" to PadState.Y,
+        "lb" to PadState.LB, "rb" to PadState.RB, "select" to PadState.SELECT, "back" to PadState.SELECT,
+        "start" to PadState.START, "menu" to PadState.START, "l3" to PadState.L3, "r3" to PadState.R3,
+        "guide" to PadState.GUIDE, "steam" to PadState.GUIDE,
+    )
+
+    /** Linux evdev codes (input-event-codes.h) by name. */
+    private val KEYS: Map<String, Int> = buildMap {
+        "1234567890".forEachIndexed { i, c -> put(c.toString(), 2 + i) }
+        "QWERTYUIOP".forEachIndexed { i, c -> put(c.toString(), 16 + i) }
+        "ASDFGHJKL".forEachIndexed { i, c -> put(c.toString(), 30 + i) }
+        "ZXCVBNM".forEachIndexed { i, c -> put(c.toString(), 44 + i) }
+        (1..10).forEach { put("F$it", 58 + it) }
+        put("F11", 87); put("F12", 88)
+        putAll(mapOf(
+            "ESC" to 1, "MINUS" to 12, "EQUAL" to 13, "BACKSPACE" to 14, "TAB" to 15, "LEFTBRACE" to 26,
+            "RIGHTBRACE" to 27, "ENTER" to 28, "LEFTCTRL" to 29, "SEMICOLON" to 39, "APOSTROPHE" to 40,
+            "GRAVE" to 41, "LEFTSHIFT" to 42, "BACKSLASH" to 43, "COMMA" to 51, "DOT" to 52, "SLASH" to 53,
+            "RIGHTSHIFT" to 54, "LEFTALT" to 56, "SPACE" to 57, "CAPSLOCK" to 58, "RIGHTCTRL" to 97,
+            "RIGHTALT" to 100, "HOME" to 102, "UP" to 103, "PAGEUP" to 104, "LEFT" to 105, "RIGHT" to 106,
+            "END" to 107, "DOWN" to 108, "PAGEDOWN" to 109, "INSERT" to 110, "DELETE" to 111, "LEFTMETA" to 125,
+            "CTRL" to 29, "SHIFT" to 42, "ALT" to 56, "META" to 125, "SUPER" to 125, "RETURN" to 28, "ESCAPE" to 1,
+        ))
+    }
+
+    /** US-layout characters as (evdev code, shift). */
+    private val TYPED: Map<Char, Pair<Int, Boolean>> = buildMap {
+        for (c in 'a'..'z') put(c, KEYS.getValue(c.uppercase()) to false)
+        for (c in 'A'..'Z') put(c, KEYS.getValue(c.toString()) to true)
+        for (c in '0'..'9') put(c, KEYS.getValue(c.toString()) to false)
+        "!@#$%^&*()".forEachIndexed { i, c -> put(c, KEYS.getValue(((i + 1) % 10).toString()) to true) }
+        putAll(mapOf(
+            ' ' to (57 to false), '\n' to (28 to false), '\t' to (15 to false),
+            '-' to (12 to false), '_' to (12 to true), '=' to (13 to false), '+' to (13 to true),
+            '[' to (26 to false), '{' to (26 to true), ']' to (27 to false), '}' to (27 to true),
+            ';' to (39 to false), ':' to (39 to true), '\'' to (40 to false), '"' to (40 to true),
+            '`' to (41 to false), '~' to (41 to true), '\\' to (43 to false), '|' to (43 to true),
+            ',' to (51 to false), '<' to (51 to true), '.' to (52 to false), '>' to (52 to true),
+            '/' to (53 to false), '?' to (53 to true),
+        ))
+    }
+}
@@ -14,6 +14,7 @@ import org.json.JSONObject
 class AgentStartActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
+        requestedOrientation = com.droiddeck.launcher.session.SessionPrefs.orientation(this)
        val request = decodeRequest(intent.getStringExtra(EXTRA_REQUEST))
        if (request == null) {
            finish()
@@ -38,6 +39,10 @@ class AgentStartActivity : Activity() {
            Log.e(TAG, "missing agent start request")
            return null
        }
+        if (encoded.length > AgentAccess.MAX_REQUEST_CHARS) {
+            Log.w(TAG, "agent start request is too large")
+            return null
+        }
        return try {
            JSONObject(String(Base64.decode(encoded, Base64.DEFAULT), Charsets.UTF_8))
        } catch (e: Exception) {
@@ -47,6 +52,13 @@ class AgentStartActivity : Activity() {
    }

    private fun startSession(request: JSONObject) {
+        try {
+            AgentAccess.requireStart(this, request)
+        } catch (e: AgentException) {
+            Log.w(TAG, e.code)
+            finish()
+            return
+        }
        val requestedMode = request.optString("mode")
        val sessionMode = when (requestedMode) {
            "steam" -> SessionService.MODE_STEAM
@@ -0,0 +1,157 @@
+package com.droiddeck.launcher.agent
+
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
+import android.view.inspector.WindowInspector
+import androidx.compose.ui.platform.ViewRootForTest
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.semantics.SemanticsConfiguration
+import androidx.compose.ui.semantics.SemanticsNode
+import androidx.compose.ui.semantics.SemanticsProperties
+import androidx.compose.ui.semantics.getOrNull
+import androidx.compose.ui.text.AnnotatedString
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * The app's own UI as an agent sees it: every Compose node in every window of the process (popups
+ * and menus included), read from Compose's semantics rather than through UI Automator, which on a
+ * dual-screen device dumps whichever window has focus - often not this app's. Nodes carry their
+ * test tag (ui/TestTags.kt), text, content description, role, state and on-screen bounds; click
+ * and set-text act on a node by tag or text, so a test needs no coordinates.
+ */
+object AgentUi {
+    private const val TIMEOUT_MS = 5_000L
+    /** Setup's Debugging tools toggle: the bridge never acts on its own gate (AgentAccess). */
+    private const val GATE_TAG = "setting-agent-commands"
+
+    fun handle(request: JSONObject): JSONObject = when (val op = request.optString("op", "dump")) {
+        "dump" -> onMain { dump(request.optBoolean("all")) }
+        "click" -> onMain { act(request) { node -> perform(node, SemanticsActions.OnClick) } }
+        "set-text" -> onMain {
+            val text = request.optString("text")
+            act(request) { node ->
+                node.config.getOrNull(SemanticsActions.SetText)?.action?.invoke(AnnotatedString(text))
+                    ?: throw AgentException("NOT_EDITABLE", "That node takes no text")
+            }
+        }
+        else -> throw AgentException("INVALID_REQUEST", "ui op '$op' is not dump, click or set-text")
+    }.put("ok", true).put("command", "ui")
+
+    private fun roots(): List<Pair<View, ViewRootForTest>> {
+        if (Build.VERSION.SDK_INT < 29) throw AgentException("UNSUPPORTED", "The UI dump needs Android 10 or later")
+        val found = mutableListOf<Pair<View, ViewRootForTest>>()
+        fun walk(view: View) {
+            if (view is ViewRootForTest) found += view to view
+            if (view is ViewGroup) for (i in 0 until view.childCount) walk(view.getChildAt(i))
+        }
+        WindowInspector.getGlobalWindowViews().filter { it.isAttachedToWindow && it.isShown }.forEach(::walk)
+        return found
+    }
+
+    private fun dump(all: Boolean): JSONObject {
+        val windows = JSONArray()
+        for ((view, root) in roots()) {
+            val nodes = JSONArray()
+            val location = IntArray(2).also { view.getLocationOnScreen(it) }
+            fun visit(node: SemanticsNode) {
+                val json = describe(node, location)
+                if (all || json.has("tag") || json.has("text") || json.has("description") || json.optBoolean("clickable")) nodes.put(json)
+                node.children.forEach(::visit)
+            }
+            visit(root.semanticsOwner.rootSemanticsNode)
+            windows.put(JSONObject()
+                .put("display", view.display?.displayId ?: JSONObject.NULL)
+                .put("window", view.rootView.javaClass.simpleName)
+                .put("nodes", nodes))
+        }
+        return JSONObject().put("windows", windows)
+    }
+
+    private fun describe(node: SemanticsNode, origin: IntArray): JSONObject {
+        val config = node.config
+        val json = JSONObject().put("id", node.id)
+        config.getOrNull(SemanticsProperties.TestTag)?.let { json.put("tag", it) }
+        val text = textFields(config)
+        text.keys().forEach { json.put(it, text.get(it)) }
+        config.getOrNull(SemanticsProperties.Role)?.let { json.put("role", it.toString()) }
+        config.getOrNull(SemanticsProperties.ToggleableState)?.let { json.put("toggle", it.name) }
+        config.getOrNull(SemanticsProperties.Selected)?.let { json.put("selected", it) }
+        config.getOrNull(SemanticsProperties.Focused)?.let { json.put("focused", it) }
+        if (config.contains(SemanticsProperties.Disabled)) json.put("disabled", true)
+        if (config.contains(SemanticsActions.OnClick)) json.put("clickable", true)
+        if (config.contains(SemanticsActions.SetText)) json.put("editable", true)
+        val b = node.boundsInWindow
+        json.put("bounds", JSONArray()
+            .put(origin[0] + b.left.toInt()).put(origin[1] + b.top.toInt())
+            .put(origin[0] + b.right.toInt()).put(origin[1] + b.bottom.toInt()))
+        return json
+    }
+
+    internal fun textFields(config: SemanticsConfiguration): JSONObject {
+        val password = config.contains(SemanticsProperties.Password)
+        val json = JSONObject()
+        for ((key, value) in listOf(
+            "text" to config.getOrNull(SemanticsProperties.Text)?.joinToString(" ") { it.text },
+            "editableText" to config.getOrNull(SemanticsProperties.EditableText)?.text,
+            "description" to config.getOrNull(SemanticsProperties.ContentDescription)?.joinToString(" "),
+            "state" to config.getOrNull(SemanticsProperties.StateDescription),
+        )) value?.let { json.put(key, if (password) "<redacted>" else it) }
+        return json
+    }
+
+    /**
+     * The node a request names by "tag" (exact) or "match" (text or description containing it,
+     * ignoring case); "index" picks among several, in tree order.
+     */
+    private fun act(request: JSONObject, action: (SemanticsNode) -> Unit): JSONObject {
+        val tag = request.optString("tag").takeIf { it.isNotEmpty() }
+        val text = if (tag == null) request.optString("match").takeIf { it.isNotEmpty() } else null
+        if (tag == null && text == null) throw AgentException("INVALID_REQUEST", "Name the node by tag or match")
+        val matches = mutableListOf<Pair<SemanticsNode, IntArray>>()
+        for ((view, root) in roots()) {
+            val origin = IntArray(2).also { view.getLocationOnScreen(it) }
+            fun visit(node: SemanticsNode) {
+                val config = node.config
+                val hit = if (tag != null) config.getOrNull(SemanticsProperties.TestTag) == tag
+                else (config.getOrNull(SemanticsProperties.Text)?.joinToString(" ") { it.text }
+                    ?: config.getOrNull(SemanticsProperties.ContentDescription)?.joinToString(" ") ?: "")
+                    .contains(text!!, ignoreCase = true)
+                if (hit) matches += node to origin
+                node.children.forEach(::visit)
+            }
+            visit(root.semanticsOwner.rootSemanticsNode)
+        }
+        val index = request.optInt("index", 0)
+        val (node, origin) = matches.getOrNull(index)
+            ?: throw AgentException("NO_SUCH_NODE", "No node with ${if (tag != null) "tag '$tag'" else "text '$text'"} (${matches.size} found)")
+        if (generateSequence(node) { it.parent }.any { it.config.getOrNull(SemanticsProperties.TestTag) == GATE_TAG }) {
+            throw AgentException("PROTECTED_CONTROL", "Debugging tools are switched on the device only")
+        }
+        action(node)
+        return JSONObject().put("matches", matches.size).put("node", describe(node, origin))
+    }
+
+    private fun perform(node: SemanticsNode, key: androidx.compose.ui.semantics.SemanticsPropertyKey<androidx.compose.ui.semantics.AccessibilityAction<() -> Boolean>>) {
+        val action = node.config.getOrNull(key)?.action ?: throw AgentException("NOT_CLICKABLE", "That node has no click action")
+        action()
+    }
+
+    private fun <T> onMain(block: () -> T): T {
+        if (Looper.myLooper() == Looper.getMainLooper()) return block()
+        val result = AtomicReference<Result<T>>()
+        val done = CountDownLatch(1)
+        Handler(Looper.getMainLooper()).post {
+            result.set(runCatching(block))
+            done.countDown()
+        }
+        if (!done.await(TIMEOUT_MS, TimeUnit.MILLISECONDS)) throw AgentException("TIMEOUT", "The UI thread did not answer")
+        return result.get().getOrThrow()
+    }
+}
@@ -28,7 +28,9 @@ public class PulseAudioComponent extends SessionPart {
    /** Where the guest reaches the daemon; the session exports PULSE_SERVER=unix:<this>. */
    public static final String SOCKET_NAME = "PS0";
    /** Identifies the bundled pulseaudio.tzst; a change here re-unpacks it over what a device has. */
-    private static final String BUNDLE_STAMP = "2026-09-23-pa13-suspend-r5";
+    private static final String BUNDLE_STAMP = "2026-10-08-pa13-directaudio-native";
+
+

    private final File workingDir;
    /** Where the daemon's own output is kept for this session, or null for logcat only. */
@@ -40,8 +42,6 @@ public class PulseAudioComponent extends SessionPart {
     * turns that one stream into a source the client can see, named DirectAudioMic.
     */
    private final String micFifoPath;
-    /** The DirectAudio relay's socket when the client's output should go through it, else null. */
-    private String relaySocketPath;
    private volatile int pid = -1;

    public PulseAudioComponent(Context context) {
@@ -54,15 +54,6 @@ public class PulseAudioComponent extends SessionPart {
        this.micFifoPath = micFifoPath;
    }

-    /**
-     * Route the daemon's output through the DirectAudio relay at this socket instead of an AAudio
-     * stream of its own. The relay owns the stream outside proot, with its adaptive buffer; the
-     * daemon only fills a shared ring. Set before {@link #start()}; the relay may start later.
-     */
-    public void setRelaySocket(String path) {
-        this.relaySocketPath = path;
-    }
-
    /** CRC-32 of the bundled pulseaudio.tzst, or "?" if it cannot be read. About 600 KB; cheap. */
    private String bundleChecksum() {
        java.util.zip.CRC32 crc = new java.util.zip.CRC32();
@@ -106,6 +97,7 @@ public class PulseAudioComponent extends SessionPart {
        String have = FileUtils.readString(stamp);
        String want = BUNDLE_STAMP + "-" + bundleChecksum();
        if (!new File(modulesDir, "arm64/module-aaudio-sink.so").isFile()
+                || !new File(modulesDir, "arm64/module-directaudio-native-sink.so").isFile()
                || !new File(workingDir, "pactl").isFile()
                || have == null || !want.equals(have.trim())) {
            Log.i(TAG, "unpacking pulseaudio.tzst (" + want + "; had " + have + ")");
@@ -139,14 +131,15 @@ public class PulseAudioComponent extends SessionPart {
        // the sink to 0% and the session plays silence.
        // The sink's name is what the client's Audio settings show as the output device, so it
        // says which road the sound takes.
-        if (relaySocketPath != null && !relaySocketPath.isEmpty()) {
-            config.add("load-module module-directaudio-sink sink_name=DirectAudio socket=\"" + relaySocketPath + "\" performance_mode=1 adaptive=1 volume=1.0");
-            config.add("set-default-sink DirectAudio");
-        } else {
-            // The classic sink: the adaptive AAudio module 0.1.5 shipped, unchanged.
-            config.add("load-module module-aaudio-classic-sink sink_name=AAudioSink performance_mode=1 adaptive=1 volume=1.0");
-            config.add("set-default-sink AAudioSink");
-        }
+        // The client's sound: DirectAudio's own engine, in this process, one step from Android.
+        // decay=0: shrinking the device buffer after a quiet spell probes below what works and that
+        // probe is a click; the client plays menus. Between .nofail and .fail a module that cannot
+        // open its stream does not take the daemon down; ensureClientSink() then loads the plain
+        // AAudio sink in its place.
+        config.add(".nofail");
+        config.add("load-module module-directaudio-native-sink sink_name=DirectAudio performance_mode=1 adaptive=1 decay=0 limiter=1 watchdog=1 volume=1.0");
+        config.add("set-default-sink DirectAudio");
+        config.add(".fail");
        if (micFifoPath != null && !micFifoPath.isEmpty()) {
            // The format is the helper's, fixed at s16le/48000/mono: it resamples when the device
            // grants another input rate, so the daemon is never told a rate the bytes are not.
@@ -178,6 +171,84 @@ public class PulseAudioComponent extends SessionPart {
                    Log.i(TAG, line);
                    if (out != null) synchronized (out) { out.println(line); out.flush(); }
                });
+        Thread guard = new Thread(() -> ensureClientSink(out), "pulse-sink-guard");
+        guard.setDaemon(true);
+        guard.start();
+    }
+
+    /**
+     * The fallback: once the daemon answers, if the DirectAudio sink is not
+     * there (the module failed to load or to open its stream), load the plain AAudio sink so the
+     * client is never left without an output. Says so in the audio log either way.
+     */
+    private void ensureClientSink(java.io.PrintWriter out) {
+        try {
+            long deadline = System.currentTimeMillis() + 15000L;
+            String sinks = null;
+            while (System.currentTimeMillis() < deadline && pid > 1) {
+                if (socket().exists() && (sinks = pactl("list", "short", "sinks")) != null) break;
+                try { Thread.sleep(250L); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; }
+            }
+            String line;
+            if (sinks == null) {
+                line = "== client sink: the daemon did not answer in 15 s; no fallback attempted";
+            } else if (sinks.contains("\tDirectAudio\t") || sinks.startsWith("DirectAudio\t") || sinks.contains("\tDirectAudio\n") || sinks.matches("(?s).*\\bDirectAudio\\b.*")) {
+                line = "== client sink: DirectAudio (module-directaudio-native-sink)";
+            } else {
+                boolean loaded = pactl("load-module", "module-aaudio-sink", "sink_name=AAudioSink", "performance_mode=1", "adaptive=1", "volume=1.0") != null
+                        && pactl("set-default-sink", "AAudioSink") != null;
+                line = loaded ? "== client sink: DirectAudio did not come up; FALLBACK to the plain AAudio sink (AAudioSink)"
+                              : "== client sink: DirectAudio did not come up and the AAudio fallback failed too - no client sound";
+                Log.w(TAG, line);
+            }
+            Log.i(TAG, line);
+            if (out != null) synchronized (out) { out.println(line); out.flush(); }
+        } catch (Throwable t) {
+            Log.w(TAG, "ensureClientSink failed", t);
+        }
+    }
+
+    /** Runs pactl against this daemon; its stdout, or null when it failed or timed out. */
+    private String pactl(String... args) {
+        File pactl = new File(workingDir, "pactl");
+        if (!pactl.isFile() || pid <= 1) return null;
+        java.lang.Process process = null;
+        try {
+            File modules = new File(workingDir, "modules/arm64");
+            ArrayList<String> cmd = new ArrayList<>();
+            cmd.add(pactl.getAbsolutePath());
+            java.util.Collections.addAll(cmd, args);
+            ProcessBuilder builder = new ProcessBuilder(cmd);
+            builder.directory(workingDir);
+            builder.redirectErrorStream(true);
+            builder.environment().put("LD_LIBRARY_PATH", "/system/lib64:" + modules + ":" + workingDir);
+            builder.environment().put("HOME", workingDir.getAbsolutePath());
+            builder.environment().put("TMPDIR", workingDir.getAbsolutePath());
+            builder.environment().put("PULSE_SERVER", "unix:" + socket().getAbsolutePath());
+            process = builder.start();
+            String output;
+            try (InputStream in = process.getInputStream();
+                 java.io.ByteArrayOutputStream outStream = new java.io.ByteArrayOutputStream()) {
+                byte[] buf = new byte[4096];
+                int n;
+                while ((n = in.read(buf)) != -1) {
+                    outStream.write(buf, 0, n);
+                }
+                output = outStream.toString(java.nio.charset.StandardCharsets.UTF_8.name());
+            }
+            if (!process.waitFor(5, TimeUnit.SECONDS)) {
+                process.destroyForcibly();
+                return null;
+            }
+            return process.exitValue() == 0 ? output : null;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            return null;
+        } catch (Throwable t) {
+            return null;
+        } finally {
+            if (process != null && process.isAlive()) process.destroyForcibly();
+        }
    }

    @Override
@@ -0,0 +1,129 @@
+package com.droiddeck.launcher.core
+
+import android.app.Activity
+import android.content.Context
+import android.content.res.Configuration
+import android.os.LocaleList
+import java.util.Locale
+
+/**
+ * The language the app shows itself in.
+ *
+ * Nothing chosen (the default) means the system's: Android's own language, or the per-app language
+ * Android 13+ lets a user set for DroidDeck in its settings, exactly as Android resolves it. Picking
+ * one in Setup overrides that until the user picks "System default" again. Each activity and service
+ * applies the choice to its own context ([wrap], [applyTo]), so it works on every Android version
+ * the app runs on rather than only where the platform's per-app language API exists.
+ *
+ * Steam follows the same choice: [SteamLanguage] turns [effective] into the client's language.
+ */
+object AppLanguage {
+    /** The stored value meaning "follow the system". */
+    const val SYSTEM = ""
+
+    /** The languages the app ships, as BCP 47 tags, in the order the picker lists them. */
+    val supported: List<String> = listOf("en", "es", "fr", "ru", "ja", "ko", "zh-CN", "zh-TW", "zh-HK")
+
+    private const val PREFS = "language"
+    private const val KEY = "app_language"
+
+    /** The locale Android gave the process before any choice here was applied. */
+    @Volatile private var systemLocale: Locale? = null
+
+    /** The stored choice: one of [supported], or [SYSTEM]. */
+    fun chosen(context: Context): String =
+        context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getString(KEY, SYSTEM)
+            ?.takeIf { it in supported } ?: SYSTEM
+
+    fun setChosen(context: Context, tag: String) {
+        val value = if (tag in supported) tag else SYSTEM
+        context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().putString(KEY, value).commit()
+        val locale = value.takeIf { it.isNotEmpty() }?.let(Locale::forLanguageTag) ?: system(context)
+        Locale.setDefault(locale)
+        // Code that reads strings through the application context sees the new language too.
+        val app = context.applicationContext
+        @Suppress("DEPRECATION")
+        app.resources.updateConfiguration(
+            Configuration(app.resources.configuration).apply { setLocales(LocaleList(locale)) },
+            app.resources.displayMetrics,
+        )
+    }
+
+    /** The locale Android chose for the app, ignoring the choice made here. */
+    fun system(context: Context): Locale =
+        systemLocale ?: context.resources.configuration.locales[0] ?: Locale.getDefault()
+
+    /** The locale the app is shown in: the chosen language, or else the system's. */
+    fun effective(context: Context): Locale =
+        chosen(context).takeIf { it.isNotEmpty() }?.let(Locale::forLanguageTag) ?: system(context)
+
+    /** Remembers the system's locale; call with the untouched base context, before [wrap]. */
+    fun noteSystem(base: Context) {
+        if (systemLocale == null) systemLocale = base.resources.configuration.locales[0]
+    }
+
+    /**
+     * [base], showing the chosen language: for an Application's or a Service's attachBaseContext.
+     * Only the locale is overridden, so screen size, density and night mode keep following the
+     * device as they change.
+     */
+    fun wrap(base: Context): Context {
+        noteSystem(base)
+        val tag = chosen(base).ifEmpty { return base }
+        val locale = Locale.forLanguageTag(tag)
+        Locale.setDefault(locale)
+        return base.createConfigurationContext(override(locale))
+    }
+
+    /**
+     * Applies the chosen language to an activity; call from its attachBaseContext, after super.
+     * applyOverrideConfiguration keeps the locale through rotation and window resizes, which an
+     * activity here handles itself rather than being recreated.
+     */
+    fun applyTo(activity: Activity, base: Context) {
+        noteSystem(base)
+        val tag = chosen(base).ifEmpty { return }
+        val locale = Locale.forLanguageTag(tag)
+        Locale.setDefault(locale)
+        activity.applyOverrideConfiguration(override(locale))
+    }
+
+    /** Follows a change of the system's language while the process lives (Application.onConfigurationChanged). */
+    fun systemChanged(config: Configuration) {
+        config.locales[0]?.let { systemLocale = it }
+    }
+
+    // A new Configuration's fontScale is 1, which as an override would undo the user's font size;
+    // 0 leaves it undefined, so only the locale is changed.
+    private fun override(locale: Locale) = Configuration().apply { fontScale = 0f; setLocales(LocaleList(locale)) }
+
+    /** Which of the app's languages [locale] reads as, or null when the app does not ship it. */
+    fun supportedTag(locale: Locale): String? = when (locale.language) {
+        "en", "es", "fr", "ru", "ja", "ko" -> locale.language
+        "zh" -> when {
+            locale.script == "Hans" -> "zh-CN"
+            locale.country == "HK" || locale.country == "MO" -> "zh-HK"
+            locale.script == "Hant" || locale.country == "TW" -> "zh-TW"
+            else -> "zh-CN"
+        }
+        else -> null
+    }
+
+    /** [locale]'s language named in itself, without its region unless the app tells them apart. */
+    fun displayName(locale: Locale): String =
+        supportedTag(locale)?.let(::nativeName) ?: locale.getDisplayLanguage(locale).replaceFirstChar { it.titlecase(locale) }
+
+    /** A language's name in that language, for the picker: what a reader of it looks for. */
+    fun nativeName(tag: String): String = when (tag) {
+        "en" -> "English"
+        "es" -> "Español"
+        "fr" -> "Français"
+        "ru" -> "Русский"
+        "ja" -> "日本語"
+        "ko" -> "한국어"
+        "zh-CN" -> "简体中文"
+        "zh-TW" -> "繁體中文（台灣）"
+        "zh-HK" -> "繁體中文（香港）"
+        else -> Locale.forLanguageTag(tag).let { it.getDisplayName(it) }
+    }
+}
@@ -0,0 +1,19 @@
+package com.droiddeck.launcher.core
+
+import android.content.Context
+
+object AppUiPrefs {
+    const val DEFAULT_SCALE = 100
+    val scales = listOf(75, 85, 100, 115, 125, 150)
+
+    internal fun normalizeScale(percent: Int): Int = percent.takeIf { it in scales } ?: DEFAULT_SCALE
+
+    fun scale(context: Context): Int = normalizeScale(
+        context.getSharedPreferences("app-ui", Context.MODE_PRIVATE).getInt("scale", DEFAULT_SCALE),
+    )
+
+    fun setScale(context: Context, percent: Int) {
+        context.getSharedPreferences("app-ui", Context.MODE_PRIVATE).edit()
+            .putInt("scale", normalizeScale(percent)).apply()
+    }
+}
@@ -53,7 +53,7 @@ object DeviceReport {
        b.append("DroidDeck session report\n")
        b.append("========================\n")
        k("Written", SimpleDateFormat("yyyy-MM-dd HH:mm:ss zzz", Locale.US).format(Date()))
-        k("Session mode", when (mode) { SessionService.MODE_DESKTOP -> "desktop (labwc/LXQt)"; SessionService.MODE_RUN -> "a program under gamescope"; else -> "Steam client (gamescope)" })
+        k("Session mode", when (mode) { SessionService.MODE_DESKTOP -> "desktop (KDE Plasma)"; SessionService.MODE_RUN -> "a program under gamescope"; else -> "Steam client (gamescope)" })

        h("App")
        runCatching {
@@ -108,9 +108,12 @@ object DeviceReport {
        h("Display")
        k("Session output", SessionState.outputSize?.let { "${it.first}x${it.second}" })
        k("Session refresh", String.format(Locale.US, "%.2f Hz", SessionState.refreshHz))
-        k("Shape setting", SessionPrefs.shapeMode(context))
-        k("Custom resolution (Steam)", SessionPrefs.customResolution(context, SessionService.MODE_STEAM)?.let { "${it.first}x${it.second}" } ?: "off")
-        k("Custom resolution (Desktop)", SessionPrefs.customResolution(context, SessionService.MODE_DESKTOP)?.let { "${it.first}x${it.second}" } ?: "off")
+        val panelSize = com.droiddeck.launcher.session.SessionDisplay.panelSize(context)
+        for ((label, mode) in listOf("Resolution (Steam)" to SessionService.MODE_STEAM, "Resolution (Desktop)" to SessionService.MODE_DESKTOP)) {
+            val choice = SessionPrefs.resolutionChoice(context, mode, panelSize)
+            val size = com.droiddeck.launcher.session.SessionDisplay.resolveChoice(panelSize, choice)
+            k(label, "$choice (${size.first}x${size.second})")
+        }
        k("Foldable", context.packageManager.hasSystemFeature("android.hardware.sensor.hinge_angle"))

        h("Drivers")
@@ -149,7 +152,6 @@ object DeviceReport {
        k("Zink lazy descriptors", SessionPrefs.zinkLazy(context))
        k("Threaded GL (glthread)", SessionPrefs.glThread(context))
        k("No GL error checks", SessionPrefs.noGlError(context))
-        k("Steam Deck mode", SessionPrefs.steamDeckMode(context))
        k("Steam controller", SessionPrefs.steamController(context))
        k("Upscaler", (SessionPrefs.upscalerChoices.firstOrNull { it.first == SessionPrefs.upscaler(context) }?.second ?: "Off") +
            " (sharpness ${SessionPrefs.upscaleSharpness(context)}%)")
@@ -163,9 +165,7 @@ object DeviceReport {
        k("proot fast path", SessionPrefs.prootFastPath(context))
        k("Guest host name", SessionPrefs.guestHostname(context))
        k("DirectAudio for games", SessionPrefs.directAudio(context))
-        k("Stretch games to fill", SessionPrefs.forceFullscreen(context))
        k("Stretch 16:9 to panel", SessionPrefs.stretch16x9(context))
-        k("Client audio", if (SessionPrefs.clientDirectAudio(context)) "DirectAudio" else "classic")
        k("Microphone", SessionPrefs.micEnabled(context))
        k("On-screen controls", SessionPrefs.oscMode(context))
        k("Touch mode", SessionPrefs.touchMode(context))
@@ -179,10 +179,16 @@ object DeviceReport {
        h("Android process limits")
        k("Phantom proc monitor", PhantomProcessLimit.reportValue(PhantomProcessLimit.read(context)))

-        h("Device switch files in Download")
-        for (name in listOf("droiddeck-env", "droiddeck-tu-debug", "droiddeck-driver",
+        h("Device switch files")
+        SessionService.envSwitchFile(context)?.takeIf { it.isFile }?.let { f ->
+            k("droiddeck-env", FileUtils.readString(f)?.trim()?.replace('\n', ' ')?.ifEmpty { "(present, empty)" } ?: "(present)")
+        }
+        if (File(Environment.getExternalStorageDirectory(), "Download/droiddeck-env").isFile) {
+            k("Download/droiddeck-env", "(ignored - it moved to Android/data/${context.packageName}/files)")
+        }
+        for (name in listOf("droiddeck-tu-debug", "droiddeck-driver",
                            "droiddeck-osc", "droiddeck-no-pad",
-                            "droiddeck-no-hud", "droiddeck-wlr-renderer")) {
+                            "droiddeck-no-hud")) {
            val f = File(Environment.getExternalStorageDirectory(), "Download/$name")
            if (f.isFile) k(name, FileUtils.readString(f)?.trim()?.replace('\n', ' ')?.ifEmpty { "(present, empty)" } ?: "(present)")
        }
@@ -1,6 +1,8 @@
 package com.droiddeck.launcher.core

+import android.content.Context
 import android.os.Build
+import com.droiddeck.launcher.R
 import java.io.File

 /**
@@ -17,8 +19,12 @@ object DeviceSupport {
        File("/sys/class/kgsl/kgsl-3d0").exists() || File("/vendor/lib64/hw/vulkan.adreno.so").exists()

    /** The chip as the device names it, for the card that explains the refusal. */
-    fun gpuName(): String {
+    fun gpuName(context: Context): String {
        val soc = if (Build.VERSION.SDK_INT >= 31) Build.SOC_MODEL.takeIf { it.isNotBlank() && it != Build.UNKNOWN } else null
-        return soc?.let { "$it (${Build.HARDWARE})" } ?: Build.HARDWARE.ifBlank { "this GPU" }
+        return soc?.let { "$it (${Build.HARDWARE})" } ?: Build.HARDWARE.ifBlank { context.getString(R.string.gpu_this_gpu) }
    }
+
+    /** False on the Odin 3 (CQ8725S): a low-latency Wi-Fi lock makes its WLAN firmware hang, and
+     *  that firmware reboots the whole device instead of restarting Wi-Fi. */
+    fun lowLatencyWifiSafe(): Boolean = Build.VERSION.SDK_INT < 31 || Build.SOC_MODEL != "CQ8725S"
 }
@@ -25,20 +25,25 @@ object GameEnvironment {
    fun validValue(value: String) = '\u0000' !in value && value.length <= 8192
    fun validScope(scope: String) = scope.isEmpty() || (Regex("[1-9][0-9]*").matches(scope) && scope.toLongOrNull()?.let { it in 1..4294967295L } == true)

-    fun defaults(preset: String): Map<String, String?> = linkedMapOf<String, String?>(
+    fun defaults(preset: String, forceSsbs: Boolean = false): Map<String, String?> = linkedMapOf<String, String?>(
        "MESA_SHADER_CACHE_DISABLE" to "false",
        "VKD3D_FEATURE_LEVEL" to "12_2",
        "VKD3D_SHADER_MODEL" to "6_9",
        // .NET 7 and later reserve 256 GB of address space for the GC heap at startup, more than an
        // Android process has free, and the runtime fails to start. 32 GB is plenty for a game.
-        "DOTNET_GCRegionRange" to "0x800000000",
+        // Older NativeAOT runtimes require bare hex digits. CoreCLR accepts this form too.
+        "DOTNET_GCRegionRange" to "800000000",
        // .NET's W^X writes JIT code through a second mapping that FEX does not watch, so FEX keeps
        // running the stale translation and the game hangs at startup.
        "DOTNET_EnableWriteXorExecute" to "0",
    ).apply {
        FexPreset.env(preset).forEach { put(it.substringBefore('='), it.substringAfter('=')) }
+        // Steam settings' Force SSBS: droiddeck-game-env preloads libssbs.so into the game's Wine.
+        if (forceSsbs) put(FORCE_SSBS, "1")
    }

-    fun effective(config: Config, preset: String, scope: String): Map<String, String?> =
-        defaults(preset) + config.shared + if (scope.isEmpty()) emptyMap() else config.games[scope].orEmpty()
+    const val FORCE_SSBS = "DROIDDECK_FORCE_SSBS"
+
+    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()
 }
@@ -40,7 +40,7 @@ object HostProcess {
            if (onLine == null) builder.redirectOutput(File("/dev/null"))
            val process = builder.start()
            val pid = pidOf(process)
-            Log.i(TAG, "started pid $pid: $command")
+            Log.i(TAG, "started pid $pid: ${argv.first()} (${argv.size - 1} arguments)")
            if (onLine != null) {
                Thread({
                    try {
@@ -59,7 +59,7 @@ object HostProcess {
            }
            pid
        } catch (e: Exception) {
-            Log.e(TAG, "could not start: $command", e)
+            Log.e(TAG, "could not start: ${argv.first()}", e)
            -1
        }
    }
@@ -60,18 +60,45 @@ object LogRedactor {
    private val IPV4 = Regex("(?<![0-9.])(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})(?![0-9.])")
    /** An IPv6 literal: "::" somewhere, or all eight groups (a clock's 10:03:05 is neither). */
    private val IPV6 = Regex("(?<![0-9A-Za-z:])[0-9A-Fa-f]{0,4}(?::[0-9A-Fa-f]{0,4}){2,7}(?:%[A-Za-z0-9_.]+)?(?![0-9A-Za-z:])")
+    private val MAC = Regex("(?i)(?<![0-9a-z:-])[0-9a-f]{2}([:-])(?:[0-9a-f]{2}\\1){4}[0-9a-f]{2}(?![0-9a-z:-])")
+    private val MAC_FIELD = Regex(
+        "(?i)(\\bmac(?:[_ ]?address)?[\"']?\\s*[:=]\\s*[\"']?)[0-9a-f]{2}([:-])" +
+            "(?:[0-9a-f]{2}\\2){4}[0-9a-f]{2}(?![0-9a-z:-])"
+    )
+    private val DEVICE_IDENTIFIER = Regex(
+        "(?i)(\\b(?:android[_ ]?id|(?:device|controller)[_ ]?serial|serial(?:[_ ]?number)?|build\\.serial)" +
+            "[\"']?\\s*[:=]\\s*)(\"[^\"\\r\\n<>]+\"|'[^'\\r\\n<>]+'|[^\\s\"'<>&;,\\[\\]{}]+)"
+    )

    /**
     * The account a Steam UI login line names ("Login: OnLoginStateChange <account> 2 1 0 0"): a
     * user who signs in with a plain account name, not an email, had it in every log. The single
     * space then a non-space keeps "OnLoginStateChange  0 1 0 0" (no account yet) as it is.
     */
-    private val LOGIN_STATE = Regex("(OnLoginStateChange )(\\S+)")
+    private val LOGIN_STATE = Regex("(?i)(OnLoginStateChange:? )([^\\s<]\\S*)")
    private val LOGIN_USERS = Regex("(OnLoginUsersChanged )(\\S.*)$")

+    /**
+     * An account name as a field: `AccountName`, `account_name`, `username` (`"AccountName"
+     * "someone"` in a VDF, `account_name=...`, `"username": "..."`) and `login` - the last only
+     * as `login=`, a quoted key or a VDF pair, so "Login: OnLoginStateChange ..." keeps its label.
+     * A quoted value is blanked whole; one already blanked is left as it is.
+     */
+    private const val ACCOUNT_VALUE = "(\"[^\"<\\r\\n]+\"|'[^'<\\r\\n]+'|[^\\s\"'<>&;,}]+)"
+    private val ACCOUNT_KV = Regex(
+        "(?i)(?<![A-Za-z0-9_])(account[_-]?name|user[_-]?name|epicusername)" +
+            "([\"']?\\s*[=:]\\s*|[\"']\\s+)" + ACCOUNT_VALUE
+    )
+    private val LOGIN_KV = Regex(
+        "(?i)(?<![A-Za-z0-9_])(login)(\\s*=\\s*|[\"']\\s*[=:]\\s*|[\"']\\s+)" + ACCOUNT_VALUE
+    )
+
+    /** A learned pattern and the text (lowercase) a line must hold for it to match; null when none can be said. */
+    private class Learned(val regex: Regex, val needs: String?)
+
    /** The device's Steam accounts and persona names as patterns (see [learnAccounts]). */
    @Volatile
-    private var accounts: List<Regex> = emptyList()
+    private var accounts: List<Learned> = emptyList()

    /**
     * Learns every Steam account on the device from the client's loginusers.vdf - its AccountName
@@ -79,12 +106,13 @@ object LogRedactor {
     * Names under three characters are skipped: blanking every "a" would ruin a log.
     */
    fun learnAccounts(loginUsers: java.io.File) {
-        val found = ArrayList<Regex>()
+        val found = ArrayList<Learned>()
        try {
            if (loginUsers.isFile) {
                val kv = Regex("\"(AccountName|PersonaName)\"\\s+\"([^\"]*)\"")
                kv.findAll(loginUsers.readText()).map { it.groupValues[2].trim() }.filter { it.length >= 3 }.distinct().forEach { name ->
-                    found += Regex("(?i)(?<![A-Za-z0-9_])" + Regex.escape(name) + "(?![A-Za-z0-9_])")
+                    val needs = name.lowercase().takeIf { name.all { it.code < 0x80 } }
+                    found += Learned(Regex("(?i)(?<![A-Za-z0-9_])" + Regex.escape(name) + "(?![A-Za-z0-9_])"), needs)
                }
            }
        } catch (e: Exception) {
@@ -101,7 +129,7 @@ object LogRedactor {

    /** This device's public addresses as patterns (see [learnOwnAddresses]); empty until learned. */
    @Volatile
-    private var own: List<Regex> = emptyList()
+    private var own: List<Learned> = emptyList()

    /**
     * Learns the device's addresses from the link file the app writes for the session
@@ -109,7 +137,7 @@ object LogRedactor {
     * private, link-local and loopback addresses identify nobody and are left out.
     */
    fun learnOwnAddresses(linkFile: java.io.File) {
-        val found = ArrayList<Regex>()
+        val found = ArrayList<Learned>()
        try {
            if (linkFile.isFile) linkFile.forEachLine { line ->
                val addr = line.trim().takeIf { it.startsWith("addr ") }?.split(Regex("\\s+"))?.getOrNull(1) ?: return@forEachLine
@@ -118,9 +146,12 @@ object LogRedactor {
                        val groups = expand6(addr)?.take(4) ?: return@forEachLine
                        // Any spelling of an address in this /64: leading zeros dropped, :: anywhere after.
                        val prefix = groups.joinToString(":") { g -> "0{0,3}" + Regex.escape(g.trimStart('0').ifEmpty { "0" }) }
-                        found += Regex("(?i)(?<![0-9A-Fa-f:])$prefix(?::[0-9A-Fa-f]{0,4}){1,4}(?:%[A-Za-z0-9_.]+)?")
+                        found += Learned(
+                            Regex("(?i)(?<![0-9A-Fa-f:])$prefix(?::[0-9A-Fa-f]{0,4}){1,4}(?:%[A-Za-z0-9_.]+)?"),
+                            groups[0].trimStart('0').ifEmpty { "0" },
+                        )
                    }
-                    "public IPv4" -> found += Regex("(?<![0-9.])" + Regex.escape(addr) + "(?![0-9.])")
+                    "public IPv4" -> found += Learned(Regex("(?<![0-9.])" + Regex.escape(addr) + "(?![0-9.])"), addr)
                }
            }
        } catch (e: Exception) {
@@ -190,37 +221,136 @@ object LogRedactor {
        false
    }

+    /**
+     * Bump whenever a pattern is added or tightened. A session folder records the version it was
+     * scrubbed under (SessionArtifacts.SCRUBBED_TREE_MARKER), and a share copies a file as it is
+     * only when that matches, so a folder scrubbed under older rules is scrubbed again on the way
+     * out.
+     */
+    const val RULES_VERSION = 3
+
+    /**
+     * A private IPv4 address (10/8, 172.16/12, 192.168/16, link-local 169.254/16): the home
+     * network's layout, e.g. its router as the resolver. Blanked in a shared zip only; public
+     * server addresses stay. Not part of a longer dotted number (a version like 10.0.19041.1).
+     */
+    private val LAN_IPV4 = Regex(
+        "(?<![\\d.])(?:10\\.\\d{1,3}|192\\.168|172\\.(?:1[6-9]|2\\d|3[01])|169\\.254)\\.\\d{1,3}\\.\\d{1,3}(?!\\.?\\d)"
+    )
+
    /** [src]'s lines, scrubbed, to [out]. */
    fun scrubTo(src: java.io.File, out: java.io.Writer) {
        src.forEachLine { line -> out.write(redact(line)); out.write("\n") }
    }

+    /**
+     * The last pass for a file going into a shared zip: [redact], then the rules the stores' log
+     * uses too ([SecretScrub]) - URLs without query, fragment and user:password and with any
+     * token-bearing path segment blanked, token values and Authorization / Cookie headers blanked
+     * - and private IPv4 addresses as `<lan-address>`. A line already clean comes out unchanged.
+     */
+    fun redactForShare(line: String): String {
+        if (line.isEmpty()) return line
+        return try {
+            val out = SecretScrub.scrub(redact(line), SecretScrub.Urls.KEEP_PATH, "<redacted:token>")
+            LAN_IPV4.replace(out, "<lan-address>")
+        } catch (t: Throwable) {
+            "<redaction failed; line withheld>"
+        }
+    }
+
+    /** [src]'s lines through [redactForShare], to [out]: the pass every text file in a shared zip gets. */
+    fun scrubForShare(src: java.io.File, out: java.io.Writer) {
+        src.forEachLine { line -> out.write(redactForShare(line)); out.write("\n") }
+    }
+
+    /** `<redacted:account>`, inside [value]'s quotes when it had them. */
+    private fun quoted(value: String): String {
+        val q = value.first().takeIf { it == '"' || it == '\'' }?.toString().orEmpty()
+        return "$q<redacted:account>$q"
+    }
+
+    /**
+     * A line on its way through [redact]. Each rule runs only on a line holding what it cannot match
+     * without - a word, enough separators, a long enough run: most of a Steam log is lines no rule
+     * touches, and a session's logs went through every rule at about a megabyte a second. A line with anything but ASCII in it goes through
+     * every case-insensitive rule, since Android's regex folds case more widely than lowercase().
+     */
+    private class Line(var text: String) {
+        private val unfolded = text.any { it.code >= 0x80 }
+        private var lower: String? = null
+
+        fun has(vararg words: String): Boolean {
+            if (unfolded) return true
+            val folded = lower ?: text.lowercase().also { lower = it }
+            return words.any { folded.contains(it) }
+        }
+
+        fun set(next: String) {
+            if (next != text) {
+                text = next
+                lower = null
+            }
+        }
+
+        fun holds(c: Char, times: Int): Boolean {
+            var n = 0
+            for (ch in text) if (ch == c && ++n >= times) return true
+            return false
+        }
+
+        inline fun hasRun(length: Int, inRun: (Char) -> Boolean): Boolean {
+            var n = 0
+            for (ch in text) if (!inRun(ch)) n = 0 else if (++n >= length) return true
+            return false
+        }
+    }
+
+    private fun isHex(c: Char) = c in '0'..'9' || c in 'a'..'f' || c in 'A'..'F'
+
    /** [line] with every credential shape replaced. Null- and exception-safe by construction. */
    fun redact(line: String): String {
        if (line.isEmpty()) return line
        return try {
-            var out = line
-            out = GUID.replace(out, "<redacted:guid>")
-            out = JWT_LABELLED.replace(out) { "${it.groupValues[1]}<redacted:jwt>" }
-            out = JWT_BASE64.replace(out, "<redacted:jwt>")
-            out = SECRET_KV.replace(out) { "${it.groupValues[1]}${it.groupValues[2]}<redacted:token>" }
-            out = GUARD_CODE.replace(out) { "${it.groupValues[1]}<redacted:code>" }
-            out = WEBAPI_KEY.replace(out, "<redacted:key>")
+            val out = Line(line)
+            if (out.has("mac")) out.set(MAC_FIELD.replace(out.text) { "${it.groupValues[1]}<redacted:mac>" })
+            if (out.holds(':', 5) || out.holds('-', 5)) out.set(MAC.replace(out.text, "<redacted:mac>"))
+            if (out.has("serial", "android")) out.set(DEVICE_IDENTIFIER.replace(out.text) {
+                val value = it.groupValues[2]
+                val quote = value.first().takeIf { char -> char == '\"' || char == '\'' }?.toString().orEmpty()
+                "${it.groupValues[1]}${quote}<redacted:serial>${quote}"
+            })
+            if (out.holds('-', 4)) out.set(GUID.replace(out.text, "<redacted:guid>"))
+            if (out.has("jwt")) out.set(JWT_LABELLED.replace(out.text) { "${it.groupValues[1]}<redacted:jwt>" })
+            if ("ey" in out.text) out.set(JWT_BASE64.replace(out.text, "<redacted:jwt>"))
+            if (out.has("token", "auth", "ticket", "sessionid", "steamloginsecure", "api", "machine", "pass", "pwd", "secret")) {
+                out.set(SECRET_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}<redacted:token>" })
+            }
+            if (out.has("guard", "factor", "2fa")) out.set(GUARD_CODE.replace(out.text) { "${it.groupValues[1]}<redacted:code>" })
+            if (out.hasRun(32, ::isHex)) out.set(WEBAPI_KEY.replace(out.text, "<redacted:key>"))
            // Mask, not delete: the last four digits let a reader correlate lines to one account.
-            out = STEAMID64.replace(out) { "${it.groupValues[1]}********${it.groupValues[3]}" }
-            out = STEAMID3.replace(out) { m ->
+            if ("76561" in out.text) out.set(STEAMID64.replace(out.text) { "${it.groupValues[1]}********${it.groupValues[3]}" })
+            if ("[U:1:" in out.text) out.set(STEAMID3.replace(out.text) { m ->
                val id = m.groupValues[1]
                "[U:1:${if (id.length > 4) "*".repeat(id.length - 4) + id.takeLast(4) else id}]"
+            })
+            if (out.has("external")) out.set(EXTERNAL_ADDR.replace(out.text) { "${it.groupValues[1]}<redacted:ip>" })
+            for (r in own) if (r.needs == null || out.has(r.needs)) out.set(r.regex.replace(out.text, "<redacted:ip>"))
+            if (out.has("onloginstatechange")) out.set(LOGIN_STATE.replace(out.text) { "${it.groupValues[1]}<redacted:account>" })
+            if ("OnLoginUsersChanged " in out.text) out.set(LOGIN_USERS.replace(out.text) { "${it.groupValues[1]}<redacted:account>" })
+            if (out.has("account", "user")) {
+                out.set(ACCOUNT_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" })
            }
-            out = EXTERNAL_ADDR.replace(out) { "${it.groupValues[1]}<redacted:ip>" }
-            for (r in own) out = r.replace(out, "<redacted:ip>")
-            out = LOGIN_STATE.replace(out) { "${it.groupValues[1]}<redacted:account>" }
-            out = LOGIN_USERS.replace(out) { "${it.groupValues[1]}<redacted:account>" }
-            for (r in accounts) out = r.replace(out, "<redacted:account>")
-            out = EMAIL.replace(out, "<redacted:email>")
-            out = RESIDUAL.replace(out) { "${it.groupValues[1]}=<redacted:token>" }
-            out = LONG_TOKEN.replace(out, "<redacted:token>")
-            out
+            if (out.has("login")) out.set(LOGIN_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" })
+            for (r in accounts) if (r.needs == null || out.has(r.needs)) out.set(r.regex.replace(out.text, "<redacted:account>"))
+            if ('@' in out.text) out.set(EMAIL.replace(out.text, "<redacted:email>"))
+            if (out.has("jwt", "token", "ticket", "sessionid", "steamloginsecure", "machineauth")) {
+                out.set(RESIDUAL.replace(out.text) { "${it.groupValues[1]}=<redacted:token>" })
+            }
+            if (out.hasRun(88) { it in 'a'..'z' || it in 'A'..'Z' || it in '0'..'9' || it == '_' || it == '-' }) {
+                out.set(LONG_TOKEN.replace(out.text, "<redacted:token>"))
+            }
+            out.text
        } catch (t: Throwable) {
            // A log line is never worth crashing a session over, but an unscrubbed one must not
            // reach the file either.
@@ -3,6 +3,7 @@ package com.droiddeck.launcher.core
 import android.content.Context
 import android.os.Build
 import android.provider.Settings
+import com.droiddeck.launcher.R

 /** Android's phantom process monitor can kill the many child processes used by a Steam session. */
 enum class PhantomProcessStatus {
@@ -98,29 +99,30 @@ object PhantomProcessLimit {
    fun blocksSteam(status: PhantomProcessStatus): Boolean =
        status != PhantomProcessStatus.NOT_APPLICABLE && status != PhantomProcessStatus.DISABLED

-    fun title(status: PhantomProcessStatus): String = when (status) {
-        PhantomProcessStatus.ENABLED -> "Child-process limit is on"
-        PhantomProcessStatus.UNSET -> "Child-process limit is unset"
-        PhantomProcessStatus.UNREADABLE -> "Child-process limit could not be checked"
-        PhantomProcessStatus.DISABLED -> "Child-process limit is off"
-        PhantomProcessStatus.NOT_APPLICABLE -> "Child-process limit not required"
+    fun title(context: Context, status: PhantomProcessStatus): String = context.getString(when (status) {
+        PhantomProcessStatus.ENABLED -> R.string.phantom_title_on
+        PhantomProcessStatus.UNSET -> R.string.phantom_title_unset
+        PhantomProcessStatus.UNREADABLE -> R.string.phantom_title_unreadable
+        PhantomProcessStatus.DISABLED -> R.string.phantom_title_off
+        PhantomProcessStatus.NOT_APPLICABLE -> R.string.phantom_title_not_required
+    })
+
+    fun instructions(context: Context, status: PhantomProcessStatus): String = when (status) {
+        PhantomProcessStatus.ENABLED, PhantomProcessStatus.UNSET, PhantomProcessStatus.UNREADABLE ->
+            context.getString(R.string.phantom_instructions_fix, fixSentence(context))
+        PhantomProcessStatus.DISABLED -> context.getString(R.string.phantom_instructions_off)
+        PhantomProcessStatus.NOT_APPLICABLE -> context.getString(R.string.phantom_instructions_not_applicable)
    }

-    fun instructions(status: PhantomProcessStatus): String = when (status) {
-        PhantomProcessStatus.ENABLED, PhantomProcessStatus.UNSET, PhantomProcessStatus.UNREADABLE -> fixSentence() + " If that is not possible, connect this device to a computer with ADB and run the command below. Return here and check again."
-        PhantomProcessStatus.DISABLED -> "Steam sessions can start."
-        PhantomProcessStatus.NOT_APPLICABLE -> "This Android version does not use this limit."
+    fun gateInstructions(context: Context, status: PhantomProcessStatus): String = when (status) {
+        PhantomProcessStatus.ENABLED, PhantomProcessStatus.UNSET, PhantomProcessStatus.UNREADABLE -> fixSentence(context)
+        else -> instructions(context, status)
    }

-    fun gateInstructions(status: PhantomProcessStatus): String = when (status) {
-        PhantomProcessStatus.ENABLED, PhantomProcessStatus.UNSET, PhantomProcessStatus.UNREADABLE -> fixSentence()
-        else -> instructions(status)
-    }
-
-    fun fixSentence(sdk: Int = Build.VERSION.SDK_INT): String =
-        if (hasDeveloperToggle(sdk)) "Turn on “Disable child process restrictions” in Developer options, and keep Developer options on afterwards."
-        else "This Android version has no switch for it. Use Wireless debugging to change it from this device."
+    fun fixSentence(context: Context, sdk: Int = Build.VERSION.SDK_INT): String =
+        context.getString(if (hasDeveloperToggle(sdk)) R.string.phantom_fix_toggle else R.string.phantom_fix_no_toggle)

+    /** English: for the device report. */
    fun reportValue(status: PhantomProcessStatus): String = when (status) {
        PhantomProcessStatus.DISABLED -> "disabled (good - the OS will not kill the session's children)"
        PhantomProcessStatus.ENABLED -> "ENABLED (the OS may kill the session with no log; turn off Restrict child processes)"
@@ -0,0 +1,72 @@
+package com.droiddeck.launcher.core
+
+/**
+ * The one set of rules that keeps URLs and tokens out of anything the app writes or shares: the
+ * stores' log ([com.droiddeck.launcher.stores.StoreLog.redactLine]) and the last pass over every
+ * text file in a shared log zip ([LogRedactor.redactForShare]).
+ *
+ * - Every URL loses its query, fragment and `user:password@`. [Urls.SHORT] then keeps only the host
+ *   and a plain first path segment (the stores' lines, where a GOG secure link carries its token in
+ *   the path); [Urls.KEEP_PATH] keeps the path but blanks any segment that carries a token.
+ * - Outside URLs, the values of token-like keys (`token`, `__token__`, `f_token`, `hdnts`, access /
+ *   refresh / id tokens; exchange and authorization codes of four characters or more, and a bare
+ *   `code=` where it is one: in a query string or on a line with OAuth keys such as `client_id`,
+ *   `redirect_uri` or `state`, never an 8-hex exception code like Proton's `code=c0000005`) and of
+ *   Authorization / Cookie headers are blanked with [mark].
+ *
+ * A line already scrubbed comes out unchanged.
+ */
+object SecretScrub {
+    enum class Urls { SHORT, KEEP_PATH }
+
+    private val URL = Regex("""[A-Za-z][A-Za-z0-9+.\-]*://[^\s"'<>]+""")
+    private val SAFE_SEGMENT = Regex("""[A-Za-z0-9._\-]{1,40}""")
+    private val TOKEN_SEGMENT = Regex("""(?i)(token|hdnts|hmac|signature|sig|exp)=""")
+    private val TOKEN = Regex("""(?i)(?<![A-Za-z0-9_])(__token__|f_token|hdnts|access_token|refresh_token|id_token|token)(["']?\s*[=:]\s*["']?)[^\s&;,"'<>}]+""")
+    /** Codes that are only ever OAuth grants. */
+    private val GRANT_CODE = Regex("""(?i)(?<![A-Za-z0-9_])(exchange_code|authorization_?code)(["']?\s*=\s*["']?)[^\s&;,"'<>}]{4,}""")
+    /** A bare `code=`: a grant only right after `?` / `&` (a query string) or beside OAuth keys ([OAUTH_CONTEXT]). */
+    private val CODE = Regex("""(?i)(?<![A-Za-z0-9_])(code)(["']?\s*=\s*["']?)([^\s&;,"'<>}]{4,})""")
+    private val OAUTH_CONTEXT = Regex("""(?i)(?<![A-Za-z0-9_])(client_id|client_secret|redirect_uri|state|grant_type|response_type|access_token|refresh_token|id_token)["']?\s*[=:]""")
+    /** A Windows exception or status code (`code=c0000005`, `code=0x80000003`): never a grant. */
+    private val STATUS_CODE = Regex("""(?i)(0x)?[0-9a-f]{8}""")
+    private val HEADER = Regex("""(?i)\b(authorization|cookie|set-cookie)(\s*[:=]\s*).+""")
+
+    fun scrub(text: String, urls: Urls, mark: String): String {
+        var out = URL.replace(text) { m -> if (urls == Urls.SHORT) short(m.value) else keepPath(m.value, mark) }
+        out = TOKEN.replace(out) { m -> m.groupValues[1] + m.groupValues[2] + mark }
+        out = GRANT_CODE.replace(out) { m -> m.groupValues[1] + m.groupValues[2] + mark }
+        val oauth = OAUTH_CONTEXT.containsMatchIn(text)
+        val src = out
+        out = CODE.replace(src) { m ->
+            val inQuery = m.range.first > 0 && src[m.range.first - 1] in "?&"
+            val grant = !STATUS_CODE.matches(m.groupValues[3]) && (oauth || inQuery)
+            if (grant) m.groupValues[1] + m.groupValues[2] + mark else m.value
+        }
+        out = HEADER.replace(out) { m -> m.groupValues[1] + m.groupValues[2] + mark }
+        return out
+    }
+
+    private fun split(url: String): Triple<String, String, String?> {
+        val schemeEnd = url.indexOf("://")
+        val rest = url.substring(schemeEnd + 3).substringBefore('#').substringBefore('?')
+        val slash = rest.indexOf('/')
+        val authority = (if (slash >= 0) rest.substring(0, slash) else rest).substringAfterLast('@')
+        return Triple(url.substring(0, schemeEnd), authority, if (slash >= 0) rest.substring(slash + 1) else null)
+    }
+
+    private fun short(url: String): String {
+        val (scheme, authority, path) = split(url)
+        if (path == null) return "$scheme://$authority"
+        val first = path.substringBefore('/')
+        if (first.isEmpty()) return "$scheme://$authority/"
+        val shown = if (SAFE_SEGMENT.matches(first)) first else "…"
+        return "$scheme://$authority/$shown" + if (path.length > first.length && shown != "…") "/…" else ""
+    }
+
+    private fun keepPath(url: String, mark: String): String {
+        val (scheme, authority, path) = split(url)
+        val clean = path?.split('/')?.joinToString("/") { seg -> if (TOKEN_SEGMENT.containsMatchIn(seg)) mark else seg }
+        return "$scheme://$authority" + (clean?.let { "/$it" } ?: "")
+    }
+}
@@ -3,6 +3,7 @@ package com.droiddeck.launcher.core
 import android.content.Context
 import android.net.nsd.NsdManager
 import android.net.nsd.NsdServiceInfo
+import com.droiddeck.launcher.R
 import com.flyfishxu.kadb.Kadb
 import com.flyfishxu.kadb.cert.KadbCert
 import java.io.File
@@ -37,21 +38,21 @@ object WirelessAdbFix {

        val identity = KadbCert.get(notAfter = System.currentTimeMillis() + TimeUnit.DAYS.toMillis(3650))
        KadbCert.set(identity.first, identity.second)
-        writeAtomically(cert, identity.first)
-        writeAtomically(key, identity.second)
+        writeAtomically(context, cert, identity.first)
+        writeAtomically(context, key, identity.second)
    }

-    private fun writeAtomically(destination: File, contents: ByteArray) {
+    private fun writeAtomically(context: Context, destination: File, contents: ByteArray) {
        val temporary = File(destination.parentFile, "${destination.name}.tmp")
        temporary.writeBytes(contents)
-        check(temporary.renameTo(destination)) { "Could not save Wireless debugging identity" }
+        check(temporary.renameTo(destination)) { context.getString(R.string.adbfix_save_failed) }
    }

    suspend fun pair(context: Context, host: String, port: Int, pairingCode: String) {
        loadOrCreateIdentity(context.applicationContext)
        Kadb.pair(host, port, pairingCode, "DroidDeck")
-        writeAtomically(File(context.noBackupFilesDir, HOST_FILE), host.toByteArray())
-        writeAtomically(File(context.noBackupFilesDir, CONNECTION_FILE), ByteArray(0))
+        writeAtomically(context, File(context.noBackupFilesDir, HOST_FILE), host.toByteArray())
+        writeAtomically(context, File(context.noBackupFilesDir, CONNECTION_FILE), ByteArray(0))
    }

    private fun savedConnection(context: Context): SavedConnection? {
@@ -73,6 +74,7 @@ object WirelessAdbFix {

    private fun saveConnection(context: Context, host: String, port: Int) {
        writeAtomically(
+            context,
            File(context.applicationContext.noBackupFilesDir, CONNECTION_FILE),
            "$host\n$port".toByteArray(),
        )
@@ -171,11 +173,11 @@ object WirelessAdbFix {
        Kadb.create(host, port).use { adb ->
            PhantomProcessLimit.shellCommands(enabled).forEach { command ->
                val change = adb.shell(command)
-                check(change.exitCode == 0) { change.allOutput.ifBlank { "ADB command failed (${change.exitCode})" } }
+                check(change.exitCode == 0) { change.allOutput.ifBlank { context.getString(R.string.adbfix_command_failed, change.exitCode) } }
            }
            val result = adb.shell(PhantomProcessLimit.verifyCommand())
            check(result.exitCode == 0 && PhantomProcessLimit.verified(result.output, enabled)) {
-                "Android did not confirm the child-process limit was changed: ${result.allOutput.trim()}"
+                context.getString(R.string.adbfix_not_confirmed, result.allOutput.trim())
            }
        }
        if (PhantomProcessLimit.usesDeviceConfig()) PhantomProcessLimit.rememberAndroid12(context, !enabled)
@@ -186,7 +188,7 @@ object WirelessAdbFix {
    fun setUsingSavedPairing(context: Context, enabled: Boolean) {
        val appContext = context.applicationContext
        val saved = savedConnection(appContext)
-            ?: error("No Wireless debugging pairing is saved")
+            ?: error(appContext.getString(R.string.adbfix_no_pairing))
        val cachedPort = saved.port
        if (cachedPort != null) {
            val cachedResult = runCatching {
@@ -201,7 +203,7 @@ object WirelessAdbFix {
            }
        } else {
            val discoveredPort = findConnectPort(appContext, saved.host)
-                ?: error("Enter the current Wireless debugging IP address & Port")
+                ?: error(appContext.getString(R.string.adbfix_enter_address))
            setChildProcessLimit(appContext, saved.host, discoveredPort, enabled)
        }
    }
@@ -20,6 +20,9 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow

 class WirelessAdbPairingService : Service() {
+    override fun attachBaseContext(newBase: android.content.Context) =
+        super.attachBaseContext(com.droiddeck.launcher.core.AppLanguage.wrap(newBase))
+
    sealed interface Stage {
        data object Idle : Stage
        data object Waiting : Stage
@@ -35,7 +38,7 @@ class WirelessAdbPairingService : Service() {
    private var pairingHost: String? = null
    private var pairingPort: Int? = null
    @Volatile private var working = false
-    private val timeout = Runnable { finish(Stage.Failed("Timed out waiting for the pairing pop-up. Try again from DroidDeck.")) }
+    private val timeout = Runnable { finish(Stage.Failed(getString(R.string.adbpair_timed_out))) }

    override fun onBind(intent: Intent?): IBinder? = null

@@ -75,13 +78,13 @@ class WirelessAdbPairingService : Service() {
            override fun onServiceLost(serviceInfo: NsdServiceInfo) = Unit
            override fun onDiscoveryStopped(serviceType: String) = Unit
            override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
-                main.post { finish(Stage.Failed("Could not look for the pairing pop-up ($errorCode). Check that Wi-Fi is on.")) }
+                main.post { finish(Stage.Failed(getString(R.string.adbpair_discovery_failed_code, errorCode))) }
            }
            override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) = Unit
        }
        runCatching { manager.discoverServices("$PAIRING_TYPE.", NsdManager.PROTOCOL_DNS_SD, listener) }
            .onSuccess { nsd = manager; discovery = listener }
-            .onFailure { finish(Stage.Failed("Could not look for the pairing pop-up: ${it.localizedMessage}")) }
+            .onFailure { finish(Stage.Failed(getString(R.string.adbpair_discovery_failed, it.localizedMessage.toString()))) }
    }

    private fun resolveListener() = object : NsdManager.ResolveListener {
@@ -107,34 +110,34 @@ class WirelessAdbPairingService : Service() {
            return
        }
        if (code.length != 6) {
-            show(Stage.CodeNeeded("Enter all 6 digits of the code"))
+            show(Stage.CodeNeeded(getString(R.string.adbpair_six_digits)))
            return
        }
        working = true
-        show(Stage.Working("Pairing…"))
+        show(Stage.Working(getString(R.string.adbpair_pairing)))
        Thread({
            val paired = runCatching { kotlinx.coroutines.runBlocking { WirelessAdbFix.pair(this@WirelessAdbPairingService, WirelessAdbFix.LOOPBACK, port, code) } }
            if (paired.isFailure) {
                main.post {
                    working = false
                    pairingPort = null
-                    show(Stage.CodeNeeded("That code didn't work. Open the pairing pop-up again and enter its new code."))
+                    show(Stage.CodeNeeded(getString(R.string.adbpair_code_rejected)))
                }
                return@Thread
            }
            main.post {
                stopDiscovery()
-                show(Stage.Working("Paired. Connecting…"))
+                show(Stage.Working(getString(R.string.adbpair_connecting)))
            }
            val result = runCatching {
                val connectPort = WirelessAdbFix.localConnectPort(this)
-                    ?: error("Paired, but the Wireless debugging port was not found. Keep Wireless debugging on and try again.")
-                main.post { show(Stage.Working("Applying the setting…")) }
+                    ?: error(getString(R.string.adbpair_port_not_found))
+                main.post { show(Stage.Working(getString(R.string.adbpair_applying))) }
                WirelessAdbFix.setChildProcessLimit(this, WirelessAdbFix.LOOPBACK, connectPort, false)
            }
            main.post {
                working = false
-                finish(result.exceptionOrNull()?.let { Stage.Failed(it.localizedMessage ?: "Wireless debugging command failed") } ?: Stage.Done)
+                finish(result.exceptionOrNull()?.let { Stage.Failed(it.localizedMessage ?: getString(R.string.adbpair_command_failed)) } ?: Stage.Done)
            }
        }, "wireless-adb-pairing").start()
    }
@@ -174,9 +177,9 @@ class WirelessAdbPairingService : Service() {

    private fun notification(stage: Stage): Notification {
        val manager = getSystemService(NotificationManager::class.java)
-        manager?.createNotificationChannel(NotificationChannel(CHANNEL_ID, "Wireless debugging setup",
+        manager?.createNotificationChannel(NotificationChannel(CHANNEL_ID, getString(R.string.adbpair_channel_name),
            NotificationManager.IMPORTANCE_HIGH).apply {
-            description = "Asks for the Wireless debugging pairing code while Settings is open"
+            description = getString(R.string.adbpair_channel_description)
            setShowBadge(false)
            setSound(null, null)
            enableVibration(false)
@@ -193,41 +196,40 @@ class WirelessAdbPairingService : Service() {
            .setCategory(Notification.CATEGORY_STATUS)
        when (stage) {
            Stage.Waiting, Stage.Idle -> builder
-                .setContentTitle("Pair Wireless debugging")
-                .setContentText("Turn on Wireless debugging, then tap “Pair device with pairing code”.")
-                .setStyle(Notification.BigTextStyle().bigText(
-                    "Turn on Wireless debugging, then tap “Pair device with pairing code”. Stay in Settings: the code goes in this notification."))
+                .setContentTitle(getString(R.string.adbpair_title_pair))
+                .setContentText(getString(R.string.adbpair_waiting_text))
+                .setStyle(Notification.BigTextStyle().bigText(getString(R.string.adbpair_waiting_long)))
                .setOngoing(true)
                .setOnlyAlertOnce(true)
-                .addAction(Notification.Action.Builder(null, "Cancel", cancel).build())
+                .addAction(Notification.Action.Builder(null, getString(R.string.common_cancel), cancel).build())
            is Stage.CodeNeeded -> {
                val reply = PendingIntent.getService(this, 2,
                    Intent(this, WirelessAdbPairingService::class.java).setAction(ACTION_CODE),
                    if (Build.VERSION.SDK_INT >= 31) PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
                    else PendingIntent.FLAG_UPDATE_CURRENT)
-                val input = RemoteInput.Builder(KEY_CODE).setLabel("6-digit pairing code").build()
-                val text = stage.error ?: "Tap Enter code and type the 6 digits shown in Settings."
+                val input = RemoteInput.Builder(KEY_CODE).setLabel(getString(R.string.adbpair_code_label)).build()
+                val text = stage.error ?: getString(R.string.adbpair_code_hint)
                builder
-                    .setContentTitle(if (stage.error == null) "Enter the Wi-Fi pairing code" else "Try the code again")
+                    .setContentTitle(getString(if (stage.error == null) R.string.adbpair_title_code else R.string.adbpair_title_retry))
                    .setContentText(text)
                    .setStyle(Notification.BigTextStyle().bigText(text))
                    .setOngoing(true)
-                    .addAction(Notification.Action.Builder(null, "Enter code", reply).addRemoteInput(input).build())
-                    .addAction(Notification.Action.Builder(null, "Cancel", cancel).build())
+                    .addAction(Notification.Action.Builder(null, getString(R.string.adbpair_enter_code), reply).addRemoteInput(input).build())
+                    .addAction(Notification.Action.Builder(null, getString(R.string.common_cancel), cancel).build())
            }
            is Stage.Working -> builder
-                .setContentTitle("Setting up Steam")
+                .setContentTitle(getString(R.string.adbpair_title_working))
                .setContentText(stage.step)
                .setProgress(0, 0, true)
                .setOngoing(true)
                .setOnlyAlertOnce(true)
            Stage.Done -> builder
-                .setContentTitle("Steam is ready")
-                .setContentText("Tap to go back to DroidDeck. You can turn Wireless debugging off now.")
-                .setStyle(Notification.BigTextStyle().bigText("Tap to go back to DroidDeck. You can turn Wireless debugging off now."))
+                .setContentTitle(getString(R.string.adbpair_title_done))
+                .setContentText(getString(R.string.adbpair_done_text))
+                .setStyle(Notification.BigTextStyle().bigText(getString(R.string.adbpair_done_text)))
                .setAutoCancel(true)
            is Stage.Failed -> builder
-                .setContentTitle("Wireless debugging setup stopped")
+                .setContentTitle(getString(R.string.adbpair_title_failed))
                .setContentText(stage.error)
                .setStyle(Notification.BigTextStyle().bigText(stage.error))
                .setAutoCancel(true)
@@ -56,6 +56,8 @@ data class RailItem(
    val selected: Boolean,
    /** >0 shows a small accent count badge on the item's icon (expanded and collapsed). */
    val badge: Int = 0,
+    /** The under-icon label when the rail is collapsed, for names too long to fit; null derives one. */
+    val shortLabel: String? = null,
    // onClick stays LAST so existing call sites can pass it as a trailing lambda; badge is an
    // optional named param before it (default 0).
    val onClick: () -> Unit,
@@ -73,7 +75,6 @@ private fun collapsedLabel(label: String): String {
    when (label) {
        "ENVIROMENT" -> return "ENVIRON"        // the app's existing (mis)spelling, kept uppercase
        "WIN COMPONENTS" -> return "WIN COMP"
-        "Downloads" -> return "Downlds"
    }
    if (label.contains(' ')) return label       // multi-word → wraps to 2 lines
    return if (label.length > 9) label.take(8) + "…" else label
@@ -317,7 +318,7 @@ fun CollapsibleRail(
                        RailItemIcon(item, iconTint)
                        Spacer(Modifier.height(2.dp))
                        Text(
-                            collapsedLabel(item.label),
+                            item.shortLabel ?: collapsedLabel(item.label),
                            color = labelColor,
                            fontSize = 7.5.sp,
                            lineHeight = 8.5.sp,
@@ -15,14 +15,20 @@ import java.io.File

 /** The File Manager as a screen of its own, from the Files tile on the main screen. */
 class FileManagerActivity : ComponentActivity() {
+    override fun attachBaseContext(newBase: android.content.Context) {
+        super.attachBaseContext(newBase)
+        com.droiddeck.launcher.core.AppLanguage.applyTo(this, newBase)
+    }
+
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
+        requestedOrientation = com.droiddeck.launcher.session.SessionPrefs.orientation(this)
        if (checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), 1)
        }
        val initialDir = intent.getStringExtra(EXTRA_START_DIR)?.let(::File)
        setContent {
-            DroidDeckTheme {
+            DroidDeckTheme(appScale = com.droiddeck.launcher.core.AppUiPrefs.scale(this)) {
                Surface(modifier = Modifier.fillMaxSize().systemBarsPadding(), color = MaterialTheme.colorScheme.background) {
                    FileManagerScreen(initialDir = initialDir)
                }
@@ -22,6 +22,7 @@ import androidx.compose.foundation.lazy.grid.items
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.ArrowUpward
 import androidx.compose.material.icons.filled.Checklist
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.FileCopy
@@ -61,6 +62,7 @@ import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.graphics.vector.rememberVectorPainter
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
 import coil.compose.AsyncImage
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
@@ -107,7 +109,7 @@ private fun FileContextMenuItems(
 ) {
    val isDir = file.isDirectory
    DropdownMenuItem(
-        text = { Text("Select") },
+        text = { Text(stringResource(R.string.fm_select)) },
        leadingIcon = { Icon(Icons.Filled.Checklist, null, tint = MaterialTheme.colorScheme.primary) },
        onClick = { onDismissMenu(); onSelect() },
    )
@@ -115,7 +117,7 @@ private fun FileContextMenuItems(
    // Properties: basic info + Read-only / Hidden toggles, for ANY file or folder (handy for config
    // files like .txt/.cfg/.ini). Kept near the top since it's a common reason to open this menu.
    DropdownMenuItem(
-        text = { Text("Properties") },
+        text = { Text(stringResource(R.string.fm_properties)) },
        leadingIcon = { Icon(Icons.Filled.Info, null, tint = MaterialTheme.colorScheme.primary) },
        onClick = { onDismissMenu(); onProperties() },
    )
@@ -123,7 +125,7 @@ private fun FileContextMenuItems(
    // Favorites are directories - only folders get the pin toggle.
    if (isDir) {
        DropdownMenuItem(
-            text = { Text(if (isFavorite) "Remove from Favorites" else "Add to Favorites") },
+            text = { Text(if (isFavorite) stringResource(R.string.fm_favorite_remove) else stringResource(R.string.fm_favorite_add)) },
            leadingIcon = {
                Icon(
                    if (isFavorite) Icons.Filled.Star else Icons.Filled.StarBorder,
@@ -136,25 +138,25 @@ private fun FileContextMenuItems(
        MenuItemDivider()
    }
    DropdownMenuItem(
-        text = { Text("Rename") },
+        text = { Text(stringResource(R.string.fm_rename)) },
        leadingIcon = { Icon(Icons.Filled.Edit, null, tint = MaterialTheme.colorScheme.primary) },
        onClick = { onDismissMenu(); onRename() },
    )
    MenuItemDivider()
    DropdownMenuItem(
-        text = { Text("Copy") },
+        text = { Text(stringResource(R.string.fm_copy)) },
        leadingIcon = { Icon(Icons.Filled.FileCopy, null, tint = MaterialTheme.colorScheme.primary) },
        onClick = { onDismissMenu(); onCopy() },
    )
    MenuItemDivider()
    DropdownMenuItem(
-        text = { Text("Cut") },
+        text = { Text(stringResource(R.string.fm_cut)) },
        leadingIcon = { Icon(Icons.Filled.ContentCut, null, tint = MaterialTheme.colorScheme.primary) },
        onClick = { onDismissMenu(); onCut() },
    )
    MenuItemDivider()
    DropdownMenuItem(
-        text = { Text("Delete") },
+        text = { Text(stringResource(R.string.common_delete)) },
        leadingIcon = { Icon(Icons.Filled.Delete, null, tint = MaterialTheme.colorScheme.primary) },
        onClick = { onDismissMenu(); onDelete() },
    )
@@ -184,6 +186,7 @@ internal fun FileItemRow(
    onProperties: () -> Unit = {},
 ) {
    val dateFormat = remember { SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.getDefault()) }
+    val context = LocalContext.current
    val isDir = file.isDirectory
    val isExe = !isDir && file.name.lowercase().let { it.endsWith(".exe") || it.endsWith(".bat") || it.endsWith(".msi") || it.endsWith(".sh") }
    // Image files show a real thumbnail instead of the generic file icon (handy when picking a
@@ -276,7 +279,7 @@ internal fun FileItemRow(
                )
                Text(
                    text = buildString {
-                        if (!isDir) append(FileOps.formatBytes(file.length())).append("  \u2022  ")
+                        if (!isDir) append(FileOps.formatBytes(context, file.length())).append("  \u2022  ")
                        append(dateFormat.format(Date(file.lastModified())))
                    },
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
@@ -285,7 +288,7 @@ internal fun FileItemRow(
            }
            if (showActions) Box {
                IconButton(onClick = onMenu) {
-                    Icon(Icons.Filled.MoreVert, "Actions", tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(20.dp))
+                    Icon(Icons.Filled.MoreVert, stringResource(R.string.fm_actions), tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(20.dp))
                }
                DropdownMenu(
                    expanded = menuExpanded,
@@ -310,6 +313,47 @@ internal fun FileItemRow(
    }
 }

+// The ".." row at the top of a folder: one level up, styled like a folder row so it reads as part
+// of the list and takes controller focus the same way.
+@Composable
+internal fun ParentFolderRow(compact: Boolean = false, onTap: () -> Unit) {
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 12.dp, vertical = 3.dp)
+            .clickable(onClick = onTap),
+        shape = RoundedCornerShape(10.dp),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer),
+        border = BorderStroke(1.dp, MaterialTheme.colorScheme.outline),
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier.padding(horizontal = 12.dp, vertical = if (compact) 3.dp else 8.dp),
+        ) {
+            Icon(
+                imageVector = Icons.Filled.ArrowUpward,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.size(if (compact) 24.dp else 36.dp),
+            )
+            Spacer(Modifier.width(10.dp))
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = "..",
+                    color = MaterialTheme.colorScheme.onBackground,
+                    fontSize = 14.sp,
+                    fontWeight = FontWeight.Medium,
+                )
+                Text(
+                    text = stringResource(R.string.fm_up_one_level),
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    fontSize = 12.sp,
+                )
+            }
+        }
+    }
+}
+
 // Dedicated Favorites list that replaces the file list while the star toggle is on.
 // Reads the store keyed on [favTick] so it recomposes after any pin/unpin.
@Composable
@@ -338,7 +382,7 @@ internal fun FavoritesList(
                    .padding(horizontal = 16.dp, vertical = 8.dp),
            ) {
                Text(
-                    text = "Favorites",
+                    text = stringResource(R.string.fm_favorites),
                    color = MaterialTheme.colorScheme.onBackground,
                    fontSize = 15.sp,
                    fontWeight = FontWeight.SemiBold,
@@ -351,7 +395,7 @@ internal fun FavoritesList(
                    Icon(Icons.Filled.PushPin, null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(16.dp))
                    Spacer(Modifier.width(6.dp))
                    Text(
-                        text = "Pin current folder",
+                        text = stringResource(R.string.fm_pin_current),
                        color = MaterialTheme.colorScheme.primary,
                        fontSize = 13.sp,
                    )
@@ -366,7 +410,7 @@ internal fun FavoritesList(
                    contentAlignment = Alignment.Center,
                ) {
                    Text(
-                        text = "No favorites yet - pin a folder with its ⋮ menu to jump back here fast.",
+                        text = stringResource(R.string.fm_no_favorites),
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        fontSize = 13.sp,
                        modifier = Modifier.padding(horizontal = 32.dp),
@@ -431,7 +475,7 @@ private fun FavoriteCard(
                // Origin line: coloured drive badge + source description.
                Row(verticalAlignment = Alignment.CenterVertically) {
                    Text(
-                        text = loc.driveLabel,
+                        text = stringResource(loc.driveLabel),
                        color = badgeFg,
                        fontSize = 11.sp,
                        fontWeight = FontWeight.Bold,
@@ -443,9 +487,9 @@ private fun FavoriteCard(
                    Spacer(Modifier.width(6.dp))
                    Text(
                        text = when (loc.storage) {
-                            FavStorage.INTERNAL -> "Internal storage"
-                            FavStorage.SD -> "SD card"
-                            FavStorage.OTHER -> "Storage"
+                            FavStorage.INTERNAL -> stringResource(R.string.games_internal)
+                            FavStorage.SD -> stringResource(R.string.fm_drive_sd)
+                            FavStorage.OTHER -> stringResource(R.string.fm_drive_storage)
                        },
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        fontSize = 12.sp,
@@ -464,7 +508,7 @@ private fun FavoriteCard(
            IconButton(onClick = onUnpin) {
                Icon(
                    Icons.Filled.Star,
-                    contentDescription = "Remove from favorites",
+                    contentDescription = stringResource(R.string.fm_unpin_favorite),
                    tint = MaterialTheme.colorScheme.primary,
                    modifier = Modifier.size(22.dp),
                )
@@ -8,6 +8,8 @@ import androidx.compose.material.icons.filled.Image
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.text.style.TextOverflow
+import androidx.annotation.StringRes
+import com.droiddeck.launcher.R
 import java.io.File

 // The File Manager's non-UI helpers: sorting, paths, conflict choices and favourite locations.
@@ -77,7 +79,7 @@ enum class FavStorage { INTERNAL, SD, OTHER }

 data class FavLocation(
    val storage: FavStorage,
-    val driveLabel: String,       // "Internal", "SD card", or "Storage"
+    @StringRes val driveLabel: Int, // Internal, SD card, or Storage
    val displayPath: String       // the unix absolute path
 )

@@ -87,15 +89,20 @@ fun describeLocation(file: File): FavLocation {

    val internal = "/storage/emulated/0"
    if (abs == internal || abs.startsWith("$internal/")) {
-        return FavLocation(FavStorage.INTERNAL, "Internal", abs)
+        return FavLocation(FavStorage.INTERNAL, R.string.fm_drive_internal, abs)
    }

    if (abs.startsWith("/storage/")) {
        val name = abs.removePrefix("/storage/").substringBefore('/')
        if (name.isNotEmpty() && name != "emulated" && name != "self") {
-            return FavLocation(FavStorage.SD, "SD card", abs)
+            return FavLocation(FavStorage.SD, R.string.fm_drive_sd, abs)
        }
    }

-    return FavLocation(FavStorage.OTHER, "Storage", abs)
+    // The Linux system's root (the app's files/linuxfs, the sessions' /) and anything under it.
+    if (Regex("/files/linuxfs(/|$)").containsMatchIn(abs)) {
+        return FavLocation(FavStorage.OTHER, R.string.fm_drive_linux, abs)
+    }
+
+    return FavLocation(FavStorage.OTHER, R.string.fm_drive_storage, abs)
 }
@@ -22,6 +22,7 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.GridItemSpan
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.grid.items
 import androidx.compose.foundation.lazy.rememberLazyListState
@@ -41,6 +42,7 @@ import androidx.compose.material.icons.filled.ViewList
 import androidx.compose.material.icons.filled.StarBorder
 import androidx.compose.material.icons.filled.Storage
 import androidx.compose.material.icons.filled.Smartphone
+import androidx.compose.material.icons.filled.Terminal
 import androidx.compose.material.icons.filled.Download
 import androidx.compose.material.icons.filled.Description
 import androidx.compose.material.icons.filled.Image
@@ -76,6 +78,9 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import com.droiddeck.launcher.R
 import androidx.compose.ui.platform.LocalLifecycleOwner
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
@@ -140,7 +145,14 @@ fun FileManagerScreen(
                val name = abs.removePrefix("/storage/").substringBefore('/')
                if (name.isNotEmpty() && name != "emulated" && name != "self") File("/storage/$name") else rootDir
            }
-            else -> rootDir
+            // A game's own folder or Proton prefix lives in the app's private storage, which has no
+            // volume above it: floor at the app's files dir so up/back still reach the library roots.
+            else -> {
+                val appFiles = runCatching { context.filesDir.canonicalPath }.getOrNull()
+                generateSequence(rootDir) { it.parentFile }
+                    .firstOrNull { appFiles != null && runCatching { it.canonicalPath }.getOrNull() == appFiles }
+                    ?: rootDir
+            }
        }
        mutableStateOf(vol)
    }
@@ -229,7 +241,9 @@ fun FileManagerScreen(
        loadDirectory(dir)
    }

-    LaunchedEffect(Unit) { openDrive(rootDir) }
+    // Open the start dir without openDrive(): that pins the floor to the start dir itself, which
+    // greyed out up/back whenever the manager was opened at a game's folder.
+    LaunchedEffect(Unit) { loadDirectory(rootDir) }

    // System/gesture Back: while the Favorites view is open it closes that first; otherwise
    // it goes up one directory. Only at the current drive's root with Favorites closed is it
@@ -243,6 +257,14 @@ fun FileManagerScreen(
        if (parent != null && parent.exists()) loadDirectory(parent)
    }

+    // One level up, never above the current drive's root: shared by the toolbar arrow and the
+    // ".." row at the top of the list.
+    val canGoUp = currentDir != currentRoot && currentDir.parentFile?.exists() == true
+    fun goUp() {
+        val parent = currentDir.parentFile
+        if (currentDir != currentRoot && parent != null && parent.exists()) loadDirectory(parent)
+    }
+
    // Resolve a non-colliding destination in [dir] for [name] (foo.txt -> "foo (1).txt").
    fun uniqueDestination(dir: File, name: String): File {
        var candidate = File(dir, name)
@@ -261,11 +283,11 @@ fun FileManagerScreen(
    fun performDelete(file: File) {
        scope.launch {
            isOperationRunning = true
-            operationLabel = "Deleting..."
+            operationLabel = context.getString(R.string.fm_op_deleting)
            val ok = withContext(Dispatchers.IO) { FileOps.delete(file) }
            isOperationRunning = false
            loadDirectory(currentDir, resetScroll = false)
-            if (!ok) Toast.makeText(context, "Delete failed", Toast.LENGTH_SHORT).show()
+            if (!ok) Toast.makeText(context, R.string.fm_delete_failed, Toast.LENGTH_SHORT).show()
        }
    }

@@ -288,7 +310,7 @@ fun FileManagerScreen(
        operationJob = scope.launch {
            operationProgress = 0f
            operationDeterminate = true
-            operationLabel = if (cut) "Moving..." else "Copying..."
+            operationLabel = context.getString(if (cut) R.string.fm_op_moving else R.string.fm_op_copying)
            isOperationRunning = true

            var applyToAll: ConflictChoice? = null
@@ -324,10 +346,10 @@ fun FileManagerScreen(
                }

                // Progress is per item; with a batch the label carries the overall position.
-                operationLabel = buildString {
-                    append(if (cut) "Moving" else "Copying")
-                    if (sources.size > 1) append(" ${done + 1}/${sources.size}")
-                    append(" - ").append(src.name)
+                operationLabel = if (sources.size > 1) {
+                    context.getString(if (cut) R.string.fm_op_moving_batch else R.string.fm_op_copying_batch, done + 1, sources.size, src.name)
+                } else {
+                    context.getString(if (cut) R.string.fm_op_moving_item else R.string.fm_op_copying_item, src.name)
                }
                var lastPct = -1
                val onProgress = FileOps.ProgressCallback { copied, total ->
@@ -355,9 +377,9 @@ fun FileManagerScreen(
            loadDirectory(currentDir, resetScroll = false)

            val message = when {
-                failed > 0 -> "$done done, $failed failed"
-                skipped > 0 -> "$done done, $skipped skipped"
-                sources.size > 1 -> "$done items ${if (cut) "moved" else "copied"}"
+                failed > 0 -> context.getString(R.string.fm_paste_failed, done, failed)
+                skipped > 0 -> context.getString(R.string.fm_paste_skipped, done, skipped)
+                sources.size > 1 -> context.resources.getQuantityString(if (cut) R.plurals.fm_paste_moved else R.plurals.fm_paste_copied, done, done)
                else -> null
            }
            if (message != null) Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
@@ -367,32 +389,32 @@ fun FileManagerScreen(
    fun performRename(file: File, newName: String) {
        val target = File(file.parentFile, newName)
        if (target.exists()) {
-            Toast.makeText(context, "\"$newName\" already exists", Toast.LENGTH_SHORT).show()
+            Toast.makeText(context, context.getString(R.string.fm_already_exists, newName), Toast.LENGTH_SHORT).show()
            return
        }
        scope.launch {
            isOperationRunning = true
-            operationLabel = "Renaming..."
+            operationLabel = context.getString(R.string.fm_op_renaming)
            val ok = withContext(Dispatchers.IO) { file.renameTo(target) }
            isOperationRunning = false
            loadDirectory(currentDir, resetScroll = false)
-            if (!ok) Toast.makeText(context, "Rename failed", Toast.LENGTH_SHORT).show()
+            if (!ok) Toast.makeText(context, R.string.fm_rename_failed, Toast.LENGTH_SHORT).show()
        }
    }

    fun createFolder(parent: File, name: String) {
        val target = File(parent, name)
        if (target.exists()) {
-            Toast.makeText(context, "\"$name\" already exists", Toast.LENGTH_SHORT).show()
+            Toast.makeText(context, context.getString(R.string.fm_already_exists, name), Toast.LENGTH_SHORT).show()
            return
        }
        scope.launch {
            isOperationRunning = true
-            operationLabel = "Creating folder..."
+            operationLabel = context.getString(R.string.fm_op_creating_folder)
            val ok = withContext(Dispatchers.IO) { target.mkdirs() }
            isOperationRunning = false
            loadDirectory(currentDir, resetScroll = false)
-            if (!ok) Toast.makeText(context, "Could not create folder", Toast.LENGTH_SHORT).show()
+            if (!ok) Toast.makeText(context, R.string.fm_create_folder_failed, Toast.LENGTH_SHORT).show()
        }
    }

@@ -409,6 +431,9 @@ fun FileManagerScreen(
        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
    }
    val drives = remember(storageTick) { StorageRoots.list(context) }
+    val linuxRoot = remember(storageTick) {
+        com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(context).takeIf { File(it, "usr").isDirectory }
+    }

    // ── Dialogs ──

@@ -416,12 +441,12 @@ fun FileManagerScreen(
        var folderName by remember { mutableStateOf("") }
        OutlinedAlertDialog(
            onDismissRequest = { showNewFolderDialog = false },
-            title = { Text("New Folder") },
+            title = { Text(stringResource(R.string.fm_new_folder)) },
            text = {
                OutlinedTextField(
                    value = folderName,
                    onValueChange = { folderName = it },
-                    label = { Text("Folder name") },
+                    label = { Text(stringResource(R.string.fm_folder_name)) },
                    singleLine = true,
                )
            },
@@ -429,9 +454,9 @@ fun FileManagerScreen(
                TextButton(onClick = {
                    showNewFolderDialog = false
                    if (folderName.isNotBlank()) createFolder(currentDir, folderName)
-                }) { Text("Create") }
+                }) { Text(stringResource(R.string.fm_create)) }
            },
-            dismissButton = { TextButton(onClick = { showNewFolderDialog = false }) { Text("Cancel") } },
+            dismissButton = { TextButton(onClick = { showNewFolderDialog = false }) { Text(stringResource(R.string.common_cancel)) } },
        )
    }

@@ -439,12 +464,12 @@ fun FileManagerScreen(
        var newName by remember(renameTarget) { mutableStateOf(renameTarget?.name ?: "") }
        OutlinedAlertDialog(
            onDismissRequest = { renameTarget = null },
-            title = { Text("Rename") },
+            title = { Text(stringResource(R.string.fm_rename)) },
            text = {
                OutlinedTextField(
                    value = newName,
                    onValueChange = { newName = it },
-                    label = { Text("New name") },
+                    label = { Text(stringResource(R.string.fm_new_name)) },
                    singleLine = true,
                )
            },
@@ -453,9 +478,9 @@ fun FileManagerScreen(
                    val file = renameTarget
                    renameTarget = null
                    if (file != null && newName.isNotBlank()) performRename(file, newName)
-                }) { Text("Rename") }
+                }) { Text(stringResource(R.string.fm_rename)) }
            },
-            dismissButton = { TextButton(onClick = { renameTarget = null }) { Text("Cancel") } },
+            dismissButton = { TextButton(onClick = { renameTarget = null }) { Text(stringResource(R.string.common_cancel)) } },
        )
    }

@@ -473,15 +498,15 @@ fun FileManagerScreen(
        val file = selectedEntry ?: return
        OutlinedAlertDialog(
            onDismissRequest = { selectedEntry = null },
-            title = { Text("Delete?") },
-            text = { Text("Delete \"${file.name}\" permanently?") },
+            title = { Text(stringResource(R.string.fm_delete_title)) },
+            text = { Text(stringResource(R.string.fm_delete_text, file.name)) },
            confirmButton = {
                TextButton(onClick = {
                    selectedEntry = null
                    performDelete(file)
-                }) { Text("Delete") }
+                }) { Text(stringResource(R.string.common_delete)) }
            },
-            dismissButton = { TextButton(onClick = { selectedEntry = null }) { Text("Cancel") } },
+            dismissButton = { TextButton(onClick = { selectedEntry = null }) { Text(stringResource(R.string.common_cancel)) } },
        )
    }

@@ -489,10 +514,10 @@ fun FileManagerScreen(
        val victims = pendingBulkDelete
        OutlinedAlertDialog(
            onDismissRequest = { pendingBulkDelete = emptyList() },
-            title = { Text("Delete ${victims.size} item${if (victims.size == 1) "" else "s"}?") },
+            title = { Text(pluralStringResource(R.plurals.fm_delete_items_title, victims.size, victims.size)) },
            text = {
                Column {
-                    Text("This can't be undone.")
+                    Text(stringResource(R.string.fm_cannot_undo))
                    Spacer(Modifier.height(6.dp))
                    // Name a few so an accidental Select-All is obvious before it's too late.
                    victims.take(5).forEach {
@@ -500,7 +525,7 @@ fun FileManagerScreen(
                    }
                    if (victims.size > 5) {
                        Text(
-                            "…and ${victims.size - 5} more",
+                            pluralStringResource(R.plurals.fm_and_more, victims.size - 5, victims.size - 5),
                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                            fontSize = 12.sp,
                        )
@@ -516,19 +541,19 @@ fun FileManagerScreen(
                        isOperationRunning = true
                        var failed = 0
                        victims.forEachIndexed { i, f ->
-                            operationLabel = "Deleting ${i + 1}/${victims.size} - ${f.name}"
+                            operationLabel = context.getString(R.string.fm_op_deleting_batch, i + 1, victims.size, f.name)
                            if (!withContext(Dispatchers.IO) { FileOps.delete(f) }) failed++
                        }
                        isOperationRunning = false
                        operationJob = null
                        loadDirectory(currentDir, resetScroll = false)
                        if (failed > 0) {
-                            Toast.makeText(context, "$failed couldn't be deleted", Toast.LENGTH_SHORT).show()
+                            Toast.makeText(context, context.resources.getQuantityString(R.plurals.fm_delete_some_failed, failed, failed), Toast.LENGTH_SHORT).show()
                        }
                    }
-                }) { Text("Delete", color = MaterialTheme.colorScheme.error) }
+                }) { Text(stringResource(R.string.common_delete), color = MaterialTheme.colorScheme.error) }
            },
-            dismissButton = { TextButton(onClick = { pendingBulkDelete = emptyList() }) { Text("Cancel") } },
+            dismissButton = { TextButton(onClick = { pendingBulkDelete = emptyList() }) { Text(stringResource(R.string.common_cancel)) } },
        )
    }

@@ -537,12 +562,12 @@ fun FileManagerScreen(
        val isDir = conflict.isDirectory
        OutlinedAlertDialog(
            onDismissRequest = { pendingConflict = null },
-            title = { Text("\"${conflict.name}\" already exists") },
+            title = { Text(stringResource(R.string.fm_already_exists, conflict.name)) },
            text = {
                Column {
                    Text(
-                        if (isDir) "Merge adds and replaces files inside the existing folder."
-                        else "Overwrite replaces the existing file.",
+                        if (isDir) stringResource(R.string.fm_conflict_merge_hint)
+                        else stringResource(R.string.fm_conflict_overwrite_hint),
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        fontSize = 12.sp,
                    )
@@ -553,15 +578,15 @@ fun FileManagerScreen(
                                checked = conflictApplyToAll,
                                onCheckedChange = { conflictApplyToAll = it },
                            )
-                            Text("Apply to all conflicts", fontSize = 12.sp)
+                            Text(stringResource(R.string.fm_conflict_apply_all), fontSize = 12.sp)
                        }
                    }
                    Spacer(Modifier.height(4.dp))
                    listOf(
                        (if (isDir) ConflictChoice.MERGE else ConflictChoice.OVERWRITE) to
-                            (if (isDir) "Merge" else "Overwrite"),
-                        ConflictChoice.KEEP_BOTH to "Keep both",
-                        ConflictChoice.SKIP to "Skip",
+                            (if (isDir) stringResource(R.string.fm_conflict_merge) else stringResource(R.string.fm_conflict_overwrite)),
+                        ConflictChoice.KEEP_BOTH to stringResource(R.string.fm_conflict_keep_both),
+                        ConflictChoice.SKIP to stringResource(R.string.fm_conflict_skip),
                    ).forEach { (choice, label) ->
                        TextButton(
                            modifier = Modifier.fillMaxWidth(),
@@ -573,7 +598,7 @@ fun FileManagerScreen(
            confirmButton = {},
            dismissButton = {
                TextButton(onClick = { conflictChoice = ConflictChoice.SKIP; pendingConflict = null }) {
-                    Text("Cancel")
+                    Text(stringResource(R.string.common_cancel))
                }
            },
        )
@@ -603,7 +628,7 @@ fun FileManagerScreen(
            ) {
                Icon(Icons.Filled.Folder, null, modifier = Modifier.size(18.dp))
                Spacer(Modifier.width(8.dp))
-                Text("Select this folder")
+                Text(stringResource(R.string.fm_select_this_folder))
            }
        }
        // ── Path bar ──
@@ -614,15 +639,11 @@ fun FileManagerScreen(
                .background(MaterialTheme.colorScheme.surfaceContainer)
                .padding(horizontal = 8.dp, vertical = 6.dp),
        ) {
-            IconButton(onClick = {
-                val parent = currentDir.parentFile
-                // Don't climb above the current drive's root.
-                if (currentDir != currentRoot && parent != null && parent.exists()) loadDirectory(parent)
-            }, enabled = currentDir != currentRoot) {
-                Icon(Icons.Filled.ArrowBack, "Back", tint = MaterialTheme.colorScheme.primary)
+            IconButton(onClick = { goUp() }, enabled = canGoUp) {
+                Icon(Icons.Filled.ArrowBack, stringResource(R.string.fm_back), tint = MaterialTheme.colorScheme.primary)
            }

-            val currentDriveLabel = describeLocation(currentDir).driveLabel
+            val currentDriveLabel = stringResource(describeLocation(currentDir).driveLabel)
            // Dim the drive chip while the Favorites list is open (it's not the active context).
            val driveChipAlpha = if (showFavorites) 0.45f else 1f
            Box {
@@ -666,13 +687,23 @@ fun FileManagerScreen(
                                } else {
                                    Toast.makeText(
                                        context,
-                                        "${drive.label} is mounted but not readable right now",
+                                        context.getString(R.string.fm_drive_not_readable, drive.label),
                                        Toast.LENGTH_SHORT,
                                    ).show()
                                }
                            },
                        )
                    }
+                    linuxRoot?.let { root ->
+                        MenuItemDivider()
+                        DropdownMenuItem(
+                            text = { Text(stringResource(R.string.fm_drive_linux)) },
+                            leadingIcon = {
+                                Icon(Icons.Filled.Terminal, null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(18.dp))
+                            },
+                            onClick = { showDriveMenu = false; openDrive(root) },
+                        )
+                    }
                }
            }

@@ -680,7 +711,7 @@ fun FileManagerScreen(

            if (showFavorites) {
                Text(
-                    text = "Favorites",
+                    text = stringResource(R.string.fm_favorites),
                    color = MaterialTheme.colorScheme.primary,
                    fontSize = 13.sp,
                    fontWeight = FontWeight.SemiBold,
@@ -718,7 +749,7 @@ fun FileManagerScreen(
                    ) {
                        Icon(Icons.Filled.CreateNewFolder, null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(16.dp))
                        Spacer(Modifier.width(5.dp))
-                        Text("New Folder", color = MaterialTheme.colorScheme.onBackground, fontSize = 12.sp)
+                        Text(stringResource(R.string.fm_new_folder), color = MaterialTheme.colorScheme.onBackground, fontSize = 12.sp)
                    }
                }
                IconButton(onClick = {
@@ -727,19 +758,19 @@ fun FileManagerScreen(
                }) {
                    Icon(
                        if (gridView) Icons.Filled.ViewList else Icons.Filled.GridView,
-                        if (gridView) "List view" else "Grid view",
+                        if (gridView) stringResource(R.string.fm_list_view) else stringResource(R.string.fm_grid_view),
                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
                    )
                }
                IconButton(onClick = { showSearch = !showSearch; if (!showSearch) searchQuery = "" }) {
-                    Icon(Icons.Filled.Search, "Search", tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                    Icon(Icons.Filled.Search, stringResource(R.string.fm_search), tint = MaterialTheme.colorScheme.onSurfaceVariant)
                }
                Box {
                    IconButton(onClick = { showSortMenu = true }) {
-                        Icon(Icons.Filled.Sort, "Sort", tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                        Icon(Icons.Filled.Sort, stringResource(R.string.fm_sort), tint = MaterialTheme.colorScheme.onSurfaceVariant)
                    }
                    DropdownMenu(expanded = showSortMenu, onDismissRequest = { showSortMenu = false }) {
-                        listOf("name" to "Name", "date" to "Date modified", "size" to "Size")
+                        listOf("name" to stringResource(R.string.fm_sort_name), "date" to stringResource(R.string.fm_sort_date), "size" to stringResource(R.string.fm_prop_size))
                            .forEach { (key, label) ->
                                DropdownMenuItem(
                                    text = {
@@ -758,7 +789,7 @@ fun FileManagerScreen(
                            }
                        HorizontalDivider(color = MaterialTheme.colorScheme.outline)
                        DropdownMenuItem(
-                            text = { Text(if (compactRows) "Comfortable rows" else "Compact rows") },
+                            text = { Text(if (compactRows) stringResource(R.string.fm_rows_comfortable) else stringResource(R.string.fm_rows_compact)) },
                            onClick = {
                                compactRows = !compactRows
                                browsePrefs.edit().putBoolean("fmCompactRows", compactRows).apply()
@@ -766,7 +797,7 @@ fun FileManagerScreen(
                            },
                        )
                        DropdownMenuItem(
-                            text = { Text(if (showHidden) "Hide hidden files" else "Show hidden files") },
+                            text = { Text(if (showHidden) stringResource(R.string.fm_hide_hidden) else stringResource(R.string.fm_show_hidden)) },
                            onClick = {
                                showHidden = !showHidden
                                browsePrefs.edit().putBoolean("fmShowHidden", showHidden).apply()
@@ -781,9 +812,9 @@ fun FileManagerScreen(
            // Star toggle: open/close the dedicated Favorites list.
            IconButton(onClick = { showFavorites = !showFavorites }) {
                if (showFavorites) {
-                    Icon(Icons.Filled.Star, "Hide favorites", tint = MaterialTheme.colorScheme.primary)
+                    Icon(Icons.Filled.Star, stringResource(R.string.fm_hide_favorites), tint = MaterialTheme.colorScheme.primary)
                } else {
-                    Icon(Icons.Filled.StarBorder, "Show favorites", tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                    Icon(Icons.Filled.StarBorder, stringResource(R.string.fm_show_favorites), tint = MaterialTheme.colorScheme.onSurfaceVariant)
                }
            }
        }
@@ -794,7 +825,7 @@ fun FileManagerScreen(
                value = searchQuery,
                onValueChange = { searchQuery = it },
                singleLine = true,
-                placeholder = { Text("Filter this folder", fontSize = 13.sp) },
+                placeholder = { Text(stringResource(R.string.fm_filter_folder), fontSize = 13.sp) },
                modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 4.dp),
            )
        }
@@ -821,7 +852,7 @@ fun FileManagerScreen(
                )
                if (freeSpace > 0) {
                    Text(
-                        "${FileOps.formatBytes(freeSpace)} free",
+                        stringResource(R.string.fm_free_space, FileOps.formatBytes(context, freeSpace)),
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        fontSize = 12.sp,
                        maxLines = 1,
@@ -842,7 +873,7 @@ fun FileManagerScreen(
                    .padding(horizontal = 12.dp, vertical = 6.dp),
            ) {
                Text(
-                    "${selectedPaths.size} selected",
+                    stringResource(R.string.fm_selected_count, selectedPaths.size),
                    color = MaterialTheme.colorScheme.onBackground,
                    fontSize = 13.sp,
                    modifier = Modifier.weight(1f),
@@ -855,7 +886,7 @@ fun FileManagerScreen(
                        else entries.map { it.absolutePath }.toSet()
                    },
                    contentPadding = selBarPadding,
-                ) { Text(if (selectedPaths.size == entries.size) "None" else "All", fontSize = 12.sp) }
+                ) { Text(if (selectedPaths.size == entries.size) stringResource(R.string.fm_select_none) else stringResource(R.string.fm_select_all), fontSize = 12.sp) }
                Spacer(Modifier.width(4.dp))
                OutlinedButton(
                    enabled = selectedPaths.isNotEmpty(),
@@ -866,7 +897,7 @@ fun FileManagerScreen(
                        selectedPaths = emptySet()
                    },
                    contentPadding = selBarPadding,
-                ) { Text("Copy", fontSize = 12.sp) }
+                ) { Text(stringResource(R.string.fm_copy), fontSize = 12.sp) }
                Spacer(Modifier.width(4.dp))
                OutlinedButton(
                    enabled = selectedPaths.isNotEmpty(),
@@ -877,19 +908,19 @@ fun FileManagerScreen(
                        selectedPaths = emptySet()
                    },
                    contentPadding = selBarPadding,
-                ) { Text("Cut", fontSize = 12.sp) }
+                ) { Text(stringResource(R.string.fm_cut), fontSize = 12.sp) }
                Spacer(Modifier.width(4.dp))
                OutlinedButton(
                    enabled = selectedPaths.isNotEmpty(),
                    onClick = { pendingBulkDelete = entries.filter { it.absolutePath in selectedPaths } },
                    contentPadding = selBarPadding,
                    border = BorderStroke(1.dp, MaterialTheme.colorScheme.error),
-                ) { Text("Delete", color = MaterialTheme.colorScheme.error, fontSize = 12.sp) }
+                ) { Text(stringResource(R.string.common_delete), color = MaterialTheme.colorScheme.error, fontSize = 12.sp) }
                Spacer(Modifier.width(4.dp))
                OutlinedButton(
                    onClick = { selectionMode = false; selectedPaths = emptySet() },
                    contentPadding = selBarPadding,
-                ) { Text("Done", fontSize = 12.sp) }
+                ) { Text(stringResource(R.string.fm_done), fontSize = 12.sp) }
            }
        }

@@ -903,16 +934,16 @@ fun FileManagerScreen(
                    .clickable { performPaste() }
                    .padding(horizontal = 16.dp, vertical = 8.dp),
            ) {
-                Icon(Icons.Filled.ContentPaste, "Paste", tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(18.dp))
+                Icon(Icons.Filled.ContentPaste, stringResource(R.string.fm_paste), tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(18.dp))
                Spacer(Modifier.width(8.dp))
                val what = if (clipboardFiles.size == 1) clipboardFiles.first().name
-                else "${clipboardFiles.size} items"
+                else pluralStringResource(R.plurals.fm_items, clipboardFiles.size, clipboardFiles.size)
                Text(
-                    "Paste $what${if (isCutOperation) " (move)" else ""} here",
+                    if (isCutOperation) stringResource(R.string.fm_paste_move_here, what) else stringResource(R.string.fm_paste_here, what),
                    color = MaterialTheme.colorScheme.onBackground, fontSize = 13.sp, modifier = Modifier.weight(1f),
                )
                TextButton(onClick = { clipboardFiles = emptyList(); isCutOperation = false }) {
-                    Text("Cancel", color = MaterialTheme.colorScheme.onSurfaceVariant, fontSize = 12.sp)
+                    Text(stringResource(R.string.common_cancel), color = MaterialTheme.colorScheme.onSurfaceVariant, fontSize = 12.sp)
                }
            }
        }
@@ -944,7 +975,7 @@ fun FileManagerScreen(
                            isOperationRunning = false
                            operationDeterminate = false
                            loadDirectory(currentDir, resetScroll = false)
-                        }) { Text("Cancel", fontSize = 12.sp) }
+                        }) { Text(stringResource(R.string.common_cancel), fontSize = 12.sp) }
                    }
                }
                Spacer(Modifier.height(4.dp))
@@ -970,38 +1001,41 @@ fun FileManagerScreen(
        // shown in pick mode (the themed picker keeps its slim layout). Built each recompose (cheap)
        // so it tracks the current drive/favourites without stale click lambdas.
        val fmRailState = rememberRailState("filemanager")
-        fun locItem(label: String, icon: androidx.compose.ui.graphics.vector.ImageVector, dir: File) =
-            RailItem(label, icon, !showFavorites && currentRoot.absolutePath == dir.absolutePath) {
+        fun locItem(label: String, icon: androidx.compose.ui.graphics.vector.ImageVector, dir: File, shortLabel: String? = null) =
+            RailItem(label, icon, !showFavorites && currentRoot.absolutePath == dir.absolutePath, shortLabel = shortLabel) {
                showFavorites = false; openDrive(dir)
            }
        val storageItems = buildList {
-            add(locItem("Internal", Icons.Filled.Smartphone, File("/storage/emulated/0")))
+            add(locItem(stringResource(R.string.fm_drive_internal), Icons.Filled.Smartphone, File("/storage/emulated/0")))
            drives.filter { it.removable }.forEach { d ->
                add(RailItem(d.label, Icons.Filled.SdStorage, !showFavorites && currentRoot.absolutePath == d.dir.absolutePath) {
                    showFavorites = false; if (d.readable) openDrive(d.dir)
                })
            }
+            // The Linux system the sessions run in: its own / (the desktop's root), once installed.
+            linuxRoot?.let { add(locItem(stringResource(R.string.fm_drive_linux), Icons.Filled.Terminal, it)) }
        }
        val quickItems = buildList {
-            File("/storage/emulated/0/Download").takeIf { it.isDirectory }?.let { add(locItem("Downloads", Icons.Filled.Download, it)) }
+            File("/storage/emulated/0/Download").takeIf { it.isDirectory }?.let { add(locItem(stringResource(R.string.fm_rail_downloads), Icons.Filled.Download, it, stringResource(R.string.fm_rail_downloads_short))) }
            // The ROMs folder chosen on the main screen: what the session shows as /root/ROMs.
            SessionPrefs.romsDir(context).takeIf { it.isNotEmpty() }?.let(::File)?.takeIf { it.isDirectory }
-                ?.let { add(locItem("ROMs", Icons.Filled.SportsEsports, it)) }
-            File("/storage/emulated/0/Download/DroidDeck").takeIf { it.isDirectory }?.let { add(locItem("Session logs", Icons.Filled.Description, it)) }
-            File("/storage/emulated/0/Pictures").takeIf { it.isDirectory }?.let { add(locItem("Pictures", Icons.Filled.Image, it)) }
+                ?.let { add(locItem(stringResource(R.string.fm_rail_roms), Icons.Filled.SportsEsports, it)) }
+            // The app's own logs folder: private, which this file manager (the app itself) can read.
+            com.droiddeck.launcher.runtime.LinuxRuntime.logDir(context).takeIf { it.isDirectory }?.let { add(locItem(stringResource(R.string.fm_rail_session_logs), Icons.Filled.Description, it)) }
+            File("/storage/emulated/0/Pictures").takeIf { it.isDirectory }?.let { add(locItem(stringResource(R.string.fm_rail_pictures), Icons.Filled.Image, it)) }
        }
        val favItems = remember(favTick) { FavoritesStore.list(context).map(::File).filter { it.exists() } }
            .map { d -> RailItem(d.name, Icons.Filled.Star, false) { showFavorites = false; openDrive(d) } }
        val locationSections = buildList {
-            add(RailSection("STORAGE", storageItems))
-            if (quickItems.isNotEmpty()) add(RailSection("QUICK", quickItems))
-            if (favItems.isNotEmpty()) add(RailSection("FAVORITES", favItems))
+            add(RailSection(stringResource(R.string.fm_rail_storage), storageItems))
+            if (quickItems.isNotEmpty()) add(RailSection(stringResource(R.string.fm_rail_quick), quickItems))
+            if (favItems.isNotEmpty()) add(RailSection(stringResource(R.string.fm_rail_favorites), favItems))
        }

        Row(modifier = Modifier.weight(1f).fillMaxWidth()) {
            // The slim picker keeps its layout: no rail.
            if (!pickMode) {
-                CollapsibleRail(state = fmRailState, title = "Files", sections = locationSections, outlinedItems = true)
+                CollapsibleRail(state = fmRailState, title = stringResource(R.string.fm_rail_title), sections = locationSections, outlinedItems = true)
            }
            Box(modifier = Modifier.weight(1f).fillMaxSize()) {
        // ── Favorites list OR file list ──
@@ -1012,7 +1046,7 @@ fun FileManagerScreen(
                onPinCurrent = {
                    FavoritesStore.add(context, currentDir.absolutePath)
                    favTick++
-                    Toast.makeText(context, "Added \"${currentDir.name}\" to Favorites", Toast.LENGTH_SHORT).show()
+                    Toast.makeText(context, context.getString(R.string.fm_favorite_added, currentDir.name), Toast.LENGTH_SHORT).show()
                },
                onJump = { dir ->
                    showFavorites = false
@@ -1021,7 +1055,7 @@ fun FileManagerScreen(
                onUnpin = { dir ->
                    FavoritesStore.remove(context, dir.absolutePath)
                    favTick++
-                    Toast.makeText(context, "Removed \"${dir.name}\" from Favorites", Toast.LENGTH_SHORT).show()
+                    Toast.makeText(context, context.getString(R.string.fm_favorite_removed, dir.name), Toast.LENGTH_SHORT).show()
                },
                modifier = Modifier.fillMaxSize(),
            )
@@ -1041,6 +1075,9 @@ fun FileManagerScreen(
                    modifier = Modifier.fillMaxSize(),
                    contentPadding = PaddingValues(8.dp),
                ) {
+                    if (canGoUp) item(key = "..", span = { GridItemSpan(maxLineSpan) }) {
+                        ParentFolderRow(compact = compactRows, onTap = { goUp() })
+                    }
                    items(shownEntries, key = { it.absolutePath }) { file ->
                        val isFav = remember(file.absolutePath, favTick) {
                            FavoritesStore.isFavorite(context, file.absolutePath)
@@ -1095,8 +1132,8 @@ fun FileManagerScreen(
                                showMenuFor = null
                                Toast.makeText(
                                    context,
-                                    if (nowFav) "Added \"${file.name}\" to Favorites"
-                                    else "Removed \"${file.name}\" from Favorites",
+                                    if (nowFav) context.getString(R.string.fm_favorite_added, file.name)
+                                    else context.getString(R.string.fm_favorite_removed, file.name),
                                    Toast.LENGTH_SHORT,
                                ).show()
                            },
@@ -1106,13 +1143,16 @@ fun FileManagerScreen(
                }
            } else
            LazyColumn(state = listState, modifier = Modifier.fillMaxSize()) {
+                if (canGoUp) item(key = "..") {
+                    ParentFolderRow(compact = compactRows, onTap = { goUp() })
+                }
                if (entries.isEmpty()) {
                    item {
                        Box(
                            modifier = Modifier.fillParentMaxSize(),
                            contentAlignment = Alignment.Center,
                        ) {
-                            Text("Empty directory", color = MaterialTheme.colorScheme.onSurfaceVariant)
+                            Text(stringResource(R.string.fm_empty_directory), color = MaterialTheme.colorScheme.onSurfaceVariant)
                        }
                    }
                } else {
@@ -1173,8 +1213,8 @@ fun FileManagerScreen(
                                showMenuFor = null
                                Toast.makeText(
                                    context,
-                                    if (nowFav) "Added \"${file.name}\" to Favorites"
-                                    else "Removed \"${file.name}\" from Favorites",
+                                    if (nowFav) context.getString(R.string.fm_favorite_added, file.name)
+                                    else context.getString(R.string.fm_favorite_removed, file.name),
                                    Toast.LENGTH_SHORT,
                                ).show()
                            },
@@ -1,6 +1,8 @@
 package com.droiddeck.launcher.files

+import android.content.Context
 import android.util.Log
+import com.droiddeck.launcher.R
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
@@ -19,9 +21,9 @@ object FileOps {
    /** Byte-accurate copy progress (copied/total bytes), reported as the copy proceeds. */
    fun interface ProgressCallback { fun onProgress(copiedBytes: Long, totalBytes: Long) }

-    fun formatBytes(bytes: Long): String {
-        if (bytes <= 0) return "0 bytes"
-        val units = arrayOf("bytes", "KB", "MB", "GB", "TB")
+    fun formatBytes(context: Context, bytes: Long): String {
+        if (bytes <= 0) return context.getString(R.string.fm_size_zero)
+        val units = arrayOf(context.getString(R.string.fm_unit_bytes), "KB", "MB", "GB", "TB")
        val group = (Math.log10(bytes.toDouble()) / Math.log10(1024.0)).toInt().coerceIn(0, units.lastIndex)
        return String.format(Locale.ENGLISH, "%.2f", bytes / Math.pow(1024.0, group.toDouble())) + " " + units[group]
    }
@@ -12,6 +12,7 @@ import androidx.compose.foundation.layout.systemBarsPadding
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.ui.Modifier
+import com.droiddeck.launcher.R
 import com.droiddeck.launcher.ui.DroidDeckTheme
 import java.io.File

@@ -26,9 +27,15 @@ import java.io.File
 *  - [EXTRA_PICKER_TITLE]      the header
 */
 class FilePickerActivity : ComponentActivity() {
+    override fun attachBaseContext(newBase: android.content.Context) {
+        super.attachBaseContext(newBase)
+        com.droiddeck.launcher.core.AppLanguage.applyTo(this, newBase)
+    }
+

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
+        requestedOrientation = com.droiddeck.launcher.session.SessionPrefs.orientation(this)
        // targetSdk 28: the old storage permission is exactly what lets us list the card.
        if (checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), 1)
@@ -43,14 +50,14 @@ class FilePickerActivity : ComponentActivity() {
            ?.let { File(it) }?.takeIf { it.isDirectory }

        setContent {
-            DroidDeckTheme {
+            DroidDeckTheme(appScale = com.droiddeck.launcher.core.AppUiPrefs.scale(this)) {
                Surface(modifier = Modifier.fillMaxSize().systemBarsPadding(), color = MaterialTheme.colorScheme.background) {
                    FileManagerScreen(
                        pickMode = true,
                        pickDirMode = pickDir,
                        pickExtensions = extensions,
                        initialDir = initialDir,
-                        pickerTitle = title ?: if (pickDir) "Choose a folder" else "Choose a file",
+                        pickerTitle = title ?: getString(if (pickDir) R.string.fm_choose_folder else R.string.fm_choose_file),
                        onPick = { file ->
                            setResult(Activity.RESULT_OK, Intent().putExtra(EXTRA_SELECTED_FILE, file.absolutePath))
                            finish()
@@ -25,6 +25,8 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import com.droiddeck.launcher.R
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
@@ -66,7 +68,7 @@ internal fun FilePropertiesDialog(

    OutlinedAlertDialog(
        onDismissRequest = onDismiss,
-        title = { Text("Properties") },
+        title = { Text(stringResource(R.string.fm_properties)) },
        text = {
            Column(modifier = Modifier.verticalScroll(rememberScrollState())) {
                // ── Basic info ──
@@ -79,14 +81,14 @@ internal fun FilePropertiesDialog(
                    overflow = TextOverflow.Ellipsis,
                )
                Spacer(Modifier.height(6.dp))
-                PropertyLine("Location", file.parent ?: "-")
+                PropertyLine(stringResource(R.string.fm_prop_location), file.parent ?: "-")
                PropertyLine(
-                    "Type",
-                    if (file.isDirectory) "Folder"
-                    else file.extension.uppercase().let { if (it.isBlank()) "File" else "$it file" },
+                    stringResource(R.string.fm_prop_type),
+                    if (file.isDirectory) stringResource(R.string.fm_type_folder)
+                    else file.extension.uppercase().let { if (it.isBlank()) stringResource(R.string.fm_type_file) else stringResource(R.string.fm_type_ext_file, it) },
                )
-                if (!file.isDirectory) PropertyLine("Size", FileOps.formatBytes(file.length()))
-                PropertyLine("Modified", dateFormat.format(Date(file.lastModified())))
+                if (!file.isDirectory) PropertyLine(stringResource(R.string.fm_prop_size), FileOps.formatBytes(context, file.length()))
+                PropertyLine(stringResource(R.string.fm_prop_modified), dateFormat.format(Date(file.lastModified())))

                Spacer(Modifier.height(10.dp))
                HorizontalDivider(color = MaterialTheme.colorScheme.outline)
@@ -95,8 +97,8 @@ internal fun FilePropertiesDialog(
                val state = attrs
                // ── Read-only ── checked when the owner can't write (Wine's FILE_ATTRIBUTE_READONLY).
                AttributeToggleRow(
-                    label = "Read-only",
-                    description = "Stops games (and Wine) from overwriting or deleting this file.",
+                    label = stringResource(R.string.fm_read_only),
+                    description = stringResource(R.string.fm_read_only_hint),
                    checked = state?.readOnly == true,
                    enabled = state != null && !busy,
                    onToggle = { want ->
@@ -108,7 +110,7 @@ internal fun FilePropertiesDialog(
                                attrs = attrs?.copy(readOnly = want)
                                onChanged()
                            } else {
-                                Toast.makeText(context, "Couldn't change Read-only", Toast.LENGTH_SHORT).show()
+                                Toast.makeText(context, R.string.fm_read_only_failed, Toast.LENGTH_SHORT).show()
                            }
                        }
                    },
@@ -117,10 +119,10 @@ internal fun FilePropertiesDialog(
                // ── Hidden ── Wine's DOS hidden bit in the user.DOSATTRIB xattr.
                val hiddenSupported = state?.hiddenSupported == true
                AttributeToggleRow(
-                    label = "Hidden",
+                    label = stringResource(R.string.fm_hidden),
                    description = if (state != null && !hiddenSupported)
-                        "This storage can't store the hidden flag."
-                    else "Marks the file hidden in Windows (Wine's hidden attribute).",
+                        stringResource(R.string.fm_hidden_unsupported)
+                    else stringResource(R.string.fm_hidden_hint),
                    checked = state?.hidden == true,
                    enabled = state != null && hiddenSupported && !busy,
                    onToggle = { want ->
@@ -134,14 +136,14 @@ internal fun FilePropertiesDialog(
                            } else {
                                // The write failed after all - disable the toggle rather than lie.
                                attrs = attrs?.copy(hiddenSupported = false)
-                                Toast.makeText(context, "Couldn't change Hidden on this storage", Toast.LENGTH_SHORT).show()
+                                Toast.makeText(context, R.string.fm_hidden_failed, Toast.LENGTH_SHORT).show()
                            }
                        }
                    },
                )
            }
        },
-        confirmButton = { TextButton(onClick = onDismiss) { Text("Done") } },
+        confirmButton = { TextButton(onClick = onDismiss) { Text(stringResource(R.string.fm_done)) } },
    )
 }

@@ -5,6 +5,7 @@ import android.os.Build
 import android.os.Environment
 import android.os.storage.StorageManager
 import android.os.storage.StorageVolume
+import com.droiddeck.launcher.R
 import java.io.File

 /**
@@ -63,7 +64,7 @@ object StorageRoots {

        // Internal storage is never removable and never absent; seed it first so it heads the menu.
        volumeOf(PRIMARY_KEY).apply {
-            label = "Internal"
+            label = context.getString(R.string.fm_drive_internal)
            removable = false
            candidates += File(INTERNAL_PATH)
        }
@@ -109,13 +110,13 @@ object StorageRoots {
            entry.seeds += dir
        }

-        val roots = volumes.values.map { it.toRoot() }
+        val roots = volumes.values.map { it.toRoot(context) }
        val internal = roots.filter { !it.removable }
        val removable = roots.filter { it.removable }.sortedBy { it.label }
        return disambiguate(internal + removable)
    }

-    private fun Volume.toRoot(): StorageRoot {
+    private fun Volume.toRoot(context: Context): StorageRoot {
        // Prefer a path we can actually list; a readable child beats an unreadable root.
        val dir = candidates.firstOrNull(::canBrowse)
            ?: candidates.firstNotNullOfOrNull { root -> seeds.firstNotNullOfOrNull { deepestReadable(root, it) } }
@@ -125,14 +126,14 @@ object StorageRoots {
            ?: File("/storage/$key")

        return StorageRoot(
-            label = label ?: defaultLabel(),
+            label = label ?: defaultLabel(context),
            dir = dir,
            removable = removable,
            readable = canBrowse(dir),
        )
    }

-    private fun Volume.defaultLabel(): String = if (removable) "SD card" else key
+    private fun Volume.defaultLabel(context: Context): String = if (removable) context.getString(R.string.fm_drive_sd) else key

    /** Appends the volume id to any label used by more than one volume, so entries stay tellable apart. */
    private fun disambiguate(roots: List<StorageRoot>): List<StorageRoot> {
@@ -183,12 +184,12 @@ object StorageRoots {
     * name like "android", which tells the user nothing about which card they are looking at.
     */
    private fun labelFor(context: Context, volume: StorageVolume, uuid: String?): String {
-        if (volume.isPrimary) return "Internal"
-        if (volume.isRemovable) return "SD card"
+        if (volume.isPrimary) return context.getString(R.string.fm_drive_internal)
+        if (volume.isRemovable) return context.getString(R.string.fm_drive_sd)
        val description = volume.getDescription(context)?.trim()
        return description?.takeIf { it.isNotBlank() && !it.equals("android", ignoreCase = true) }
            ?: uuid
-            ?: "Storage"
+            ?: context.getString(R.string.fm_drive_storage)
    }

    private fun isEmulated(dir: File): Boolean = dir.absolutePath.startsWith(EMULATED_PREFIX)
@@ -0,0 +1,48 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Games added from the Games tab's + rather than a Games folder: one picked .exe, or each game
+ * "Add all games in this folder" found. Kept by the game's folder in `files/added-exes.json`,
+ * which [AddedGames.scan] merges in. The exe chosen later, the shortcut appid, the edits and the
+ * removal live where every added game keeps them ([com.droiddeck.launcher.session.SessionPrefs]);
+ * this holds which folders are games and the exe they came with.
+ */
+object AddedExes {
+    /** [picked]: the user chose [exe]; false = [GameExePicker]'s best guess, which a scan ranks again. */
+    class Entry(val folder: String, val exe: String, val picked: Boolean = true)
+
+    private fun file(context: Context) = File(context.filesDir, "added-exes.json")
+
+    @Synchronized
+    fun list(context: Context): List<Entry> = try {
+        val array = JSONArray(file(context).takeIf { it.isFile }?.readText() ?: "[]")
+        (0 until array.length()).mapNotNull { i ->
+            val o = array.optJSONObject(i) ?: return@mapNotNull null
+            val folder = o.optString("folder"); val exe = o.optString("exe")
+            if (folder.isEmpty() || exe.isEmpty()) null else Entry(folder, exe, o.optBoolean("picked", true))
+        }
+    } catch (e: Exception) {
+        emptyList()
+    }
+
+    /** Adds [entry], replacing one for the same folder. */
+    @Synchronized
+    fun put(context: Context, entry: Entry) = write(context, list(context).filter { it.folder != entry.folder } + entry)
+
+    @Synchronized
+    fun drop(context: Context, folder: String) = write(context, list(context).filter { it.folder != folder })
+
+    private fun write(context: Context, entries: List<Entry>) {
+        val array = JSONArray()
+        entries.forEach { array.put(JSONObject().put("folder", it.folder).put("exe", it.exe).put("picked", it.picked)) }
+        val f = file(context)
+        val tmp = File(f.path + ".tmp")
+        tmp.writeText(array.toString())
+        if (!tmp.renameTo(f)) { f.delete(); tmp.renameTo(f) }
+    }
+}
@@ -12,8 +12,9 @@ import java.net.URL
 import java.net.URLEncoder

 /**
- * Artwork for an added game: what the user put in the game's folder first, else what Steam's
- * store has for the same title, fetched once into the app's cache. Four pieces, named the way
+ * Artwork for an added game: what the user put in the game's folder first, else what Steam has
+ * for it - by the Steam appid its files name, else by a store search on its title - else what
+ * SteamGridDB has ([SteamGridDb]), fetched once into the app's cache. Four pieces, named the way
 * the client names them in its grid folder: the portrait capsule, the wide header, the hero
 * background and the logo; plus an icon pulled out of the game's own .exe. The session hands
 * the paths to the runtime's shortcuts writer, which copies them into the client's grid.
@@ -28,13 +29,40 @@ object AddedGameArt {
        val any get() = portrait != null || header != null || hero != null || logo != null
    }

+    /**
+     * The pieces a user can choose, as the client takes them: [assetType] is its custom-artwork
+     * number (null: the icon, set by path); [cacheName] the automatic file in the game's cache.
+     */
+    enum class Slot(val key: String, val cacheName: String, val assetType: Int?) {
+        COVER("p", "p.jpg", 0), BACKGROUND("hero", "hero.jpg", 1), LOGO("logo", "logo.png", 2), ICON("icon", "icon.png", null),
+    }
+
+    /** Where a piece came from; [AUTO] = nothing found yet. */
+    const val FOLDER = "folder"
+    const val STEAM = "steam"
+    const val SGDB = "sgdb"
+    const val FILE = "file"
+    const val EXE = "exe"
+    const val AUTO = ""
+
+    /** A slot as it stands: the file shown and where it came from (one of [FOLDER].. [AUTO]); [chosen] = the user picked it. */
+    class SlotState(val slot: Slot, val file: File?, val source: String, val chosen: Boolean)
+
+    /** One image the chooser offers: its group ([FOLDER], [STEAM], [SGDB]), a thumbnail and the full image (URL or path). */
+    class Option(val group: String, val thumb: String, val full: String)
+
+    private val CHOSEN = Regex("""chosen-(\w+)\.(\w+)""")
+
+    private fun chosen(cache: File, slot: Slot): File? =
+        cache.listFiles { f -> CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.firstOrNull()
+
    private val IMAGE = listOf("png", "jpg", "jpeg")
    private val PORTRAIT = listOf("cover", "poster", "grid", "boxart", "capsule", "folder", "library_600x900", "portrait")
    private val HEADER = listOf("header", "banner", "library_header", "wide")
    private val HERO = listOf("hero", "background", "library_hero")
    private val LOGO = listOf("logo")

-    private fun cacheDir(context: Context, game: AddedGames.Game) = File(context.filesDir, "added-art/${game.appId}")
+    internal fun cacheDir(context: Context, game: AddedGames.Game) = File(context.filesDir, "added-art/${game.appId}")

    /** An image in the folder (or its `art` subfolder) under one of the given names, any image extension. */
    private fun find(folder: File, names: List<String>): File? {
@@ -58,20 +86,111 @@ object AddedGameArt {
        )
    }

-    /** The folder's art, else the cached Steam art, without touching the network. */
+    /** The user's choice for each piece, else the folder's art, else the cached art; no network. */
    fun resolve(context: Context, game: AddedGames.Game): Art {
        val own = local(game)
        val cache = cacheDir(context, game)
        fun cached(name: String) = File(cache, name).takeIf { it.isFile }
        return Art(
-            portrait = own.portrait ?: cached("p.jpg"),
-            header = own.header ?: cached("header.jpg"),
-            hero = own.hero ?: cached("hero.jpg"),
-            logo = own.logo ?: cached("logo.png"),
-            icon = own.icon ?: exeIcon(context, game),
+            portrait = chosen(cache, Slot.COVER) ?: own.portrait ?: cached("p.jpg") ?: exeArt(context, game, cover = true),
+            header = own.header ?: cached("header.jpg") ?: exeArt(context, game, cover = false),
+            hero = chosen(cache, Slot.BACKGROUND) ?: own.hero ?: cached("hero.jpg"),
+            logo = chosen(cache, Slot.LOGO) ?: own.logo ?: cached("logo.png"),
+            icon = chosen(cache, Slot.ICON) ?: own.icon ?: cached("icon-sgdb.png") ?: exeIcon(context, game),
        )
    }

+    /** Each choosable piece with its file and where it came from, for the game's editor; no network. */
+    fun describe(context: Context, game: AddedGames.Game): List<SlotState> {
+        val own = local(game)
+        val cache = cacheDir(context, game)
+        fun cached(name: String): Pair<File, String>? = File(cache, name).takeIf { it.isFile }?.let { f ->
+            f to (File(cache, "$name.src").takeIf { it.isFile }?.readText()?.trim()?.takeIf { it.isNotEmpty() } ?: STEAM)
+        }
+        return Slot.values().map { slot ->
+            chosen(cache, slot)?.let { return@map SlotState(slot, it, chosenSource(context, game, slot).first.ifEmpty { FILE }, true) }
+            val auto: Pair<File, String>? = when (slot) {
+                Slot.COVER -> own.portrait?.let { it to FOLDER } ?: cached("p.jpg") ?: exeArt(context, game, cover = true)?.let { it to EXE }
+                Slot.BACKGROUND -> own.hero?.let { it to FOLDER } ?: cached("hero.jpg")
+                Slot.LOGO -> own.logo?.let { it to FOLDER } ?: cached("logo.png")
+                Slot.ICON -> own.icon?.let { it to FOLDER } ?: File(cache, "icon-sgdb.png").takeIf { it.isFile }?.let { it to SGDB }
+                    ?: exeIcon(context, game)?.let { it to EXE }
+            }
+            SlotState(slot, auto?.first, auto?.second ?: AUTO, false)
+        }
+    }
+
+    private val CHOOSABLE = setOf("png", "jpg", "jpeg", "webp")
+
+    /** Images in the game's folder (and its art folders) that could stand for a piece. */
+    internal fun folderImages(folder: File): List<File> =
+        listOf(folder, File(folder, "art"), File(folder, ".art")).flatMap { dir ->
+            dir.listFiles { f -> f.isFile && f.extension.lowercase() in CHOOSABLE }?.sortedBy { it.name.lowercase() }.orEmpty()
+        }.take(12)
+
+    /**
+     * What the chooser offers for [slot]: the game folder's images, Steam's official piece (when the
+     * game has a Steam appid and Steam has the piece), and SteamGridDB's best few (with a key).
+     * Blocking: it asks the network.
+     */
+    fun options(context: Context, game: AddedGames.Game, slot: Slot): List<Option> {
+        val out = ArrayList<Option>()
+        folderImages(game.folder).forEach { out.add(Option(FOLDER, it.path, it.path)) }
+        val cache = cacheDir(context, game)
+        val steamId = SteamMatch.resolve(context, game.folder.path, game.exe, game.name, legacy = File(cache, "steam-appid")).appId?.toString()
+        val remote = when (slot) { Slot.COVER -> "library_600x900.jpg"; Slot.BACKGROUND -> "library_hero.jpg"; Slot.LOGO -> "logo.png"; Slot.ICON -> null }
+        if (steamId != null && remote != null) {
+            val url = "$CDN$steamId/$remote".takeIf { exists(it) } ?: steamAssetUrl(steamId, remote)
+            if (url != null) out.add(Option(STEAM, url, url))
+        }
+        val key = SteamGridDb.key(context)
+        if (key.isNotEmpty()) {
+            cache.mkdirs()
+            val gridId = remembered(File(cache, "sgdb-id")) {
+                runCatching { SteamGridDb.gameId(key, steamId?.toIntOrNull(), game.name) }.getOrNull()?.toString()
+            }?.toIntOrNull()
+            if (gridId != null) runCatching { SteamGridDb.images(key, gridId, slot, if (slot == Slot.ICON) 3 else 5) }.getOrNull()
+                ?.forEach { (thumb, full) -> out.add(Option(SGDB, thumb, full)) }
+        }
+        return out
+    }
+
+    /** Sets [slot] to [option] (a file is copied, a URL fetched) and records where it came from. False when it could not be had. Blocking. */
+    fun choose(context: Context, game: AddedGames.Game, slot: Slot, option: Option): Boolean {
+        val bytes = if (option.full.startsWith("https://")) get(option.full) else runCatching { File(option.full).readBytes() }.getOrNull()
+        bytes ?: return false
+        val ext = option.full.substringAfterLast('.', "png").substringBefore('?').lowercase().takeIf { it in CHOOSABLE + "ico" } ?: "png"
+        val cache = cacheDir(context, game).apply { mkdirs() }
+        chosen(cache, slot)?.delete()
+        val dst = File(cache, "chosen-${slot.key}.${if (ext == "jpeg") "jpg" else ext}")
+        val tmp = File(cache, dst.name + ".tmp")
+        tmp.writeBytes(bytes)
+        if (!tmp.renameTo(dst)) return false
+        SessionPrefs.setAddedGameArtSource(context, game.folder.path, slot.key, option.group + "|" + option.full)
+        return true
+    }
+
+    /** Where the user's choice for [slot] came from and which image it was ("" both when automatic). */
+    fun chosenSource(context: Context, game: AddedGames.Game, slot: Slot): Pair<String, String> {
+        val value = SessionPrefs.addedGameArtSource(context, game.folder.path, slot.key)
+        return value.substringBefore('|') to value.substringAfter('|', "")
+    }
+
+    /** [slot] back to what is found by itself. */
+    fun reset(context: Context, game: AddedGames.Game, slot: Slot) {
+        chosen(cacheDir(context, game), slot)?.delete()
+        SessionPrefs.setAddedGameArtSource(context, game.folder.path, slot.key, "")
+    }
+
+    private fun exists(url: String): Boolean = runCatching {
+        val c = URL(url).openConnection() as HttpURLConnection
+        c.requestMethod = "HEAD"
+        c.connectTimeout = 8_000
+        c.readTimeout = 8_000
+        c.setRequestProperty("User-Agent", "DroidDeck-launcher")
+        try { c.responseCode == 200 } finally { c.disconnect() }
+    }.getOrDefault(false)
+
    /** The first icon inside the game's .exe, kept as a PNG beside the cached art. */
    private fun exeIcon(context: Context, game: AddedGames.Game): File? {
        val cache = cacheDir(context, game)
@@ -88,58 +207,91 @@ object AddedGameArt {
    }

    /**
-     * Looks the games up on Steam's store and fetches the art that is missing, once per game
-     * (a miss is retried after a week). Blocking: run it off the main thread. Returns true when
-     * anything new arrived.
+     * Fetches the art that is missing: Steam first (the appid the game's files name, else a store
+     * search on its title whose result carries the same name), then SteamGridDB when a key is
+     * set. Each lookup runs once per game; a miss is retried after a week. Blocking: run it off
+     * the main thread. Returns true when anything new arrived.
     */
    fun fetchMissing(context: Context, games: List<AddedGames.Game>): Boolean {
        if (!SessionPrefs.addedGamesArt(context)) return false
+        val sgdbKey = SteamGridDb.key(context)
        var changed = false
        for (game in games) {
            if (local(game).portrait != null) continue
            val cache = cacheDir(context, game)
-            val lookup = File(cache, "steam-appid")
            if (File(cache, "p.jpg").isFile) continue
-            if (lookup.isFile && (lookup.readText().trim() != "none" || System.currentTimeMillis() - lookup.lastModified() < RETRY_AFTER_MS)) {
-                val id = lookup.readText().trim()
-                if (id == "none") continue
-                if (download(id, cache)) changed = true
-                continue
-            }
            cache.mkdirs()
-            val id = runCatching { search(game.name) }.onFailure { Log.w(TAG, "${game.name}: store search failed (${it.message})") }.getOrNull()
-            if (id == null) { lookup.writeText("none"); continue }
-            lookup.writeText(id)
-            Log.i(TAG, "${game.name}: Steam app $id")
-            if (download(id, cache)) changed = true
+            val match = steamMatch(context, game) { name ->
+                runCatching { search(name) }.onFailure { Log.w(TAG, "${game.name}: store search failed (${it.message})") }.getOrNull()?.toIntOrNull()
+            }
+            val appId = match.appId?.takeIf { match.certainty == SteamMatch.Certainty.FILES }
+            val id = match.appId?.toString()
+            if (id != null && download(id, cache)) changed = true
+            if (File(cache, "p.jpg").isFile || sgdbKey.isEmpty()) continue
+            val gridId = remembered(File(cache, "sgdb-id")) {
+                runCatching { SteamGridDb.gameId(sgdbKey, appId ?: id?.toIntOrNull(), game.name) }.getOrNull()?.toString()
+            }?.toIntOrNull() ?: continue
+            if (runCatching { SteamGridDb.download(sgdbKey, gridId, cache) }.getOrDefault(false)) changed = true
        }
        return changed
    }

+    /**
+     * The game's Steam app, the one record its Windows components use too ([SteamMatch]): what its
+     * files name, else a store search on its title ([search]) whose result has the same name.
+     */
+    internal fun steamMatch(context: Context, game: AddedGames.Game, search: (String) -> Int?): SteamMatch.Match {
+        val match = SteamMatch.resolve(context, game.folder.path, game.exe, game.name, legacy = File(cacheDir(context, game), "steam-appid"), search = search)
+        match.appId?.let { Log.i(TAG, "${game.name}: Steam app $it (${match.certainty.name.lowercase()})") }
+        return match
+    }
+
+    /** What [marker] remembers (an id, or "none" for a week), else [find]'s answer written to it. */
+    private fun remembered(marker: File, find: () -> String?): String? {
+        if (marker.isFile) {
+            val value = marker.readText().trim()
+            if (value != "none") return value
+            if (System.currentTimeMillis() - marker.lastModified() < RETRY_AFTER_MS) return null
+        }
+        val found = find()
+        marker.writeText(found ?: "none")
+        return found
+    }
+
    private fun normalize(s: String) = s.lowercase().replace(Regex("[^a-z0-9]"), "")

-    /** The Steam appid whose store name matches the folder name best, or null for no match. */
+    private val EDITION = Regex("(?i)\\b(complete|definitive|legendary|goty|game of the year|deluxe|ultimate|remastered)( edition)?\\b")
+
+    /**
+     * How well a result's name [got] matches the game's [name]: 3 the same, 2 the same once
+     * edition words are dropped, 1 one starts with the other; 0 no match. Nothing is taken for
+     * being the first result.
+     */
+    internal fun nameMatch(name: String, got: String): Int {
+        val want = normalize(name)
+        val wantShort = normalize(name.replace(EDITION, " ").trim().ifEmpty { name })
+        val have = normalize(got)
+        if (have.isEmpty() || wantShort.isEmpty()) return 0
+        return when {
+            have == want -> 3
+            have == wantShort -> 2
+            have.startsWith(wantShort) || wantShort.startsWith(have) -> 1
+            else -> 0
+        }
+    }
+
+    /** The id of the store result whose name matches [name] best, or null when none does. */
+    internal fun pickStoreResult(name: String, items: List<Pair<String, String>>): String? =
+        items.map { (id, got) -> id to nameMatch(name, got) }
+            .filter { it.second > 0 && it.first.isNotEmpty() }
+            .maxByOrNull { it.second }?.first
+
+    /** The Steam appid whose store name matches [name], or null for no match. */
    private fun search(name: String): String? {
-        val term = name.replace(Regex("(?i)\\b(complete|definitive|legendary|goty|game of the year|deluxe|ultimate|remastered)( edition)?\\b"), " ").trim().ifEmpty { name }
+        val term = name.replace(EDITION, " ").trim().ifEmpty { name }
        val json = get(STORE_SEARCH + URLEncoder.encode(term, "UTF-8"))?.toString(Charsets.UTF_8) ?: return null
        val items = JSONObject(json).optJSONArray("items") ?: return null
-        val want = normalize(name)
-        val wantShort = normalize(term)
-        var best: String? = null
-        var bestScore = 0
-        for (i in 0 until items.length()) {
-            val item = items.getJSONObject(i)
-            val got = normalize(item.optString("name"))
-            val score = when {
-                got == want -> 4
-                got == wantShort -> 3
-                got.startsWith(wantShort) || wantShort.startsWith(got) -> 2
-                i == 0 -> 1
-                else -> 0
-            }
-            if (score > bestScore) { bestScore = score; best = item.optString("id") }
-        }
-        return best?.takeIf { it.isNotEmpty() && bestScore >= 1 }
+        return pickStoreResult(name, (0 until items.length()).map { items.getJSONObject(it) }.map { it.optString("id") to it.optString("name") })
    }

    private fun download(id: String, cache: File): Boolean {
@@ -149,15 +301,73 @@ object AddedGameArt {
        )) {
            val dst = File(cache, localName)
            if (dst.isFile) continue
-            val bytes = get("$CDN$id/$remote") ?: continue
+            val bytes = get("$CDN$id/$remote") ?: steamAssetUrl(id, remote)?.let { get(it) } ?: continue
            val tmp = File(cache, "$localName.tmp")
            tmp.writeBytes(bytes)
-            if (tmp.renameTo(dst)) got = true
+            if (tmp.renameTo(dst)) { got = true; File(cache, "$localName.src").writeText(STEAM) }
        }
        return got
    }

-    private fun get(url: String): ByteArray? {
+    /**
+     * Newer Steam games keep their art under hashed paths (store_item_assets/steam/apps/<id>/<hash>/…),
+     * where the fixed CDN names above 404. The store's item API names those paths; once per appid.
+     */
+    private fun steamAssetUrl(id: String, remote: String): String? {
+        val assets = steamAssets.getOrPut(id) {
+            runCatching {
+                val input = """{"ids":[{"appid":$id}],"context":{"language":"english","country_code":"US"},"data_request":{"include_assets":true}}"""
+                val json = get("https://api.steampowered.com/IStoreBrowseService/GetItems/v1/?input_json=" + URLEncoder.encode(input, "UTF-8"))
+                    ?.toString(Charsets.UTF_8) ?: return@runCatching emptyMap()
+                val a = JSONObject(json).optJSONObject("response")?.optJSONArray("store_items")?.optJSONObject(0)?.optJSONObject("assets")
+                    ?: return@runCatching emptyMap()
+                val format = a.optString("asset_url_format").takeIf { it.contains("\${FILENAME}") } ?: return@runCatching emptyMap()
+                fun url(vararg keys: String) = keys.firstNotNullOfOrNull { k -> a.optString(k).takeIf { it.isNotEmpty() } }
+                    ?.let { "https://shared.akamai.steamstatic.com/store_item_assets/" + format.replace("\${FILENAME}", it) }
+                mapOf(
+                    "library_600x900.jpg" to url("library_capsule_2x", "library_capsule"),
+                    "header.jpg" to url("header"),
+                    "library_hero.jpg" to url("library_hero_2x", "library_hero"),
+                ).filterValues { it != null }.mapValues { it.value!! }
+            }.getOrDefault(emptyMap())
+        }
+        return assets[remote]
+    }
+
+    private val steamAssets = java.util.concurrent.ConcurrentHashMap<String, Map<String, String>>()
+
+    /**
+     * When nothing else gave a cover (or header), one made from the exe's icon: the icon centred on
+     * its own colour, darkened toward the bottom, so the game still has a face in the list and in
+     * Steam. Made once per game; real art found later takes over because it is looked at first.
+     */
+    private fun exeArt(context: Context, game: AddedGames.Game, cover: Boolean): File? {
+        val cache = cacheDir(context, game)
+        val out = File(cache, if (cover) "p-exe.png" else "header-exe.png")
+        if (out.isFile) return out
+        val icon = exeIcon(context, game) ?: return null
+        val src = android.graphics.BitmapFactory.decodeFile(icon.path) ?: return null
+        val (w, h) = if (cover) 600 to 900 else 920 to 430
+        val tint = android.graphics.Bitmap.createScaledBitmap(src, 1, 1, true).getPixel(0, 0)
+        val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+        val canvas = android.graphics.Canvas(bmp)
+        fun shade(c: Int, f: Float) = android.graphics.Color.rgb(
+            (android.graphics.Color.red(c) * f).toInt(), (android.graphics.Color.green(c) * f).toInt(), (android.graphics.Color.blue(c) * f).toInt(),
+        )
+        canvas.drawPaint(android.graphics.Paint().apply {
+            shader = android.graphics.LinearGradient(0f, 0f, 0f, h.toFloat(), shade(tint, 0.7f), shade(tint, 0.15f), android.graphics.Shader.TileMode.CLAMP)
+        })
+        val side = (minOf(w, h) * 0.5f).toInt()
+        val left = (w - side) / 2f
+        val top = (h - side) / 2f
+        canvas.drawBitmap(src, null, android.graphics.RectF(left, top, left + side, top + side), android.graphics.Paint(android.graphics.Paint.FILTER_BITMAP_FLAG))
+        cache.mkdirs()
+        val tmp = File(cache, "${out.name}.tmp")
+        tmp.outputStream().use { bmp.compress(Bitmap.CompressFormat.PNG, 100, it) }
+        return if (tmp.renameTo(out)) out else null
+    }
+
+    internal fun get(url: String): ByteArray? {
        val c = URL(url).openConnection() as HttpURLConnection
        c.connectTimeout = 10_000
        c.readTimeout = 15_000
@@ -0,0 +1,77 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.stores.SteamLiveShortcuts
+import java.io.File
+
+/**
+ * The game editor's writes for an added game, Steam's non-Steam Properties in the app: name,
+ * target, Start in, launch options and art. Each goes through the same shortcut - the listing the
+ * shortcuts writer reads, and the running client - on the appid the game already has, so an edit
+ * never makes a second shortcut. Each call is quick (the game alone, [AddedGames.single]); the
+ * client and the listing follow on [AddedGamesPublisher], in order. Call off the main thread.
+ */
+object AddedGameEdits {
+    /** The added game in [folder] as it stands now, or null when it is not listed. */
+    fun game(context: Context, folder: String): AddedGames.Game? = AddedGames.single(context, folder)
+
+    /** The client told ([live]), then the listing rewritten, on [AddedGamesPublisher]. */
+    private fun publish(context: Context, live: () -> Unit) = AddedGamesPublisher.later(context, live)
+
+    /** [name] as the game's name; "" goes back to the name found by itself. */
+    fun setName(context: Context, folder: String, name: String): AddedGames.Game? {
+        SessionPrefs.setAddedGameName(context, folder, name)
+        return apply(context, folder)
+    }
+
+    /** [exe] as the game's target; false when the session cannot see it. */
+    fun setExe(context: Context, folder: String, exe: File): Boolean {
+        if (!exe.isFile || AddedGames.guestPath(context, exe) == null) return false
+        SessionPrefs.setAddedGameExe(context, folder, exe.path)
+        apply(context, folder)
+        return true
+    }
+
+    /** [dir] (a host folder) as the game's Start in; "" = the exe's own folder. False when the session cannot see it. */
+    fun setStartIn(context: Context, folder: String, dir: String): Boolean {
+        val guest = if (dir.isBlank()) "" else AddedGames.guestPath(context, File(dir.trim())) ?: return false
+        SessionPrefs.setAddedGameStartIn(context, folder, guest)
+        apply(context, folder)
+        return true
+    }
+
+    fun setLaunchOptions(context: Context, folder: String, options: String): AddedGames.Game? {
+        SessionPrefs.setAddedGameLaunch(context, folder, options)
+        return apply(context, folder)
+    }
+
+    /** [slot] set to [option], then handed to the shortcut. False when the image could not be had. */
+    fun setArt(context: Context, folder: String, slot: AddedGameArt.Slot, option: AddedGameArt.Option): Boolean {
+        val game = game(context, folder) ?: return false
+        if (!AddedGameArt.choose(context, game, slot, option)) return false
+        applyArt(context, game, slot)
+        return true
+    }
+
+    /** [slot] back to automatic, then handed to the shortcut. */
+    fun resetArt(context: Context, folder: String, slot: AddedGameArt.Slot) {
+        val game = game(context, folder) ?: return
+        AddedGameArt.reset(context, game, slot)
+        applyArt(context, game, slot)
+    }
+
+    private fun applyArt(context: Context, game: AddedGames.Game, slot: AddedGameArt.Slot) {
+        val file = AddedGameArt.describe(context, game).first { it.slot == slot }.file
+        publish(context) {
+            if (slot == AddedGameArt.Slot.ICON) SteamLiveShortcuts.setArt(context, game.appId, null, null, iconPath = file?.absolutePath.orEmpty())
+            else SteamLiveShortcuts.setArt(context, game.appId, slot.assetType, file)
+        }
+    }
+
+    private fun apply(context: Context, folder: String): AddedGames.Game? {
+        val game = game(context, folder)
+        if (game != null) publish(context) { SteamLiveShortcuts.update(context, game) }
+        return game
+    }
+}
@@ -6,6 +6,8 @@ import com.droiddeck.launcher.runtime.LinuxRuntime
 import org.json.JSONObject
 import com.droiddeck.launcher.session.GameStorage
 import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import com.droiddeck.launcher.stores.StoreInstallRoot
 import java.io.File
 import java.util.zip.CRC32

@@ -16,33 +18,42 @@ object AddedGames {
    private const val LEGACY_LIBRARY = "/mnt/bannerlator-sd"

    class Game(
-        val folder: File, val name: String, val exe: File, val guestExe: String, val guestDir: String,
+        val folder: File, val name: String,
+        /** The game's own .exe: what the icon is read from and what the settings page lists. */
+        val exe: File,
+        /** The guest path the shortcut runs: [exe], or a store install's launcher .bat in front of it. */
+        val guestExe: String, val guestDir: String,
        /** The client's 32-bit appid for this shortcut, as an unsigned value. */
        val appId: Long,
        /** What steam://rungameid/ takes for a shortcut. */
        val gameId: Long,
        val candidates: List<File>,
        val steamAppId: Int? = null,
+        /** Where the game came from: a store's id, or [Library.ADDED] for a folder the user added. */
+        val source: String = Library.ADDED,
+        /** The store's own id for the game, from its sidecar; null for a plain added folder. */
+        val storeId: String? = null,
+        /** The exe is the picker's guess and nothing clearly won ([GameExePicker.Ranking.uncertain]). */
+        val exeUncertain: Boolean = false,
+        /** Steam's launch options for the shortcut; "" for none. */
+        val launchOptions: String = "",
+        /** Added from the Games tab (an entry of its own), not found in a Games folder. */
+        val single: Boolean = false,
    ) {
        fun folderName(): String = folder.name
    }

-    /** One Games folder and where the session sees it. */
+    /** A Games folder an earlier build had, and where the session sees it. */
    class Root(val host: File, val guest: String)

    /**
-     * The chosen folders with their guest paths: /root/Games/<folder name>, or with a short hash of
-     * the host path when two chosen folders share a name (so a folder's guest path, and with it
-     * every shortcut's appid, does not change when another folder is added or removed).
+     * The Games folders earlier builds had, bound into the session at the guest paths they had
+     * then (/root/Games/<name>), so the games in them (entries now, [GamesFolderMigration]) keep
+     * their paths and shortcuts. Nothing adds one any more.
     */
    fun roots(context: Context): List<Root> {
-        val hosts = SessionPrefs.addedGamesDirs(context).map { File(it) }
-        val names = hosts.groupingBy { it.name.lowercase() }.eachCount()
-        return hosts.map { host ->
-            val name = host.name.ifEmpty { "games" }
-            val guestName = if ((names[name.lowercase()] ?: 0) > 1) name + "-" + "%08x".format(CRC32().apply { update(host.path.toByteArray()) }.value).take(4) else name
-            Root(host, "$GUEST_DIR/$guestName")
-        }
+        GamesFolderMigration.run(context)
+        return SessionPrefs.gameFolderBinds(context).map { (host, guest) -> Root(File(host), guest) }
    }

    private val SKIP = Regex(
@@ -66,45 +77,296 @@ object AddedGames {
        SessionPrefs.romsDir(context).takeIf { it.isNotEmpty() }?.let { roms ->
            if (path.startsWith("$roms/")) return "/root/ROMs/" + path.removePrefix("$roms/")
        }
+        // A store root on a card has a bind of its own, before the library rule: the same folder
+        // keeps the same guest path (and appid) whether or not that card is also the Steam library.
+        StoreInstallRoot.externalGuestPath(context, host)?.let { return it }
        GameStorage.effective(context)?.let { lib ->
            if (path.startsWith("${lib.path}/")) return "$LIBRARY/" + path.removePrefix("${lib.path}/")
        }
+        // Inside the runtime's own tree (store installs on internal storage live at
+        // root/Games/Stores): the tree is the session's / and needs no bind.
+        val runtime = LinuxRuntime.rootDir(context).absolutePath
+        if (path.startsWith("$runtime/")) return "/" + path.removePrefix("$runtime/")
+        // Internal storage, bound at /root/Storage in every session: an exe picked anywhere on it.
+        val storage = android.os.Environment.getExternalStorageDirectory().absolutePath
+        if (path.startsWith("$storage/")) return "/root/Storage/" + path.removePrefix("$storage/")
        return null
    }

-    /** The .exe files a game folder offers, best first. */
-    fun candidates(folder: File): List<File> {
-        val exes = ArrayList<File>()
-        val roots = listOf(folder) + (folder.listFiles { f -> f.isDirectory }?.sortedBy { it.name.lowercase() } ?: emptyList())
-        for (dir in roots) {
-            dir.listFiles { f -> f.isFile && f.name.endsWith(".exe", ignoreCase = true) && !SKIP.matches(f.name) }
-                ?.let { exes.addAll(it) }
-        }
-        val key = folder.name.lowercase().replace(Regex("[^a-z0-9]"), "")
-        return exes.sortedWith(
-            compareByDescending<File> { it.parentFile == folder }
-                .thenByDescending { it.nameWithoutExtension.lowercase().replace(Regex("[^a-z0-9]"), "").let { n -> n == key || key.startsWith(n) || n.startsWith(key) } }
-                .thenByDescending { it.length() },
+    /** The .exe files a game folder offers, best first ([GameExePicker]); declared Store exes lead. */
+    fun candidates(folder: File): List<File> = rank(folder).exes
+
+    /** [GameExePicker]'s ranking, with a Store-declared executable taking precedence when present. */
+    fun rank(folder: File): GameExePicker.Ranking {
+        val key = "${folder.path}|${folder.lastModified()}"
+        val now = System.currentTimeMillis()
+        ranked[key]?.takeIf { now - it.first < RANK_FRESH_MS }?.let { return it.second }
+        val guessed = GameExePicker.rank(folder) { !SKIP.matches(it.name) }
+        val declared = declaredExes(folder)
+        val preferred = declared.map { it.path }.toSet()
+        val result = if (declared.isEmpty()) guessed else GameExePicker.Ranking(
+            declared + guessed.exes.filter { it.path !in preferred },
+            List(declared.size) { Int.MAX_VALUE } + guessed.exes.zip(guessed.scores)
+                .filter { it.first.path !in preferred }.map { it.second },
+            uncertain = false,
        )
+        if (ranked.size > 256) ranked.clear()
+        ranked[key] = now to result
+        return result
    }

+    /** A folder's ranking for a minute, so one add (rank, then the game built from it) walks it once. */
+    private val ranked = java.util.concurrent.ConcurrentHashMap<String, Pair<Long, GameExePicker.Ranking>>()
+    private const val RANK_FRESH_MS = 60_000L
+
+    /**
+     * Names identified from an exe (Steam manifest, GOG info, version resource), by the exe's path,
+     * size and time and its game folder's time (a GOG info file dropped in changes the latter).
+     */
+    private val identified = java.util.concurrent.ConcurrentHashMap<String, String>()
+
+    /**
+     * The game's own title for [exe] when the disk names one ([GameIdentifier]: a Steam manifest,
+     * a GOG info file, the exe's version resource), else null (the folder name stands).
+     */
+    internal fun identifiedName(folder: File, exe: File): String? {
+        val key = "${exe.path}|${exe.length()}|${exe.lastModified()}|${folder.lastModified()}"
+        identified[key]?.let { return it.ifEmpty { null } }
+        val id = runCatching { GameIdentifier.identify(exe) }.getOrNull()
+        val found = id?.name?.takeIf {
+            id.nameSource in setOf(GameIdentifier.Source.STEAM_MANIFEST_ACF, GameIdentifier.Source.GOG_INFO, GameIdentifier.Source.PE_VERSION)
+        }
+        val name = found?.let { if (id?.nameSource == GameIdentifier.Source.PE_VERSION) betterSpelling(underscoresToSpaces(it), folder.name) else it }
+        identified[key] = name.orEmpty()
+        return name
+    }
+
+    /**
+     * The exe's version resource often spells the title the way a programmer typed it ("Insane2")
+     * while the folder has the real spacing ("Insane 2"). When both spell the same letters and
+     * digits, the one with more word breaks wins; a tie keeps mixed case over all one case
+     * ("DiRT 3" over "dirt 3"), else the exe's spelling. Different titles keep the exe's.
+     */
+    /** "Watch_Dogs" → "Watch Dogs": an underscore in a version-resource title is a programmer's space. */
+    internal fun underscoresToSpaces(name: String): String =
+        name.replace('_', ' ').replace(Regex("\\s+"), " ").trim().ifEmpty { name }
+
+    internal fun betterSpelling(peName: String, folderName: String): String {
+        fun key(s: String) = s.lowercase().filter { it.isLetterOrDigit() }
+        if (key(peName) != key(folderName) || folderName.isBlank()) return peName
+        fun breaks(s: String) = s.count { !it.isLetterOrDigit() }
+        fun mixed(s: String) = s.any { it.isUpperCase() } && s.any { it.isLowerCase() }
+        return when {
+            breaks(folderName) > breaks(peName) -> folderName.trim()
+            breaks(folderName) < breaks(peName) -> peName
+            mixed(folderName) && !mixed(peName) -> folderName.trim()
+            else -> peName
+        }
+    }
+    /** The executables MicrosoftGame.config or appxmanifest.xml declares that exist inside [folder]. */
+    internal fun declaredExes(folder: File): List<File> {
+        val names = DECLARED.flatMap { (file, pattern) ->
+            runCatching { pattern.findAll(File(folder, file).readText()).map { it.groupValues[1] }.toList() }.getOrDefault(emptyList())
+        }
+        val root = runCatching { folder.canonicalPath + File.separator }.getOrNull() ?: return emptyList()
+        return names.asSequence()
+            .map { File(folder, it.trim().replace('\\', '/').trimStart('/')) }
+            .filter { it.name.endsWith(".exe", ignoreCase = true) && !SKIP.matches(it.name) && it.isFile }
+            .filter { runCatching { it.canonicalPath.startsWith(root) }.getOrDefault(false) }
+            .distinctBy { it.path }
+            .toList()
+    }
+
+    private val DECLARED = listOf(
+        "MicrosoftGame.config" to Regex("<Executable\\b[^>]*?\\bName\\s*=\\s*\"([^\"]+)\"", RegexOption.IGNORE_CASE),
+        "appxmanifest.xml" to Regex("<Application\\b[^>]*?\\bExecutable\\s*=\\s*\"([^\"]+)\"", RegexOption.IGNORE_CASE),
+    )
+
    fun scan(context: Context): List<Game> {
        val out = ArrayList<Game>()
-        val folders = roots(context).map { it.host } + listOfNotNull(
+        GamesFolderMigration.run(context)
+        val folders = listOfNotNull(
            GameStorage.effective(context)?.let { File(it.path) },
            GameStorage.effective(context)?.let { File(it.path, "steamapps/common") },
        )
+        val removed = SessionPrefs.removedAddedGames(context).toSet()
        for (dir in folders.distinctBy { it.absolutePath }) {
            if (!dir.isDirectory) { Log.w(TAG, "$dir is not a folder; skipped"); continue }
            val steamInstalls = steamInstallDirs(dir)
            for (folder in dir.listFiles { f -> f.isDirectory }?.sortedBy { it.name.lowercase() } ?: emptyList()) {
-                if (folder.name.lowercase() in steamInstalls) continue
+                if (folder.name.lowercase() in steamInstalls || folder.name.equals("steamapps", ignoreCase = true)) continue
+                // Removed from the list by the user (the folder stays on disk); restored from the settings page.
+                if (folder.path in removed) continue
+                // The store install root sits inside the Games storage; its games are scanned below, per store.
+                if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue
                scanGame(context, folder, out)
            }
        }
+        // Games added as one picked exe (the Games tab's +), by that exe's folder.
+        for (entry in AddedExes.list(context)) {
+            val folder = File(entry.folder)
+            if (folder.path in removed || !folder.isDirectory) continue
+            scanGame(context, folder, out, single = entry)
+        }
+        // Games the Stores section installed: one folder each under <root>/<Store>/, with a sidecar.
+        // An unfinished one (sidecar still `installing`, or none at all) is neither a game nor Custom.
+        for (folder in StoreInstallRoot.gameFolders(context)) if (StoreInstallRoot.isFinished(folder)) scanGame(context, folder, out)
        return out.distinctBy { it.folder.canonicalPath }
    }

+    /**
+     * The game in [folderPath] alone, built by the same rules as [scan] (store sidecar, an entry
+     * from the Games tab, the chosen exe, the edits) without walking every other game: what the
+     * editor needs for one game. Null when that folder is not a game, or was removed.
+     */
+    fun single(context: Context, folderPath: String): Game? {
+        val folder = File(folderPath)
+        if (!folder.isDirectory || folderPath in SessionPrefs.removedAddedGames(context)) return null
+        val out = ArrayList<Game>(1)
+        scanGame(context, folder, out, single = AddedExes.list(context).firstOrNull { it.folder == folderPath })
+        return out.firstOrNull()
+    }
+
+    /**
+     * Stops listing the added game in [folder] at once: marked removed and dropped from the
+     * library cache; the running client loses its shortcut ([appId], else the one stored for the
+     * folder) and the listing is rewritten afterwards ([AddedGamesPublisher]). Nothing on disk is
+     * deleted. Quick; call off the main thread (preferences and a small file).
+     */
+    fun remove(context: Context, folder: File, appId: Long? = null, name: String = folder.name) {
+        val app = context.applicationContext
+        val started = android.os.SystemClock.elapsedRealtime()
+        val id = appId ?: SessionPrefs.addedGameStoredAppId(app, folder.path)
+        SessionPrefs.setAddedGameRemoved(app, folder.path, true)
+        LibraryCache.save(app, LibraryCache.load(app).filterNot { it.library == Library.ADDED && it.gameFiles?.path == folder.path })
+        Log.i(TAG, "games: remove $name took ${android.os.SystemClock.elapsedRealtime() - started}ms")
+        AddedGamesPublisher.later(app) { if (id != null) com.droiddeck.launcher.stores.SteamLiveShortcuts.remove(app, id) }
+    }
+
+    /** What [addExe] did with a picked exe. */
+    sealed class AddResult {
+        /** A new game, or the existing one the exe already is, or the listed game whose exe it now is. */
+        class Added(val game: Game) : AddResult()
+        class Existing(val game: Game) : AddResult()
+        class Switched(val game: Game) : AddResult()
+        /** The session cannot see the exe's path. */
+        object Unreachable : AddResult()
+        object NotFound : AddResult()
+    }
+
+    private fun canonical(f: File): String = runCatching { f.canonicalPath }.getOrDefault(f.absolutePath)
+
+    private fun inside(path: String, folder: String) = path.startsWith(folder.trimEnd('/') + "/")
+
+    /**
+     * The game folder [exe] belongs to, without a scan: an entry from the Games tab (Games folders
+     * of earlier builds included), a removed game, a store install, or the first-level folder under
+     * the Steam library that holds it. Null when it is in none.
+     */
+    private fun ownerFolder(context: Context, exe: File): File? {
+        GamesFolderMigration.run(context)
+        val path = canonical(exe)
+        fun holds(f: File) = inside(path, canonical(f))
+        AddedExes.list(context).map { File(it.folder) }.firstOrNull(::holds)?.let { return it }
+        SessionPrefs.removedAddedGames(context).map { File(it) }.firstOrNull(::holds)?.let { return it }
+        StoreInstallRoot.gameFolders(context).firstOrNull(::holds)?.let { return it }
+        // Games folders of earlier builds are entries now, found above.
+        val dirs = listOfNotNull(
+            GameStorage.effective(context)?.let { File(it.path, "steamapps/common") },
+            GameStorage.effective(context)?.let { File(it.path) },
+        )
+        for (dir in dirs) {
+            val base = canonical(dir)
+            if (!inside(path, base)) continue
+            val first = path.removePrefix("$base/").substringBefore('/')
+            File(dir, first).takeIf { it.isDirectory && first != "steamapps" }?.let { return it }
+        }
+        return null
+    }
+
+    /**
+     * Adds the game [exe] is: the game itself when it is listed already, that game's exe switched
+     * when [exe] sits in a listed (or removed) game's folder, else a new game for [exe]'s folder.
+     * Only that one game is read; Steam (the running client, then the listing) follows on
+     * [AddedGamesPublisher]. Nothing is added when the session cannot see the path.
+     */
+    fun addExe(context: Context, exe: File): AddResult {
+        val app = context.applicationContext
+        if (!exe.isFile) return AddResult.NotFound
+        val path = canonical(exe)
+        val owner = ownerFolder(app, exe)
+        if (owner != null && owner.path !in SessionPrefs.removedAddedGames(app)) {
+            single(app, owner.path)?.takeIf { canonical(it.exe) == path }?.let { return AddResult.Existing(it) }
+        }
+        if (owner == null && guestPath(app, exe) == null) return AddResult.Unreachable
+        val folder = owner ?: exe.parentFile ?: return AddResult.NotFound
+        SessionPrefs.setAddedGameRemoved(app, folder.path, false)
+        SessionPrefs.setAddedGameExe(app, folder.path, exe.path)
+        if (owner == null) AddedExes.put(app, AddedExes.Entry(folder.path, exe.path))
+        val game = single(app, folder.path) ?: return AddResult.NotFound
+        AddedGamesPublisher.later(app) { com.droiddeck.launcher.stores.SteamLiveShortcuts.sync(app, listOf(game)) { true } }
+        Log.i(TAG, "added ${game.name} from its exe")
+        return if (owner == null) AddResult.Added(game) else AddResult.Switched(game)
+    }
+
+    /** What [addFolder] did: the games it added, and how many of the folder's games were listed already. */
+    class FolderResult(val added: List<Game>, val already: Int)
+
+    /**
+     * "Add all games in this folder": every subfolder of [dir] with an .exe becomes a game with
+     * [GameExePicker]'s best one (marked uncertain where nothing clearly won), as an entry of its
+     * own, not a Games folder. A subfolder that is, holds or sits in a listed game counts as
+     * already there; a removed one comes back. Steam follows once, on [AddedGamesPublisher]. Blocking.
+     */
+    fun addFolder(context: Context, dir: File, onGame: (Game) -> Unit = {}, onChecking: (String?) -> Unit = {}): FolderResult {
+        val app = context.applicationContext
+        val removed = SessionPrefs.removedAddedGames(app).toSet()
+        val listed = listedFolders(app, removed)
+        var already = 0
+        val fresh = ArrayList<String>()
+        val added = ArrayList<Game>()
+        for (sub in dir.listFiles { f -> f.isDirectory && !f.name.startsWith(".") }?.sortedBy { it.name.lowercase() }.orEmpty()) {
+            val path = canonical(sub)
+            if (listed.any { it == path || inside(path, it) || inside(it, path) }) { already++; continue }
+            onChecking(sub.name)
+            val best = rank(sub).exes.firstOrNull() ?: continue
+            if (guestPath(app, best) == null) continue
+            if (sub.path in removed) SessionPrefs.setAddedGameRemoved(app, sub.path, false)
+            AddedExes.put(app, AddedExes.Entry(sub.path, best.path, picked = false))
+            fresh.add(sub.path)
+            single(app, sub.path)?.let { added.add(it); onGame(it) }
+        }
+        onChecking(null)
+        if (fresh.isEmpty()) return FolderResult(emptyList(), already)
+        AddedGamesPublisher.later(app) { com.droiddeck.launcher.stores.SteamLiveShortcuts.sync(app, added) { true } }
+        Log.i(TAG, "added ${added.size} game(s) from ${dir.name}, $already already listed")
+        return FolderResult(added, already)
+    }
+
+    /**
+     * The game folders already listed, without building any game: the first-level folders of the
+     * Steam library (as [scan] walks them), the Games tab's entries (Games folders of earlier builds
+     * included) and the store installs. Canonical paths; removed games are left out.
+     */
+    private fun listedFolders(context: Context, removed: Set<String>): List<String> {
+        val out = ArrayList<String>()
+        GamesFolderMigration.run(context)
+        val dirs = listOfNotNull(
+            GameStorage.effective(context)?.let { File(it.path) },
+            GameStorage.effective(context)?.let { File(it.path, "steamapps/common") },
+        )
+        for (dir in dirs.distinctBy { it.absolutePath }) {
+            for (folder in dir.listFiles { f -> f.isDirectory }.orEmpty()) {
+                if (folder.path in removed || folder.name.equals("steamapps", ignoreCase = true)) continue
+                if (folder.name == "Games" && StoreInstallRoot.roots(context).any { it.absolutePath == folder.absolutePath }) continue
+                out.add(canonical(folder))
+            }
+        }
+        AddedExes.list(context).filter { it.folder !in removed }.forEach { out.add(canonical(File(it.folder))) }
+        StoreInstallRoot.gameFolders(context).forEach { out.add(canonical(it)) }
+        return out
+    }
+
    /**
     * The folders under a library's steamapps/common that a manifest beside it already claims.
     * Steam lists those itself, so a shortcut would only add a non-Steam copy of the game. Steam
@@ -123,35 +385,110 @@ object AddedGames {

    private val INSTALL_DIR = Regex("\"installdir\"\\s*\"([^\"]*)\"", RegexOption.IGNORE_CASE)

-    private fun scanGame(context: Context, folder: File, out: MutableList<Game>) {
+    /** [single]: the entry a game added from the Games tab has; its exe stands in when no other is chosen and the user picked it. */
+    private fun scanGame(context: Context, folder: File, out: MutableList<Game>, single: AddedExes.Entry? = null) {
        run {
-            val candidates = candidates(folder)
-            val chosen = SessionPrefs.addedGameExe(context, folder.path).takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile }
-            val exe = chosen ?: candidates.firstOrNull() ?: return
-            val guestExe = guestPath(context, exe)
-            if (guestExe == null) { Log.w(TAG, "${folder.name}: the session cannot see ${exe.path}"); return }
-            val guestDir = guestPath(context, exe.parentFile ?: folder) ?: return
-            val name = folder.name
+            // A store install carries a sidecar; every one of them is a shortcut.
+            val sidecar = StoreGameSidecar.read(folder)
+            val ranking = rank(folder)
+            val candidates = ranking.exes
+            val picked = SessionPrefs.addedGameExe(context, folder.path)
+            val chosen = picked.takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile }
+                ?: single?.takeIf { it.picked }?.let { File(it.exe) }?.takeIf { it.isFile }
+            // A store install says which exe it is; the folder's guess only when that file is gone.
+            val found = chosen ?: sidecar?.exeFile(folder)?.takeIf { it.isFile } ?: candidates.firstOrNull() ?: return
+            // The store's launcher .bat stands in front of the exe when the game needs arguments or
+            // environment; it is what the shortcut runs. Dropped when the user picked another exe.
+            val launch = if (chosen == null) sidecar?.launcherFile(folder)?.takeIf { it.isFile } ?: found else found
+            val foundGuest = guestPath(context, launch)
+            if (foundGuest == null) { Log.w(TAG, "${folder.name}: the session cannot see ${launch.path}"); return }
+            // A store install's title; else the title the disk gives (the shortcut's appid is kept
+            // per folder from its first scan, so a name found later does not move it); else the folder.
+            val autoName = sidecar?.title ?: identifiedName(folder, found) ?: folder.name
            // Keyed by the pre-rename path so shortcut ids, and the prefixes and saves under them, stay put.
-            val crc = CRC32().apply { update(("\"${guestExe.replaceFirst(Regex("^$LIBRARY/"), "$LEGACY_LIBRARY/")}\"" + name).toByteArray()) }.value
-            val appId = crc or 0x80000000L
-            val steamRoot = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam")
-            val steamId = steamRoute(steamRoot, appId)
+            val crc = CRC32().apply { update(("\"${foundGuest.replaceFirst(Regex("^$LIBRARY/"), "$LEGACY_LIBRARY/")}\"" + autoName).toByteArray()) }.value
+            val appId = SessionPrefs.addedGameAppId(context, folder.path, crc or 0x80000000L)
+            val config = accountConfig(File(LinuxRuntime.rootDir(context), "root/.local/share/Steam"))
+            val record = config?.let { shortcutRecord(it, appId) }
+            val rev = record?.optInt("rev", 0) ?: 0
+            // Name, Start in and launch options edited in Steam's own Properties become the app's.
+            if (sidecar == null && record != null) adoptSteamEdits(context, folder, record)
+            val name = SessionPrefs.addedGameName(context, folder.path).takeIf { sidecar == null && it.isNotEmpty() } ?: autoName
+            val adopted = guestPath(context, folder)
+                ?.let { steamTarget(folder, it, record, foundGuest, SessionPrefs.addedGameExeSeen(context, folder.path)) }
+                ?.takeIf { SessionPrefs.adoptAddedGameExe(context, folder.path, picked, it.path, rev) }
+            val exe = adopted ?: found
+            val guestExe = if (adopted != null) guestPath(context, adopted) ?: return else foundGuest
+            val guestDir = SessionPrefs.addedGameStartIn(context, folder.path).takeIf { sidecar == null && it.isNotEmpty() }
+                ?: guestPath(context, (if (adopted != null) adopted else launch).parentFile ?: folder) ?: return
+            val steamId = config?.let { steamRoute(it, appId) }
            out.add(Game(folder, name, exe, guestExe, guestDir, appId,
-                steamId?.toLong() ?: ((appId shl 32) or 0x02000000L), candidates, steamId))
+                steamId?.toLong() ?: ((appId shl 32) or 0x02000000L), candidates, steamId,
+                source = sidecar?.store?.id ?: Library.ADDED, storeId = sidecar?.id,
+                exeUncertain = sidecar == null && chosen == null && adopted == null && ranking.uncertain,
+                launchOptions = if (sidecar == null) SessionPrefs.addedGameLaunch(context, folder.path) else "",
+                single = single != null))
        }
    }

-    private fun steamRoute(root: File, appId: Long): Int? = runCatching {
-        val users = File(root, "config/loginusers.vdf").readText()
-        val blocks = Regex(""""(\d{5,})"\s*\{([^}]*)\}""")
-        val recent = blocks.findAll(users).firstOrNull { Regex(""""MostRecent"\s*"1"""").containsMatchIn(it.groupValues[2]) }
-            ?: return@runCatching null
-        val account = recent.groupValues[1].toLong() - 76561197960265728L
-        JSONObject(File(root, "userdata/$account/config/.droiddeck-routes.json").readText())
-            .optInt(appId.toString()).takeIf { it > 0 }
+    private fun accountConfig(root: File): File? {
+        val users = runCatching { File(root, "config/loginusers.vdf").readText() }.getOrDefault("")
+        val recent = Regex(""""(\d{5,})"\s*\{([^}]*)\}""").findAll(users)
+            .lastOrNull { Regex(""""MostRecent"\s*"1"""").containsMatchIn(it.groupValues[2]) }
+        val account = recent?.groupValues?.get(1)?.toLongOrNull()?.let { (it - 76561197960265728L).toString() }
+            ?: File(root, "userdata").list()?.filter { it.isNotEmpty() && it.all(Char::isDigit) && it != "0" }?.singleOrNull()
+        return account?.let { File(root, "userdata/$it/config") }
+    }
+
+    private fun steamRoute(config: File, appId: Long): Int? = runCatching {
+        JSONObject(File(config, ".droiddeck-routes.json").readText()).optInt(appId.toString()).takeIf { it > 0 }
    }.getOrNull()

+    private fun shortcutRecord(config: File, appId: Long): JSONObject? = runCatching {
+        JSONObject(File(config, ".droiddeck-shortcuts.json").readText()).optJSONObject("games")?.optJSONObject(appId.toString())
+    }.getOrNull()
+
+    internal fun steamTarget(folder: File, folderGuest: String, record: JSONObject?, guestExe: String, seen: Int): File? {
+        if (record == null || record.optInt("rev", 0) == seen) return null
+        val asked = unquote(record.optJSONObject("app")?.optString("Exe"))
+        val steam = unquote(record.optJSONObject("steam")?.optString("Exe"))
+        if (asked != guestExe || steam.isEmpty() || steam == asked || !steam.startsWith("$folderGuest/")) return null
+        val file = File(folder, steam.removePrefix("$folderGuest/"))
+        val inside = runCatching { file.canonicalPath.startsWith(folder.canonicalPath + File.separator) }.getOrDefault(false)
+        return file.takeIf { inside && it.isFile }
+    }
+
+    private fun unquote(value: String?): String = value.orEmpty().trim().trim('"')
+
+    /**
+     * What the user changed in Steam's Properties since the app last wrote the shortcut ([record]:
+     * what the app asked for, and what Steam had): a new name, launch options, or a Start in other
+     * than the exe's folder, taken over as the app's own. Each Steam value is taken once, so an app
+     * edit made after it is not undone before the shortcut is written again.
+     */
+    internal fun adoptSteamEdits(context: Context, folder: File, record: JSONObject) {
+        val app = record.optJSONObject("app") ?: return
+        val steam = record.optJSONObject("steam") ?: return
+        fun adopt(field: String, value: String, apply: (String) -> Unit) {
+            if (SessionPrefs.addedGameAdopted(context, folder.path, field) == value) return
+            SessionPrefs.setAddedGameAdopted(context, folder.path, field, value)
+            apply(value)
+        }
+        if (steam.has("AppName") && app.has("AppName")) {
+            val s = steam.optString("AppName"); val a = app.optString("AppName")
+            if (s.isNotEmpty() && s != a) adopt("AppName", s) { SessionPrefs.setAddedGameName(context, folder.path, it) }
+        }
+        if (steam.has("LaunchOptions") && app.has("LaunchOptions")) {
+            val s = steam.optString("LaunchOptions"); val a = app.optString("LaunchOptions")
+            if (s != a) adopt("LaunchOptions", s) { SessionPrefs.setAddedGameLaunch(context, folder.path, it) }
+        }
+        if (steam.has("StartDir") && app.has("StartDir")) {
+            val s = unquote(steam.optString("StartDir")); val a = unquote(app.optString("StartDir"))
+            val exeDir = unquote(steam.optString("Exe")).substringBeforeLast('/', "")
+            if (s.isNotEmpty() && s != a) adopt("StartDir", s) { SessionPrefs.setAddedGameStartIn(context, folder.path, if (it == exeDir) "" else it) }
+        }
+    }
+
    /** The list the session hands the runtime's shortcuts writer; one file per session start. */
    fun writeListing(context: Context, games: List<Game>): File {
        val file = File(context.filesDir, "session/added-games.json").apply { parentFile?.mkdirs() }
@@ -161,6 +498,8 @@ object AddedGames {
            json.append("{\"name\":").append(quote(g.name)).append(",\"exe\":").append(quote(g.guestExe))
                .append(",\"folder\":").append(quote(guestPath(context, g.folder) ?: g.guestDir))
                .append(",\"dir\":").append(quote(g.guestDir)).append(",\"appid\":").append(g.appId)
+                .append(",\"seen\":").append(SessionPrefs.addedGameExeSeen(context, g.folder.path))
+            if (g.launchOptions.isNotEmpty()) json.append(",\"launch\":").append(quote(g.launchOptions))
            // The art, as the session sees it: the app's cache is bound at its own path, a file in
            // the game's folder at the folder's guest path.
            val art = AddedGameArt.resolve(context, g)
@@ -0,0 +1,40 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import java.util.concurrent.Executors
+
+/**
+ * The slow part of an added-game change, off the caller's path and in order: the running client
+ * told ([later]'s work), then the listing the shortcuts writer reads at the next session start and
+ * the library cache, both from one scan ([republish]). An add, an edit or a removal shows at once;
+ * this follows.
+ */
+object AddedGamesPublisher {
+    private const val TAG = "AddedGamesPublisher"
+
+    /** Tests publish at once, to read the listing right after a change. */
+    @VisibleForTesting
+    @Volatile
+    internal var now = false
+
+    private val worker = Executors.newSingleThreadExecutor { r -> Thread(r, "added-games-publish") }
+
+    /** [live] (a DevTools call or nothing), then [republish], on the worker. */
+    fun later(context: Context, live: () -> Unit = {}) {
+        val app = context.applicationContext
+        val work = Runnable {
+            try { live() } catch (e: Exception) { Log.w(TAG, "live: ${e.message}") }
+            try { republish(app) } catch (e: Exception) { Log.w(TAG, "listing: ${e.message}") }
+        }
+        if (now) work.run() else worker.execute(work)
+    }
+
+    /** The listing and the library cache from one scan of the added games. Blocking. */
+    fun republish(context: Context) {
+        val games = AddedGames.scan(context)
+        AddedGames.writeListing(context, games)
+        LibraryCache.save(context, Library.launchableGames(context, added = games))
+    }
+}
@@ -0,0 +1,419 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.os.Build
+import android.os.PowerManager
+import android.util.AtomicFile
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import com.droiddeck.launcher.session.SessionState
+import com.droiddeck.launcher.session.WinComponents
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import kotlinx.coroutines.flow.MutableStateFlow
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.PriorityBlockingQueue
+
+/**
+ * Turns on, per game, the Windows components its source's list names ([WinCompSources]). Only the
+ * findings marked auto are turned on, only the ones that install here, and never one the user
+ * switched off: the user's switches are kept apart ([WinComponents.Selection.user]) and win.
+ *
+ * All the work is done by one background thread (low priority, so are the runtime helpers it
+ * starts), one job at a time from one queue: working out a game's list (kept, so a page opens on
+ * it) and downloading a component (each once, whichever games want it). The queue waits while a
+ * session runs; jobs nobody asked for (the start-up sweep, a game being launched) also wait on
+ * battery saver, a warm device or a metered network. Nothing here runs on the caller's thread.
+ */
+object AutoComponents {
+    private const val TAG = "AutoComponents"
+
+    /** The key a game's picks are kept under: the appid its prefix is named after. */
+    fun appKey(game: Library.SteamGame): String? =
+        if (game.library == Library.ADDED) Integer.toUnsignedString(game.appId) else game.appId.takeIf { it > 0 }?.toString()
+
+    /**
+     * What turns on by itself for [findings], given [catalog] and what is [installed]: the catalog
+     * name each auto finding installs as, with its reason. A component that needs a Windows
+     * installer, or is not in the catalog, stays out (the editor lists it as a suggestion).
+     */
+    fun autoPicks(findings: List<WinCompSources.Finding>, catalog: Map<String, WinComponents.Component>): Map<String, WinComponents.AutoReason> {
+        val out = LinkedHashMap<String, WinComponents.AutoReason>()
+        for (f in findings) {
+            if (!f.auto || f.component == null) continue
+            val id = WinComponents.installable(f.component, catalog)
+            val c = catalog[id] ?: continue
+            if (WinComponents.support(c, catalog) != WinComponents.Support.READY) continue
+            if (id !in out) out[id] = WinComponents.AutoReason(f.origin.name, listOf(f.original) + f.args)
+        }
+        return out
+    }
+
+    // ---- seams for tests ----
+    @VisibleForTesting internal var catalogOf: (Context, Boolean) -> List<WinComponents.Component>? =
+        { c, network -> if (network) WinComponents.fetch(c) else WinComponents.cached(c) }
+    @VisibleForTesting internal var installedOf: (Context) -> Set<String> = { WinComponents.installedIds(it).toSet() }
+    @VisibleForTesting internal var installer: (Context, WinComponents.Component, Map<String, WinComponents.Component>, (WinComponents.Progress) -> Unit) -> String? =
+        { c, comp, all, progress -> WinComponents.install(c, comp, all, progress) }
+    @VisibleForTesting internal var sessionRunning: () -> Boolean = { SessionState.running }
+    /** Battery saver, a warm device or a metered network: no work nobody asked for. */
+    @VisibleForTesting internal var unfavourable: (Context) -> Boolean = { c -> constrained(c) }
+    /** A usable network: a download waits for one. */
+    @VisibleForTesting internal var online: (Context) -> Boolean = { c -> isOnline(c) }
+    /** Tests run the queue on the caller's thread ([drain]) instead of the worker. */
+    @VisibleForTesting @Volatile internal var runNow = false
+
+    /** Bumped whenever a game's list or automatic components change, so an open page reads them again. */
+    val changes = MutableStateFlow(0)
+
+    /** The components downloading for an automatic pick right now, with their progress. */
+    val downloading = MutableStateFlow<Map<String, WinComponents.Progress>>(emptyMap())
+
+    /** Games (by [appKey]) whose list is queued or being worked out: a page waits on it. */
+    val pendingGames = MutableStateFlow<Set<String>>(emptySet())
+
+    /** Components queued for an automatic pick, not yet downloaded. */
+    val pendingComponents = MutableStateFlow<Set<String>>(emptySet())
+
+    private fun mark(job: Job, on: Boolean) {
+        if (job.pics != null) return
+        val flow = if (job.component != null) pendingComponents else pendingGames
+        val id = job.component ?: job.game?.let { appKey(it) } ?: return
+        flow.value = if (on) flow.value + id else flow.value - id
+    }
+
+    /** One piece of work: a game's list ([game]) or one component's download ([component]). [asked]: the user is waiting on it. */
+    internal class Job(
+        val game: Library.SteamGame?, val component: String?, val asked: Boolean, val seq: Long, val pics: List<Int>? = null,
+        /** For a game Steam installed during the running session: may run in it, unless a game is running. */
+        val inSession: Boolean = false,
+    ) {
+        val key get() = when {
+            pics != null -> "pics"
+            component != null -> "c:$component"
+            else -> "g:" + (game?.let { appKey(it) } ?: "")
+        }
+        /** Needs the network: a download, or Steam asked anonymously. */
+        val online get() = component != null || pics != null
+    }
+
+    private val seq = java.util.concurrent.atomic.AtomicLong()
+    /** What the user asked for first, then in the order queued. */
+    private val jobs = PriorityBlockingQueue<Job>(16, compareByDescending<Job> { it.asked }.thenBy { it.seq })
+    @Volatile private var draining = false
+    private val queuedKeys = java.util.Collections.synchronizedSet(HashSet<String>())
+    /** The games waiting on a component's download, to turn it on for when it lands. */
+    private val waiting = HashMap<String, MutableList<Library.SteamGame>>()
+    @Volatile private var worker: Thread? = null
+    private const val PAUSE_MS = 15_000L
+
+    /**
+     * [game]'s list worked out again on the worker, and its components queued: [asked] when the
+     * user is waiting (its page is open, or they installed or added it).
+     */
+    fun queueGame(context: Context, game: Library.SteamGame, asked: Boolean) {
+        if (appKey(game) == null) return
+        enqueue(context, Job(game, null, asked, seq.incrementAndGet()))
+    }
+
+    private fun queueDownload(context: Context, id: String, asked: Boolean, inSession: Boolean = false) =
+        enqueue(context, Job(null, id, asked, seq.incrementAndGet(), inSession = inSession))
+
+    /** Adds [job] unless the same one is queued (a game or a component, once each). */
+    private fun enqueue(context: Context, job: Job) {
+        if (!queuedKeys.add(job.key)) {
+            // Asked for now: ahead of what nobody asked for, so the open page does not wait behind the sweep.
+            if (job.asked && jobs.removeIf { it.key == job.key && !it.asked }) jobs.add(job)
+            if (runNow && !draining) drain(context)
+            return
+        }
+        if (job.component != null) Log.i(TAG, "wincomp: queued ${job.component}")
+        mark(job, true)
+        jobs.add(job)
+        if (runNow) { if (!draining) drain(context) } else ensureWorker(context.applicationContext)
+    }
+
+    /** Whether [job] has to wait: always while a session runs; one nobody asked for also when it is unfavourable. */
+    internal fun mustWait(context: Context, job: Job): Boolean =
+        if (job.inSession && sessionRunning()) gameRunning() || (job.online && !online(context))
+        else sessionRunning() || (job.online && !online(context)) || (!job.asked && unfavourable(context))
+
+    /** A game is running in the session (Steam's reaper, or Proton waiting on its game). */
+    @VisibleForTesting internal var gameRunning: () -> Boolean = { gameProcessRunning() }
+
+    private fun gameProcessRunning(): Boolean = File("/proc").listFiles()?.any { p ->
+        p.name.all(Char::isDigit) && runCatching { String(File(p, "cmdline").readBytes()).replace('\u0000', ' ') }.getOrNull()
+            ?.let { it.contains("SteamLaunch AppId=") || it.contains("proton waitforexitandrun") } == true
+    } == true
+
+    /**
+     * A game Steam installed during the running session: its list worked out and its components
+     * readied in the session (one job, low priority), so a launch right after finds them; it
+     * waits while a game runs. All other work stays paused until the session ends.
+     */
+    fun queueInSession(context: Context, game: Library.SteamGame) {
+        if (appKey(game) == null) return
+        enqueue(context, Job(game, null, true, seq.incrementAndGet(), inSession = true))
+    }
+
+    /** Runs the queued jobs on this thread until the queue is empty or the next one has to wait. Tests. */
+    @VisibleForTesting
+    internal fun drain(context: Context) {
+        draining = true
+        try {
+            while (true) {
+                val job = next(context) ?: return
+                queuedKeys.remove(job.key)
+                run(context, job)
+            }
+        } finally {
+            draining = false
+        }
+    }
+
+    /** The first job in order that may run now, taken off the queue; null when none may. */
+    private fun next(context: Context): Job? = synchronized(jobs) {
+        val job = jobs.sortedWith(order).firstOrNull { !mustWait(context, it) } ?: return null
+        jobs.remove(job)
+        job
+    }
+
+    private val order = compareByDescending<Job> { it.asked }.thenBy { it.seq }
+
+    @VisibleForTesting internal fun queued(): List<String> = jobs.sortedWith(compareByDescending<Job> { it.asked }.thenBy { it.seq }).map { it.key }
+
+    @Synchronized
+    private fun ensureWorker(app: Context) {
+        if (worker?.isAlive == true) return
+        worker = Thread({
+            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND)
+            while (true) {
+                // Something queued, then the first that may run (one for a game installed in the
+                // session goes ahead of paused work); else a look again in a while.
+                try { jobs.put(jobs.take()) } catch (e: InterruptedException) { return@Thread }
+                val job = next(app)
+                if (job == null) {
+                    try { Thread.sleep(PAUSE_MS) } catch (e: InterruptedException) { return@Thread }
+                    continue
+                }
+                queuedKeys.remove(job.key)
+                WinComponents.background { run(app, job) }
+            }
+        }, "auto-components").apply { isDaemon = true; start() }
+    }
+
+    private fun run(context: Context, job: Job) {
+        try {
+            when {
+                job.pics != null -> SteamAppInfo.lookup(context, job.pics)
+                job.component != null -> download(context, job.component, job.asked, job.inSession)
+                else -> job.game?.let { apply(context, it, job.asked, job.inSession) }
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "wincomp: ${job.key}: ${e.javaClass.simpleName}: ${e.message}")
+        } finally {
+            mark(job, false)
+            changes.value = changes.value + 1
+        }
+    }
+
+    /**
+     * [game]'s list (worked out again only when what it is read from changed), its automatic
+     * components that are downloaded turned on, and the rest queued for download.
+     */
+    private fun apply(context: Context, game: Library.SteamGame, asked: Boolean, inSession: Boolean = false) {
+        val key = appKey(game) ?: return
+        val folder = game.gameFiles
+        if (game.library == Library.ADDED && game.source == Library.ADDED && folder != null && SteamMatch.get(context, folder.path) == null) {
+            AddedGames.single(context, folder.path)?.let { SteamMatch.resolve(context, folder.path, it.exe, it.name) }
+        }
+        // A GOG or Epic game installed before its sidecar kept the store's list: read it once from the store.
+        val store = com.droiddeck.launcher.stores.Store.byId(game.source)
+        if (folder != null && (store == com.droiddeck.launcher.stores.Store.GOG || store == com.droiddeck.launcher.stores.Store.EPIC)) StoreListBackfill.fill(context, folder)
+        // Its Steam app, when the client never saw it: Steam asked anonymously now if the user is
+        // waiting on this game (a pass over every game asks for all of them in one go, [sweep]).
+        if (asked && online(context)) steamAppOf(context, game)?.let { SteamAppInfo.lookup(context, listOf(it)) }
+        val findings = findings(context, game)
+        val catalog = (catalogOf(context, false) ?: catalogOf(context, true))?.associateBy { it.name } ?: return
+        val wanted = autoPicks(findings, catalog)
+        val user = WinComponents.selection(context, key).user
+        val installed = installedOf(context)
+        val kept = LinkedHashMap<String, WinComponents.AutoReason>()
+        val missing = ArrayList<String>()
+        for ((id, reason) in wanted) {
+            if (user[id] == false) { kept[id] = reason; continue }
+            if (id in installed) { kept[id] = reason; continue }
+            synchronized(waiting) { waiting.getOrPut(id) { ArrayList() }.let { if (it.none { g -> appKey(g) == key }) it.add(game) } }
+            queueDownload(context, id, asked, inSession)
+            missing.add(id)
+        }
+        // In a session the launch waits a little for these (droiddeck-wincomponents reads the list).
+        if (inSession) Pending.set(context, key, missing)
+        val before = WinComponents.selection(context, key).auto
+        if (before.keys != kept.keys) {
+            WinComponents.setAuto(context, key, kept)
+            Log.i(TAG, "${game.name}: on by itself ${kept.keys.joinToString().ifEmpty { "(none)" }}")
+        }
+        changes.value = changes.value + 1
+    }
+
+    /** One component downloaded and installed, then turned on for every game waiting on it. */
+    private fun download(context: Context, id: String, asked: Boolean, inSession: Boolean = false) {
+        val catalog = catalogOf(context, true)?.associateBy { it.name } ?: run { Pending.drop(context, id); return }
+        if (id !in installedOf(context)) {
+            val c = catalog[id] ?: run { Pending.drop(context, id); return }
+            val started = System.currentTimeMillis()
+            downloading.value = downloading.value + (id to WinComponents.Progress(id, "", WinComponents.Phase.DOWNLOAD, -1))
+            val problem = try {
+                installer(context, c, catalog) { p -> downloading.value = downloading.value + (id to p) }
+            } finally {
+                downloading.value = downloading.value - id
+            }
+            if (problem != null) { Log.w(TAG, "wincomp: $id did not install: $problem"); Pending.drop(context, id); return }
+            Log.i(TAG, "wincomp: $id installed in ${System.currentTimeMillis() - started}ms")
+        }
+        val games = synchronized(waiting) { waiting.remove(id).orEmpty() }
+        games.forEach { apply(context, it, asked, inSession) }
+        Pending.drop(context, id)
+    }
+
+    /**
+     * The components still being readied for games installed in the session, where the launch
+     * reads them (~/.config/droiddeck/wincomponents-pending.json in the runtime).
+     */
+    internal object Pending {
+        private fun file(context: Context) = File(com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(context), "root/.config/droiddeck/wincomponents-pending.json")
+
+        @Synchronized fun read(context: Context): JSONObject =
+            runCatching { JSONObject(file(context).readText()) }.getOrDefault(JSONObject()).let { it.optJSONObject("games") ?: JSONObject() }
+
+        @Synchronized fun set(context: Context, key: String, ids: List<String>) {
+            val games = read(context)
+            if (ids.isEmpty()) games.remove(key) else games.put(key, JSONArray(ids))
+            write(context, games)
+        }
+
+        @Synchronized fun drop(context: Context, id: String) {
+            val games = read(context)
+            for (k in games.keys().asSequence().toList()) {
+                val left = games.optJSONArray(k)?.let { a -> (0 until a.length()).map { a.optString(it) } }.orEmpty() - id
+                if (left.isEmpty()) games.remove(k) else games.put(k, JSONArray(left))
+            }
+            write(context, games)
+        }
+
+        private fun write(context: Context, games: JSONObject) {
+            val f = file(context)
+            runCatching {
+                f.parentFile?.mkdirs()
+                val tmp = File(f.path + ".tmp")
+                tmp.writeText(JSONObject().put("games", games).toString())
+                if (!tmp.renameTo(f)) { f.delete(); tmp.renameTo(f) }
+            }
+        }
+    }
+
+    // ---- the list, kept per game ----
+
+    private const val FINDINGS = "wincomp-findings.json"
+
+    /** What the list is read from, by modification time: a change means it is worked out again. */
+    internal fun signature(context: Context, game: Library.SteamGame): String {
+        val folder = game.gameFiles
+        val parts = listOfNotNull(
+            folder?.lastModified(),
+            folder?.let { SteamRedists.manifest(it, game.appId)?.lastModified() },
+            folder?.let { StoreGameSidecar.file(it).lastModified() },
+            folder?.let { File(it, "fuel.json").lastModified() },
+            SteamAppInfo.appinfoFile(context).lastModified(),
+            folder?.let { SteamMatch.get(context, it.path) }?.let { "${it.appId}/${it.certainty}" },
+            steamAppOf(context, game)?.let { SteamAppInfo.state(context, it) },
+        )
+        return parts.joinToString("|")
+    }
+
+    /** [game]'s list: the one kept when nothing it is read from changed, else worked out again and kept. Worker only. */
+    internal fun findings(context: Context, game: Library.SteamGame): List<WinCompSources.Finding> {
+        val key = appKey(game) ?: return emptyList()
+        val sig = signature(context, game)
+        val all = readFindings(context)
+        all.optJSONObject(key)?.takeIf { it.optString("sig") == sig }?.let { return decode(it.optJSONArray("findings")) }
+        val fresh = WinCompSources.forGame(context, game)
+        writeFindings(context, all.put(key, JSONObject().put("sig", sig).put("findings", encode(fresh))))
+        return fresh
+    }
+
+    /** The list kept for [appKey], without working anything out; null before the first time. */
+    fun cachedFindings(context: Context, appKey: String): List<WinCompSources.Finding>? =
+        readFindings(context).optJSONObject(appKey)?.let { decode(it.optJSONArray("findings")) }
+
+    @Synchronized
+    private fun readFindings(context: Context): JSONObject =
+        runCatching { JSONObject(AtomicFile(File(context.filesDir, FINDINGS)).readFully().toString(Charsets.UTF_8)) }.getOrDefault(JSONObject())
+
+    @Synchronized
+    private fun writeFindings(context: Context, json: JSONObject) {
+        val atomic = AtomicFile(File(context.filesDir, FINDINGS))
+        val out = atomic.startWrite()
+        try { out.write(json.toString().toByteArray()); atomic.finishWrite(out) } catch (e: Exception) { atomic.failWrite(out) }
+    }
+
+    private fun encode(list: List<WinCompSources.Finding>) = JSONArray().apply {
+        list.forEach { f ->
+            put(JSONObject().put("original", f.original).put("origin", f.origin.name).put("auto", f.auto).put("args", JSONArray(f.args))
+                .apply { f.component?.let { put("component", it) } })
+        }
+    }
+
+    private fun decode(arr: JSONArray?): List<WinCompSources.Finding> = if (arr == null) emptyList() else (0 until arr.length()).mapNotNull { i ->
+        val o = arr.optJSONObject(i) ?: return@mapNotNull null
+        val origin = runCatching { WinCompSources.Origin.valueOf(o.optString("origin")) }.getOrNull() ?: return@mapNotNull null
+        val args = o.optJSONArray("args")?.let { a -> (0 until a.length()).map { a.optString(it) } }.orEmpty()
+        WinCompSources.Finding(o.optString("component").takeIf { it.isNotEmpty() }, o.optString("original"), origin, o.optBoolean("auto"), args)
+    }
+
+    // ---- when ----
+
+    /** Before a launch from DroidDeck: nothing but a queued look (it waits for the session to end). */
+    fun beforeLaunch(context: Context, game: Library.SteamGame) = queueGame(context, game, asked = false)
+
+    /** After an install or an add: the user did it, so it does not wait on a metered network. */
+    fun refreshLater(context: Context, game: Library.SteamGame) = queueGame(context, game, asked = true)
+
+    /**
+     * Every game, whatever its source, at app start and after each session (Steam installs its
+     * games without a word to DroidDeck; older GOG and Epic installs get their list read once):
+     * only queued, one game at a time, behind anything asked for, under the same conditions. A
+     * game whose files did not change costs a look at their times.
+     */
+    fun sweep(context: Context, games: List<Library.SteamGame>) {
+        // First every Steam app these games are that the client never saw, asked of Steam in one
+        // connection; then each game's list.
+        val apps = games.mapNotNull { steamAppOf(context, it) }.distinct()
+        if (apps.isNotEmpty() && SteamAppInfo.needLookup(context, apps).isNotEmpty()) enqueue(context, Job(null, null, false, seq.incrementAndGet(), pics = apps))
+        games.forEach { queueGame(context, it, asked = false) }
+    }
+
+    /** The Steam app whose list a game takes: a Steam game's own, or an added game's match. */
+    private fun steamAppOf(context: Context, game: Library.SteamGame): Int? =
+        if (game.library != Library.ADDED) game.appId.takeIf { it > 0 }
+        else game.gameFiles?.let { SteamMatch.get(context, it.path) }?.appId
+
+    /** The default network is there and validated (reaches the internet). */
+    fun isOnline(context: Context): Boolean {
+        val cm = context.getSystemService(ConnectivityManager::class.java) ?: return false
+        val caps = cm.getNetworkCapabilities(cm.activeNetwork ?: return false) ?: return false
+        return caps.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+            caps.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED)
+    }
+
+    /** Battery saver, thermal status moderate or worse, or a metered network. */
+    private fun constrained(context: Context): Boolean {
+        val power = context.getSystemService(PowerManager::class.java)
+        if (power?.isPowerSaveMode == true) return true
+        if (Build.VERSION.SDK_INT >= 29 && (power?.currentThermalStatus ?: 0) >= PowerManager.THERMAL_STATUS_MODERATE) return true
+        return context.getSystemService(ConnectivityManager::class.java)?.isActiveNetworkMetered == true
+    }
+}
@@ -0,0 +1,269 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+import java.util.Locale
+
+/**
+ * Best-effort detection of the Windows redistributables a game bundles, by scanning its install
+ * folder for the redist installers Steam/Epic/GOG ship (`_CommonRedist/`, `_Redist/`,
+ * `Redistributables/`, loose `vcredist_x64.exe`, …) and mapping them to entries in our component
+ * catalog (WinComponents, Bannerlator's components.json `name` keys). The result drives the
+ * Recommended part of a game's Windows components; the user still switches each one on.
+ * Bannerlator's detector, unchanged but for this note and its package.
+ *
+ * Wine-aware: keeps the redists that actually matter under Wine/DXVK (VC++ runtimes, .NET, PhysX,
+ * OpenAL, XACT, XNA, GFWL) and SKIPS the ones DXVK/VKD3D already provide (DX12 Agility SDK) or that
+ * aren't our components (anti-cheat, Rockstar/Social-Club/launcher setups). Never throws; returns an
+ * empty list on anything unexpected. Pure filesystem — no network, no Android deps (unit-testable).
+ */
+object DependencyDetector {
+
+    /** How a recommendation was found — drives the UI's "recommended vs optional" split. */
+    enum class Kind {
+        /** The game bundles the redist installer (in _CommonRedist etc.) — meant to be installed. */
+        BUNDLED,
+        /** A runtime DLL the game ships loose — usually already works from the game folder; install
+         *  only if the game misbehaves. */
+        SHIPPED,
+        /** Steam installs it with the game from Steamworks Shared ([SteamRedists]). */
+        STEAM,
+    }
+
+    /** A recommended component: the catalog [componentName] to install, a display [label], the on-disk
+     *  redist that triggered it ([reason]), and [kind] (bundled installer vs shipped DLL). */
+    data class Recommendation(val componentName: String, val label: String, val reason: String, val kind: Kind = Kind.BUNDLED)
+
+    private const val MAX_DEPTH = 5
+    private const val MAX_ENTRIES = 8000 // cost guard against giant game trees
+
+    /** A loose VC++ installer with no year in its path — resolved to "latest" only if no specific
+     *  vcredistYYYY was found anywhere (else it's just a duplicate of the versioned one). */
+    private const val VCREDIST_LOOSE = "__vcredist_loose"
+
+    /** Directory names that are redist containers worth descending into. */
+    private val REDIST_DIR_RE = Regex(
+        """(?i)^(_?commonredist|_?redist(ributables)?|__?installer|vcredist|vc_redist|directx|direct_x|physx|openal|dotnet(fx)?|\.net|xna|xact|redist|support)$"""
+    )
+
+    /** Skip whole subtrees that are never our components. */
+    private val SKIP_DIR_RE = Regex("""(?i)^(d3d12.*|.*agility.*|dxvk|vkd3d|battleye|easyanticheat|eac|anticheat)$""")
+
+    private val YEAR_TO_VCREDIST = mapOf(
+        "2005" to "vcredist2005", "2008" to "vcredist2008", "2010" to "vcredist2010",
+        "2012" to "vcredist2012", "2013" to "vcredist2013", "2015" to "vcredist2015",
+        "2017" to "vcredist2015", "2019" to "vcredist2019", "2022" to "vcredist2022",
+    )
+
+    private val LABELS = mapOf(
+        "vcredist2005" to "Visual C++ 2005", "vcredist2008" to "Visual C++ 2008",
+        "vcredist2010" to "Visual C++ 2010", "vcredist2012" to "Visual C++ 2012",
+        "vcredist2013" to "Visual C++ 2013", "vcredist2015" to "Visual C++ 2015-2017",
+        "vcredist2019" to "Visual C++ 2019", "vcredist2022" to "Visual C++ 2015-2022",
+        "physx" to "NVIDIA PhysX", "oalinst" to "OpenAL", "xact" to "DirectX XACT audio",
+        "xact_x64" to "DirectX XACT audio (x64)", "xna40" to "XNA Framework 4.0",
+        "xna31" to "XNA Framework 3.1", "d3dx9" to "DirectX 9 (d3dx9)", "d3dx11" to "DirectX 11 (d3dx11)",
+        "XLiveRedist" to "Games for Windows Live", "dotnet40" to ".NET Framework 4.0",
+        "dotnet45" to ".NET Framework 4.5", "dotnet452" to ".NET Framework 4.5.2",
+        "dotnet46" to ".NET Framework 4.6", "dotnet472" to ".NET Framework 4.7.2",
+        "dotnet48" to ".NET Framework 4.8", "dotnet35" to ".NET Framework 3.5",
+        "dotnetcoredesktop6" to ".NET Desktop 6", "dotnetcoredesktop7" to ".NET Desktop 7",
+        "dotnetcoredesktop8" to ".NET Desktop 8",
+    )
+
+    /** Preferred install order (runtimes others may depend on first). */
+    private val INSTALL_ORDER = listOf(
+        "vcredist2005", "vcredist2008", "vcredist2010", "vcredist2012", "vcredist2013",
+        "vcredist2015", "vcredist2019", "vcredist2022",
+        "dotnet35", "dotnet40", "dotnet45", "dotnet452", "dotnet46", "dotnet472", "dotnet48",
+        "dotnetcoredesktop6", "dotnetcoredesktop7", "dotnetcoredesktop8",
+        "d3dx9", "d3dx11", "xact", "xact_x64", "xna31", "xna40", "physx", "oalinst", "XLiveRedist",
+    )
+
+    /**
+     * Detect from the .exe the user picked, resolving the game root first: walk up from the exe's
+     * folder (bounded) to the nearest ancestor that holds a redist container (`_CommonRedist`, …) at
+     * its top level, and scan from there — so a nested exe (`…/Game/bin/x.exe`) still finds a root-level
+     * `_CommonRedist`, without over-reaching into a shared `steamapps/common` (which has no redist
+     * container of its own). Falls back to scanning the exe's own folder.
+     */
+    fun detectForExe(exeFile: File): List<Recommendation> {
+        val start = exeFile.absoluteFile.parentFile ?: return emptyList()
+        var d: File? = start
+        var depth = 0
+        while (d != null && depth < 4) {
+            val hasRedistContainer = try {
+                d.listFiles()?.any { it.isDirectory && REDIST_DIR_RE.matches(it.name.lowercase(Locale.US)) } == true
+            } catch (_: Throwable) { false }
+            if (hasRedistContainer) return detect(d)
+            d = d.parentFile
+            depth++
+        }
+        return detect(start)
+    }
+
+    /**
+     * Scan [gameDir] and return the recommended components, de-duplicated (first reason wins), in a
+     * stable install-friendly order. Empty when nothing is detected or [gameDir] isn't a directory.
+     */
+    fun detect(gameDir: File): List<Recommendation> {
+        if (!gameDir.isDirectory) return emptyList()
+        val hits = LinkedHashMap<String, Recommendation>() // componentName -> first recommendation
+        var visited = 0
+
+        fun consider(f: File, isDir: Boolean, insideRedist: Boolean) {
+            val name = f.name.lowercase(Locale.US)
+            val path = f.path.replace('\\', '/').lowercase(Locale.US)
+            // Bundled = in a redist container or an installer (exe/msi/cab); shipped = a loose runtime DLL.
+            val kind = if (insideRedist || isDir || name.endsWith(".exe") || name.endsWith(".msi") || name.endsWith(".cab"))
+                Kind.BUNDLED else Kind.SHIPPED
+            for (comp in classify(path, name, isDir)) {
+                val existing = hits[comp]
+                if (existing == null) {
+                    hits[comp] = Recommendation(comp, LABELS[comp] ?: comp, relativeReason(gameDir, f), kind)
+                } else if (existing.kind == Kind.SHIPPED && kind == Kind.BUNDLED) {
+                    hits[comp] = existing.copy(kind = Kind.BUNDLED) // a bundled installer outranks a shipped DLL
+                }
+            }
+        }
+
+        fun walk(dir: File, depth: Int, insideRedist: Boolean) {
+            if (depth > MAX_DEPTH || visited > MAX_ENTRIES) return
+            val entries = dir.listFiles() ?: return
+            for (f in entries) {
+                if (visited++ > MAX_ENTRIES) return
+                val lower = f.name.lowercase(Locale.US)
+                if (f.isDirectory) {
+                    if (SKIP_DIR_RE.matches(lower)) continue
+                    // Unity's <Game>_Data/Managed holds the game's own Mono assemblies, not a .NET
+                    // Framework to install.
+                    if (lower == "managed" && dir.name.endsWith("_Data", ignoreCase = true)) continue
+                    val isRedistDir = insideRedist || REDIST_DIR_RE.matches(lower)
+                    if (isRedistDir) consider(f, isDir = true, insideRedist = true)
+                    // Aggressive coverage: descend redist containers fully, and otherwise sweep the game
+                    // tree a few levels deep so runtime libraries the game ships (in bin/, etc.) are seen.
+                    if (isRedistDir || depth < 3) walk(f, depth + 1, isRedistDir)
+                } else {
+                    // Classify installers + runtime libraries (.dll/.exe/.msi) anywhere in the scanned
+                    // tree; other files are ignored. Recommendations are advisory, so cast a wide net.
+                    val ext = lower.substringAfterLast('.', "")
+                    if (insideRedist || ext == "dll" || ext == "exe" || ext == "msi") consider(f, isDir = false, insideRedist = insideRedist)
+                }
+            }
+        }
+
+        return try {
+            walk(gameDir, 0, false)
+            resolveLooseVcredist(hits)
+            hits.values.sortedBy { INSTALL_ORDER.indexOf(it.componentName).let { i -> if (i < 0) 999 else i } }
+        } catch (_: Throwable) {
+            emptyList()
+        }
+    }
+
+    /**
+     * The catalog components one installer stands for, by its path ("_CommonRedist/vcredist/2015/
+     * vc_redist.x64.exe", "DXSETUP.exe"): what a store's install list names. A VC++ installer
+     * with no year is the latest; empty for one that is none of ours.
+     */
+    fun componentsFor(path: String): List<String> {
+        val p = path.replace('\\', '/').lowercase(Locale.US)
+        return classify(p, p.substringAfterLast('/'), isDir = false).map { if (it == VCREDIST_LOOSE) "vcredist2022" else it }
+    }
+
+    /** The name the catalog component [name] goes by, for a reason line. */
+    fun label(name: String): String = LABELS[name] ?: name
+
+    /** A loose VC++ installer resolves to the latest 14.x only if no specific vcredistYYYY was found. */
+    private fun resolveLooseVcredist(hits: LinkedHashMap<String, Recommendation>) {
+        val loose = hits.remove(VCREDIST_LOOSE) ?: return
+        val hasSpecific = hits.keys.any { it in YEAR_TO_VCREDIST.values }
+        if (!hasSpecific) hits["vcredist2022"] = loose.copy(componentName = "vcredist2022", label = LABELS["vcredist2022"]!!)
+    }
+
+    private fun relativeReason(gameDir: File, f: File): String {
+        val g = gameDir.path.replace('\\', '/')
+        val p = f.path.replace('\\', '/')
+        return if (p.startsWith("$g/")) p.substring(g.length + 1) else f.name
+    }
+
+    /**
+     * Map a redist file/dir (its full lowercased [path], leaf [name], and whether it [isDir]) to
+     * catalog component name(s). Empty for things we deliberately skip.
+     */
+    private fun classify(path: String, name: String, isDir: Boolean): List<String> {
+        // Hard skips first — DX12 is provided by DXVK/VKD3D; these aren't our components.
+        if (path.contains("d3d12") || path.contains("agility") ||
+            path.contains("battleye") || path.contains("anticheat") || path.contains("easyanticheat") ||
+            name.contains("socialclub") || name.contains("social-club") ||
+            name.contains("rockstar") || name == "setup.exe"
+        ) return emptyList()
+
+        // Visual C++ runtimes — most important. Year comes from the path context.
+        if (path.contains("vcredist") || path.contains("vc_redist") || name.startsWith("vcredist") || name.startsWith("vc_redist")) {
+            val year = YEAR_TO_VCREDIST.keys.firstOrNull { path.contains(it) }
+            return when {
+                year != null -> listOf(YEAR_TO_VCREDIST.getValue(year))
+                isDir -> emptyList()              // bare "vcredist" container — wait for the year subfolder / installer
+                else -> listOf(VCREDIST_LOOSE)    // loose installer, no year → resolved post-walk
+            }
+        }
+        // VC++ runtime DLL the game ships (msvcp140.dll → 2015-2022, msvcp120.dll → 2013, …).
+        VCRUNTIME_DLL.entries.firstOrNull { name.startsWith(it.key) }?.let { return listOf(it.value) }
+        if (path.contains("openal") || name.startsWith("oalinst") || name == "openal32.dll" || name == "wrap_oal.dll") return listOf("oalinst")
+        if (path.contains("physx") || name.startsWith("physx")) return listOf("physx")
+        if (path.contains("xact") || name.startsWith("xactengine") || name.startsWith("x3daudio")) return listOf("xact", "xact_x64")
+        // Games for Windows Live — the redist folder, OR a GFWL library the game ships (xlive.dll,
+        // Codemasters' dbxLive32/64, gfwl*): GFWL titles need XLiveRedist to run even when they don't
+        // bundle the redist itself.
+        if (path.contains("xliveredist") || name.contains("xlive") || name.startsWith("gfwl") || name.startsWith("dbxlive")) {
+            return listOf("XLiveRedist")
+        }
+        if (path.contains("xna")) return listOf(if (path.contains("3.1") || path.contains("3_1") || path.contains("v31")) "xna31" else "xna40")
+        // .NET — Framework and Core/Desktop runtimes.
+        if (path.contains("dotnet") || path.contains(".net") || name.startsWith("ndp") || name.startsWith("dotnetfx") || name.contains("windowsdesktop-runtime")) {
+            val comp = dotnetComponent("$path $name")
+            return when {
+                comp != null -> listOf(comp)
+                isDir -> emptyList()          // bare ".NET" container — wait for the versioned installer
+                else -> listOf("dotnet48")    // unlabeled .NET Framework installer file → sensible default
+            }
+        }
+        // DirectX 11 helper DLLs the game ships (d3dx11_43.dll).
+        if (D3DX11_RE.matches(name)) return listOf("d3dx11")
+        // DirectX 9 helper DLLs / d3dcompiler / June-2010 DX redist (DXVK provides core d3d9 but NOT
+        // these helper DLLs).
+        if (name.startsWith("dxsetup") || name.startsWith("dxwebsetup") ||
+            D3DX9_RE.matches(name) || D3DCOMPILER_RE.matches(name) ||
+            (path.contains("directx") && name.endsWith(".exe"))
+        ) return listOf("d3dx9")
+        return emptyList()
+    }
+
+    /** Runtime DLL prefix → the VC++ redistributable that provides it (checked with startsWith). */
+    private val VCRUNTIME_DLL = linkedMapOf(
+        "vcruntime140" to "vcredist2022", "msvcp140" to "vcredist2022", "msvcr140" to "vcredist2022", "concrt140" to "vcredist2022",
+        "msvcp120" to "vcredist2013", "msvcr120" to "vcredist2013",
+        "msvcp110" to "vcredist2012", "msvcr110" to "vcredist2012",
+        "msvcp100" to "vcredist2010", "msvcr100" to "vcredist2010",
+        "msvcp90" to "vcredist2008", "msvcr90" to "vcredist2008",
+        "msvcp80" to "vcredist2005", "msvcr80" to "vcredist2005",
+    )
+    private val D3DX9_RE = Regex("""d3dx9_\d+\.dll""")
+    private val D3DX11_RE = Regex("""d3dx11_\d+\.dll""")
+    private val D3DCOMPILER_RE = Regex("""d3dcompiler_\d+\.dll""")
+
+    /** Resolve a .NET component from installer/path text, or null when no version is discernible. */
+    private fun dotnetComponent(s: String): String? = when {
+        s.contains("desktop-runtime-8") || Regex("""\b8\.\d""").containsMatchIn(s) -> "dotnetcoredesktop8"
+        s.contains("desktop-runtime-7") || Regex("""\b7\.\d""").containsMatchIn(s) -> "dotnetcoredesktop7"
+        s.contains("desktop-runtime-6") || Regex("""\b6\.\d""").containsMatchIn(s) -> "dotnetcoredesktop6"
+        s.contains("ndp48") || s.contains("fx48") || s.contains("4.8") -> "dotnet48"
+        s.contains("ndp472") || s.contains("4.7.2") -> "dotnet472"
+        s.contains("ndp46") || s.contains("4.6") -> "dotnet46"
+        s.contains("ndp452") || s.contains("4.5.2") -> "dotnet452"
+        s.contains("dotnetfx45") || s.contains("ndp45") || s.contains("4.5") -> "dotnet45"
+        s.contains("dotnetfx40") || s.contains("ndp40") || s.contains("4.0") -> "dotnet40"
+        s.contains("dotnetfx35") || s.contains("3.5") -> "dotnet35"
+        else -> null // no version signal (e.g. a bare "DotNet" container dir)
+    }
+}
@@ -0,0 +1,130 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+
+/**
+ * Which `.exe` in a game folder is the game. A real install holds installers, crash handlers,
+ * anti-cheat stubs and launchers beside the game, and the game itself may sit several levels down
+ * (`Game/Binaries/Win64/Game-Win64-Shipping.exe`), so candidates are collected with a bounded walk
+ * and ranked rather than guessed by position.
+ */
+object GameExePicker {
+    /** How far below a game folder to look: Unreal puts the game three down, repacks deeper. */
+    const val MAX_DEPTH = 5
+
+    /** Folders and .exe files looked at per game before the walk stops, so a huge game stays quick. */
+    const val WALK_BUDGET = 400
+
+    /** Below this the pick is marked uncertain rather than trusted silently. */
+    const val CONFIDENT_SCORE = 60
+
+    /** The best and the runner-up this close together: nothing clearly won. */
+    const val AMBIGUOUS_MARGIN = 15
+
+    /** Folders that never hold the game itself. */
+    private val SKIP_DIRS = setOf(
+        "_commonredist", "commonredist", "redist", "redistributable", "redistributables",
+        "directx", "dotnet", "dotnetfx", "vcredist", "vc_redist", "prerequisites", "prereq",
+        "installer", "installers", "__installer", "support", "extras", "docs", "documentation", "manual",
+        "soundtrack", "ost", "artbook", "bonus", "dlc", "mods", "saves", "savegames",
+        "crashreportclient", "easyanticheat", "battleye", "punkbuster", "steamworks shared", ".git",
+    )
+    private val SKIP_DIR_PREFIX = listOf("dotnet", "vcredist", "$")
+    private val SKIP_PATHS = listOf("engine/extras", "engine/binaries/thirdparty")
+
+    /** Exe names that are never the game. */
+    private val JUNK_EXE_RE = Regex(
+        """(?i)^(unins\w*|setup|install\w*|vc_?redist.*|vcredist.*|dxsetup|dxwebsetup|directx.*|""" +
+            """oalinst|openal.*|dotnetfx.*|ndp\d.*|unitycrashhandler\d*|crashreport\w*|crashpad\w*|""" +
+            """crashsender\w*|easyanticheat\w*|eac\w*|battleye\w*|beservice\w*|punkbuster\w*|""" +
+            """steamerrorreporter\d*|gameoverlayui|touchup|cleanup|config|settings|benchmark|""" +
+            """activation\w*|register\w*|readme|report\w*|.*_debug|.*-debug)$""",
+    )
+
+    /** A folder's exes best first, with their scores, and whether the first clearly won. */
+    class Ranking(val exes: List<File>, val scores: List<Int>, val uncertain: Boolean)
+
+    /** Ranks the .exe files under [folder]; [keep] drops names the caller never offers. */
+    fun rank(folder: File, keep: (File) -> Boolean = { true }): Ranking {
+        val scored = collect(folder).filter { keep(it.first) }.map { (exe, depth) -> exe to score(exe, folder, depth) }
+            .sortedWith(compareByDescending<Pair<File, Int>> { it.second }.thenBy { it.first.path.lowercase() })
+        val best = scored.firstOrNull()?.second
+        val runnerUp = scored.getOrNull(1)?.second
+        val uncertain = best != null && (best < CONFIDENT_SCORE || (runnerUp != null && best - runnerUp < AMBIGUOUS_MARGIN))
+        return Ranking(scored.map { it.first }, scored.map { it.second }, uncertain)
+    }
+
+    /**
+     * Every plausible exe under [folder] with its depth (0 = in the folder itself): up to
+     * [MAX_DEPTH] folders down, nearest levels first, at most [WALK_BUDGET] entries, never through a
+     * symlink, past folders that never hold the game.
+     */
+    private fun collect(folder: File): List<Pair<File, Int>> {
+        val found = ArrayList<Pair<File, Int>>()
+        var visited = 0
+        var level = listOf(folder)
+        var depth = 0
+        walk@ while (level.isNotEmpty()) {
+            val next = ArrayList<File>()
+            for (dir in level) {
+                val entries = dir.listFiles()?.sortedBy { it.name.lowercase() } ?: continue
+                for (f in entries) {
+                    if (visited >= WALK_BUDGET) break@walk
+                    if (isLink(f)) continue
+                    if (f.isDirectory) {
+                        visited++
+                        if (depth < MAX_DEPTH && !skipDir(f, f.relativeTo(folder).invariantSeparatorsPath)) next.add(f)
+                    } else if (f.isFile && f.name.endsWith(".exe", ignoreCase = true)) {
+                        visited++
+                        if (!JUNK_EXE_RE.matches(f.nameWithoutExtension)) found.add(f to depth)
+                    }
+                }
+            }
+            level = next
+            depth++
+        }
+        return found
+    }
+
+    /**
+     * How likely [exe] is to be the game in [folder]. Relative only: the numbers rank candidates
+     * against each other and decide whether anything won clearly enough to trust.
+     */
+    internal fun score(exe: File, folder: File, depth: Int): Int {
+        var score = 0
+        val base = exe.nameWithoutExtension
+        val exeKey = key(base)
+        val folderKey = key(folder.name)
+        // The exe named after its folder is the single strongest signal.
+        if (exeKey.isNotEmpty() && folderKey.isNotEmpty()) {
+            when {
+                exeKey == folderKey -> score += 100
+                folderKey.contains(exeKey) || exeKey.contains(folderKey) -> score += 60
+            }
+        }
+        // Unreal ships as <Game>-Win64-Shipping.exe under Binaries/Win64.
+        if (base.endsWith("-Win64-Shipping", true) || base.endsWith("-Win32-Shipping", true)) score += 70
+        val path = exe.absolutePath.lowercase()
+        if (path.contains("/binaries/win64") || path.contains("/binaries/win32")) score += 30
+        if (path.contains("/bin/") || path.contains("/bin64/")) score += 10
+        // A launcher is a real entry point, so it stays a candidate, just not the preferred one.
+        if (GameIdentifier.isLauncherExeName(base)) score -= 40
+        if (GameIdentifier.isJunkPeName(base)) score -= 30
+        // Shallower is more likely the entry point; big binaries beat small helpers.
+        score -= depth * 8
+        score += (exe.length() / (8L * 1024 * 1024)).toInt().coerceAtMost(30)
+        return score
+    }
+
+    private fun skipDir(dir: File, relative: String): Boolean {
+        val name = dir.name.lowercase().trim()
+        if (name in SKIP_DIRS || SKIP_DIR_PREFIX.any { name.startsWith(it) }) return true
+        val rel = relative.lowercase()
+        return SKIP_PATHS.any { rel == it || rel.endsWith("/$it") }
+    }
+
+    private fun isLink(f: File): Boolean = runCatching { java.nio.file.Files.isSymbolicLink(f.toPath()) }.getOrDefault(false)
+
+    /** Comparison key: letters and digits only, so "GTA IV" and "gta-iv" match. */
+    private fun key(s: String) = s.lowercase().filter { it.isLetterOrDigit() }
+}
@@ -2,6 +2,7 @@ package com.droiddeck.launcher.frontend

 import android.content.Context
 import android.util.Log
+import com.droiddeck.launcher.R
 import com.droiddeck.launcher.runtime.LinuxRuntime
 import com.droiddeck.launcher.session.GameStorage
 import com.droiddeck.launcher.session.SessionPrefs
@@ -37,18 +38,18 @@ object GameFileSync {
    }

    @Synchronized private fun sync(context: Context, folder: File) {
-        check(LinuxRuntime.isInstalled(context)) { "Install the runtime first" }
+        check(LinuxRuntime.isInstalled(context)) { context.getString(R.string.game_sync_err_runtime) }
        // A disconnected library must not be interpreted as a mass uninstall.
-        check(File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/steamapps").isDirectory) { "Steam library is unavailable" }
+        check(File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/steamapps").isDirectory) { context.getString(R.string.game_sync_err_steam_library) }
        val storage = GameStorage.effective(context)
        val storageSetting = SessionPrefs.gameStorage(context)
        val previousStorage = prefs(context).getString("storagePath", null)
        if (storageSetting.isEmpty() && prefs(context).getString("storageSetting", null) == storageSetting && previousStorage != null) {
-            check(File(previousStorage).isDirectory) { "Previous SD library is unavailable" }
+            check(File(previousStorage).isDirectory) { context.getString(R.string.game_sync_err_previous_sd) }
        }
-        storage?.let { check(File(it.path).listFiles() != null) { "Game storage is unavailable" } }
-        SessionPrefs.addedGamesDirs(context).forEach { check(File(it).listFiles() != null) { "Added games folder is unavailable" } }
-        GameFiles.sync(folder, Library.launchableGames(context, strictRead = true))
+        storage?.let { check(File(it.path).listFiles() != null) { context.getString(R.string.game_sync_err_game_storage) } }
+        AddedGames.roots(context).forEach { check(it.host.listFiles() != null) { context.getString(R.string.game_sync_err_added_games) } }
+        GameFiles.sync(context, folder, Library.launchableGames(context, strictRead = true))
        prefs(context).edit().putString("storageSetting", storageSetting).putString("storagePath", storage?.path).apply()
    }
 }
@@ -3,6 +3,7 @@ package com.droiddeck.launcher.frontend
 import android.content.Context
 import android.content.Intent
 import android.util.AtomicFile
+import com.droiddeck.launcher.R
 import androidx.core.util.readText
 import androidx.core.util.writeBytes
 import androidx.core.util.writeText
@@ -12,7 +13,7 @@ import java.io.InputStream

 /** Small, portable launch files for frontends that scan ROM folders. No guest paths or commands. */
 object GameFiles {
-    const val EXTENSION = "droiddeck"
+    const val EXTENSION = "steam"
    private const val MAX_BYTES = 128
    private const val INVENTORY = ".droiddeck-sync.json"
    private const val FORMAT = "droiddeck-game-files-v1"
@@ -46,83 +47,115 @@ object GameFiles {
        }
        if (count > MAX_BYTES) return null
        val text = String(bytes, 0, count, Charsets.UTF_8).trim()
-        return GameLaunchLink.parse(text) ?: text.takeIf(GameLaunchLink::validId)
+        return text.takeIf(GameLaunchLink::validId)
    }

-    fun filename(game: Library.SteamGame): String {
+    fun filename(game: Library.SteamGame, disambiguate: Boolean = false): String {
        val sanitized = game.name.replace(Regex("[\\p{Cntrl}\\\\/:*?\"<>|]"), "_")
            .trim().trim('.').ifBlank { "Game" }
        val points = sanitized.codePoints().limit(40).toArray()
        val title = String(points, 0, points.size)
-        return "$title (${game.gameIdString}).$EXTENSION"
+        val suffix = if (disambiguate) " (${game.gameIdString})" else ""
+        return "$title$suffix.$EXTENSION"
    }

-    private fun contents(id: String) = GameLaunchLink.uri(id) + "\n"
+    private fun contents(id: String): String {
+        require(GameLaunchLink.validId(id))
+        return id
+    }

-    @Synchronized fun export(folder: File, game: Library.SteamGame): File {
-        require(folder.isDirectory) { "Folder is unavailable" }
-        val target = child(folder, filename(game))
+    @Synchronized fun export(context: Context, folder: File, game: Library.SteamGame): File =
+        exportNamed(context, folder, game, filename(game))
+
+    private fun exportNamed(context: Context, folder: File, game: Library.SteamGame, name: String): File {
+        require(folder.isDirectory) { context.getString(R.string.gfiles_folder_unavailable) }
        val text = contents(game.gameIdString)
-        require(!target.exists() || matches(target, text)) { "A different file already uses ${target.name}" }
+        val target = exportTarget(context, folder, game, name)
+        require(!target.exists() || matches(target, text)) { context.getString(R.string.gfiles_name_taken, target.name) }
        if (!target.exists()) write(target, text)
-        exportArt(folder, game)
+        exportArt(context, folder, game)
        return target
    }

+    private fun exportTarget(context: Context, folder: File, game: Library.SteamGame, name: String): File {
+        val target = child(context, folder, name)
+        return if (target.exists() && !matches(target, contents(game.gameIdString))) {
+            child(context, folder, filename(game, disambiguate = true))
+        } else target
+    }
+
    /** Cocoon matches icons in its data folder's images directory. Never replace custom art. */
-    private fun exportArt(folder: File, game: Library.SteamGame) {
+    private fun exportArt(context: Context, folder: File, game: Library.SteamGame) {
        val art = listOfNotNull(game.icon, game.art).firstOrNull {
            it.isFile && it.extension.lowercase() in listOf("jpg", "jpeg", "png", "webp")
        } ?: return
-        val title = filename(game).substringBeforeLast(" (${game.gameIdString})")
+        val title = filename(game).substringBeforeLast(".")
            .replace(Regex("\\[[^]]*]|\\([^)]*\\)"), "")
            .replace(Regex("[^a-zA-Z0-9\\s]"), "").trim()
            .replace(Regex("\\s+"), "-").lowercase(java.util.Locale.ROOT).take(50).trimEnd('-')
        if (title.isEmpty()) return
-        val images = child(folder, "images")
-        check(images.isDirectory || images.mkdir()) { "Artwork folder is unavailable" }
-        val target = child(images, "$title-icon.${art.extension.lowercase()}")
+        val images = child(context, folder, "images")
+        check(images.isDirectory || images.mkdir()) { context.getString(R.string.gfiles_art_unavailable) }
+        val target = child(context, images, "$title-icon.${art.extension.lowercase()}")
        if (!target.exists()) AtomicFile(target).writeBytes(art.readBytes())
    }

    /** Only remove files in our inventory whose content is still exactly what we wrote. */
-    @Synchronized fun sync(folder: File, games: List<Library.SteamGame>) {
-        require(folder.isDirectory) { "Folder is unavailable" }
-        val inventory = child(folder, INVENTORY)
+    @Synchronized fun sync(context: Context, folder: File, games: List<Library.SteamGame>) {
+        require(folder.isDirectory) { context.getString(R.string.gfiles_folder_unavailable) }
+        val inventory = child(context, folder, INVENTORY)
        val previous = if (inventory.exists()) {
            val record = JSONObject(AtomicFile(inventory).readText())
-            require(record.optString("format") == FORMAT) { "Folder has an unrelated sync inventory" }
+            require(record.optString("format") == FORMAT) { context.getString(R.string.gfiles_unrelated_inventory) }
            record.getJSONObject("games")
        } else JSONObject()
        val next = JSONObject()
-        val exports = games.distinctBy { it.gameId }.map { game ->
-            val target = child(folder, filename(game))
+        val unique = games.distinctBy { it.gameId }
+        val names = unique.groupingBy { filename(it).lowercase(java.util.Locale.ROOT) }.eachCount()
+        val exports = unique.map { game ->
+            val name = filename(game, disambiguate = names.getValue(filename(game).lowercase(java.util.Locale.ROOT)) > 1)
+            val preferred = child(context, folder, name)
+            val target = if (inventoryOwns(context, folder, previous, preferred, game.gameIdString)) preferred
+                else exportTarget(context, folder, game, name)
+            val text = contents(game.gameIdString)
+            val existed = target.exists()
            // Keep an edited export without letting it block the rest of the library sync.
-            val file = if (previous.optString(target.name) == game.gameIdString && target.exists() &&
-                !matches(target, contents(game.gameIdString))) target else export(folder, game)
-            next.put(file.name, game.gameIdString)
+            val owned = inventoryOwns(context, folder, previous, target, game.gameIdString)
+            val file = if (owned && target.exists() &&
+                !matches(target, text)) target else exportNamed(context, folder, game, target.name)
+            if (!existed || owned) next.put(file.name, game.gameIdString)
            file
        }
        // Write new exports before pruning; a failed write must not remove old launch files.
        for (name in previous.keys()) {
            val id = previous.getString(name)
            if (!next.has(name) && name.endsWith(".$EXTENSION") && GameLaunchLink.validId(id)) {
-                val file = child(folder, name)
+                val file = child(context, folder, name)
                if (matches(file, contents(id))) {
                    // Android shared storage is often case insensitive. A case-only rename may
                    // still resolve to the live export, which must not be pruned as an old file.
                    val retained = exports.any { java.nio.file.Files.isSameFile(it.toPath(), file.toPath()) }
-                    if (!retained) check(file.delete()) { "Could not remove $name" }
+                    if (!retained) check(file.delete()) { context.getString(R.string.gfiles_remove_failed, name) }
                }
            }
        }
        if (previous.toString() != next.toString()) write(inventory, JSONObject().put("format", FORMAT).put("games", next).toString())
    }

-    private fun child(folder: File, name: String): File {
+    private fun inventoryOwns(context: Context, folder: File, record: JSONObject, file: File, id: String): Boolean {
+        if (record.optString(file.name) == id) return true
+        if (!file.exists()) return false
+        return record.keys().asSequence().any { name ->
+            record.optString(name) == id && child(context, folder, name).let { old ->
+                old.exists() && java.nio.file.Files.isSameFile(old.toPath(), file.toPath())
+            }
+        }
+    }
+
+    private fun child(context: Context, folder: File, name: String): File {
        require(name.isNotEmpty() && '/' !in name && '\\' !in name && name != "." && name != "..")
        val file = File(folder, name)
-        require(file.canonicalFile.parentFile == folder.canonicalFile) { "File leaves the export folder" }
+        require(file.canonicalFile.parentFile == folder.canonicalFile) { context.getString(R.string.gfiles_outside_folder) }
        return file
    }

@@ -0,0 +1,328 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+
+/**
+ * Best-effort identification of a game from its on-disk footprint, given its .exe: a Steam appId
+ * and/or a display name, so an added game is not just named after its folder or exe. Pure
+ * filesystem and PE parsing, no network, never throws; it reports only what the disk tells.
+ *
+ * Signal chain (appId preferred; best name chosen across all hits):
+ *  1. steam_appid.txt            → appId            (Goldberg-style installs)
+ *  2. ColdClientLoader / emu ini → appId            (AppId= key)
+ *  3. appmanifest_<id>.acf       → appId + name     (real Steam install under steamapps/)
+ *  4. goggame-<id>.info          → name (+ gogId)   (GOG installs)
+ *  5. PE VS_VERSIONINFO          → name             (ProductName / FileDescription)
+ *  6. cleaned folder / exe name  → name             (weak fallback)
+ */
+object GameIdentifier {
+
+    /** How far up the directory tree to look for marker files (games nest deep, e.g. Game/Binaries/Win64/x.exe). */
+    private const val MAX_PARENT_DEPTH = 6
+
+    enum class Source { STEAM_APPID_TXT, STEAM_MANIFEST_ACF, STEAM_EMU_INI, GOG_INFO, PE_VERSION, FILENAME, NONE }
+    enum class Confidence { HIGH, MEDIUM, LOW }
+
+    /**
+     * @param appId  Steam appId if one was found on disk, else null.
+     * @param gogId  GOG product id if a goggame info file was found, else null.
+     * @param name   Best display name found locally; may be null when only an appId was
+     *               found (caller resolves the name from the appId over the network).
+     * @param source Which signal produced the primary identity.
+     */
+    data class GameIdentity(
+        val appId: Int? = null,
+        val gogId: String? = null,
+        val name: String? = null,
+        val source: Source = Source.NONE,
+        val confidence: Confidence = Confidence.LOW,
+        /** Which signal gave [name]: [Source.FILENAME] means only a cleaned folder or exe name. */
+        val nameSource: Source = Source.NONE,
+    ) {
+        val hasStrongId: Boolean get() = appId != null
+    }
+
+    /** Identify the game owning [exeFile]. Never throws; returns an empty identity if nothing matched. */
+    fun identify(exeFile: File): GameIdentity {
+        val dirs = ancestorDirs(exeFile)
+
+        // Steam appId from a bare steam_appid.txt (in the exe dir, a steam_settings/ subdir, or an ancestor).
+        val steamAppId = dirs.firstNotNullOfOrNull { readSteamAppIdTxt(it) }
+        // AppId= out of a ColdClientLoader.ini / steam_emu.ini next to the game.
+        val emuAppId = dirs.firstNotNullOfOrNull { readEmuIniAppId(it) }
+        // Real Steam install: appmanifest_<id>.acf up under steamapps/ — carries both appId and name.
+        val acf = resolveSteamManifest(exeFile, dirs)
+        // GOG: goggame-<id>.info JSON with the real title.
+        val gog = dirs.firstNotNullOfOrNull { readGogInfo(it) }
+        // PE ProductName / FileDescription — but not when it merely names a launcher/loader
+        // ("Rockstar Games Launcher Redirector", "GSE", …), which must not become the game name.
+        val peName = PeVersionInfo.bestName(PeVersionInfo.read(exeFile))?.takeUnless { isJunkPeName(it) }
+
+        val appId = acf?.appId ?: steamAppId ?: emuAppId
+
+        // Best name, most-trustworthy first.
+        val nameHit: Pair<String, Source>? = when {
+            acf?.name != null -> acf.name to Source.STEAM_MANIFEST_ACF
+            gog?.name != null -> gog.name to Source.GOG_INFO
+            peName != null -> peName to Source.PE_VERSION
+            else -> cleanedFallbackName(exeFile)?.let { it to Source.FILENAME }
+        }
+
+        // Primary source = whatever gave us the appId (strongest), else the name source.
+        val primary: Source = when {
+            acf?.appId != null -> Source.STEAM_MANIFEST_ACF
+            steamAppId != null -> Source.STEAM_APPID_TXT
+            emuAppId != null -> Source.STEAM_EMU_INI
+            else -> nameHit?.second ?: Source.NONE
+        }
+
+        val confidence = when {
+            appId != null -> Confidence.HIGH
+            nameHit?.second == Source.GOG_INFO -> Confidence.HIGH
+            nameHit?.second == Source.PE_VERSION -> Confidence.MEDIUM
+            else -> Confidence.LOW
+        }
+
+        return GameIdentity(
+            appId = appId,
+            gogId = gog?.id,
+            name = nameHit?.first?.let(::normalizeName)?.takeIf { it.isNotBlank() },
+            source = primary,
+            confidence = confidence,
+            nameSource = nameHit?.second ?: Source.NONE,
+        )
+    }
+
+    /**
+     * Make an identified title readable and filesystem-safe (a Steam shortcut's name also names
+     * files): "DARK SOULS: REMASTERED" becomes "DARK SOULS - REMASTERED". Strips trademark marks,
+     * turns title punctuation into safe equivalents, and collapses whitespace.
+     */
+    fun normalizeName(raw: String): String {
+        var s = raw
+        s = s.replace("™", "").replace("®", "").replace("©", "")
+        s = s.replace(Regex("""(?i)\(\s*(tm|r|c)\s*\)"""), "") // "(TM)" / "(R)" / "(C)"
+        s = s.replace(":", " - ")                              // colon → dash separator (safe + readable)
+        s = s.replace(Regex("""[\\/]"""), " ")                 // path separators → space
+        s = s.replace(Regex("""["*?<>|]"""), "")               // other illegal chars → drop
+        // Drop trailing generic descriptors a PE FileDescription tacks on ("DiRT 3 Executable" → "DiRT 3").
+        s = s.replace(Regex("""(?i)[ \-]+(executable|application|launcher|redistributable|installer|setup)$"""), "")
+        s = s.replace(Regex("""\s+"""), " ").trim()            // collapse whitespace
+        return s.trim(' ', '-').trim()                          // tidy stray leading/trailing dashes
+    }
+
+    // ── directory walk ──
+
+    /** The exe's directory plus its ancestors, nearest-first, bounded by [MAX_PARENT_DEPTH]. */
+    private fun ancestorDirs(exeFile: File): List<File> {
+        val out = ArrayList<File>(MAX_PARENT_DEPTH + 1)
+        var d: File? = exeFile.absoluteFile.parentFile
+        var depth = 0
+        while (d != null && depth <= MAX_PARENT_DEPTH) {
+            out.add(d)
+            d = d.parentFile
+            depth++
+        }
+        return out
+    }
+
+    // ── signal readers (all best-effort; return null on anything unexpected) ──
+
+    /** steam_appid.txt directly in [dir] or in a steam_settings/ subdir. */
+    private fun readSteamAppIdTxt(dir: File): Int? {
+        for (candidate in arrayOf(File(dir, "steam_appid.txt"), File(dir, "steam_settings/steam_appid.txt"))) {
+            // Strip a leading UTF-8 BOM (trim() doesn't) before reading the digits.
+            val id = readSmallTextFile(candidate)?.removePrefix("\uFEFF")?.trim()
+                ?.takeWhile { it.isDigit() }?.toIntOrNull()
+            if (id != null && id > 0) return id
+        }
+        return null
+    }
+
+    /**
+     * First `AppId=<n>` in a crack/emu config .ini next to the game (ColdClientLoader, steam_emu,
+     * flt, hlm, …). Known names are tried first, then any other `.ini` in the dir — only crack
+     * configs carry an `AppId=` key, game settings .ini files (settings.ini, graphics.ini) don't,
+     * so the broad scan is safe.
+     */
+    private fun readEmuIniAppId(dir: File): Int? {
+        val re = Regex("""(?im)^\s*appid\s*=\s*(\d+)""")
+        val named = arrayOf(
+            "ColdClientLoader.ini", "steam_emu.ini", "flt.ini", "hlm.ini",
+            "valve.ini", "cream_api.ini", "SmartSteamEmu.ini", "GreenLuma.ini",
+        )
+        val seen = HashSet<String>()
+        val candidates = ArrayList<File>()
+        for (n in named) File(dir, n).let { if (it.isFile) { candidates.add(it); seen.add(n.lowercase()) } }
+        (dir.listFiles { f -> f.isFile && f.name.endsWith(".ini", ignoreCase = true) && f.name.lowercase() !in seen }
+            ?: emptyArray()).sortedBy { it.name }.forEach { candidates.add(it) }
+        for (f in candidates) {
+            val text = readSmallTextFile(f) ?: continue
+            val id = re.find(text)?.groupValues?.getOrNull(1)?.toIntOrNull()
+            if (id != null && id > 0) return id
+        }
+        return null
+    }
+
+    private data class Acf(val appId: Int?, val name: String?)
+
+    /**
+     * Resolve the Steam appmanifest for this game: find the `common` ancestor on the exe's
+     * path, read the sibling `steamapps/appmanifest_*.acf`, and match by installdir == the
+     * game folder under common. No match, no manifest: a folder in steamapps/common that no
+     * manifest claims is exactly the kind added games list, and the library's one other game is
+     * not its name.
+     */
+    private fun resolveSteamManifest(exeFile: File, dirs: List<File>): Acf? {
+        val commonIdx = dirs.indexOfFirst { it.name.equals("common", ignoreCase = true) }
+        if (commonIdx < 0) return null
+        val commonDir = dirs[commonIdx]
+        val steamapps = commonDir.parentFile ?: return null
+        val manifests = steamapps.listFiles { f ->
+            f.isFile && f.name.startsWith("appmanifest_") && f.name.endsWith(".acf")
+        } ?: return null
+        if (manifests.isEmpty()) return null
+
+        // The game's install folder is the child of `common` on our descent path.
+        val gameFolder = if (commonIdx > 0) dirs[commonIdx - 1].name else null
+
+        val match = manifests.firstOrNull { m ->
+            val text = readSmallTextFile(m) ?: return@firstOrNull false
+            val installdir = vdfValue(text, "installdir")
+            gameFolder != null && installdir != null && installdir.equals(gameFolder, ignoreCase = true)
+        } ?: return null
+
+        val text = readSmallTextFile(match) ?: return null
+        val appId = vdfValue(text, "appid")?.toIntOrNull()?.takeIf { it > 0 }
+        val name = vdfValue(text, "name")?.takeIf { it.isNotBlank() }
+        return if (appId == null && name == null) null else Acf(appId, name)
+    }
+
+    private data class Gog(val id: String?, val name: String?)
+
+    /** goggame-<id>.info JSON: pull `name` (and the id from the filename). */
+    private fun readGogInfo(dir: File): Gog? {
+        val files = dir.listFiles { f ->
+            f.isFile && f.name.startsWith("goggame-") && f.name.endsWith(".info")
+        } ?: return null
+        for (f in files) {
+            val text = readSmallTextFile(f) ?: continue
+            val name = jsonStringValue(text, "name")?.takeIf { it.isNotBlank() } ?: continue
+            val id = f.name.removePrefix("goggame-").removeSuffix(".info").takeIf { it.isNotBlank() }
+            return Gog(id, name)
+        }
+        return null
+    }
+
+    // ── filename fallback ──
+
+    private val REPACK_TOKENS = setOf(
+        "fitgirl", "dodi", "codex", "plaza", "skidrow", "rune", "empress", "flt", "tenoke",
+        "reloaded", "elamigos", "razor1911", "hoodlum", "gog", "repack", "multi", "goldberg",
+        // repack/site tags that show up in folder names
+        "ankergames", "steamrip", "onlinefix", "online-fix", "gload", "fitgirlrepacks",
+    )
+    private const val EXE_NOISE_WORDS =
+        """win64|win32|shipping|wingdk|client|launcher|game|x64|x86|64bit|32bit"""
+
+    /**
+     * Does this exe basename look like engine/arch boilerplate rather than a title? Deliberately
+     * UNANCHORED — "GameConTest" is boilerplate-ish wherever the giveaway sits, and the answer
+     * decides whether we trust the folder name instead of the exe name.
+     */
+    private val EXE_NOISE_RE = Regex("""(?i)[-_. ]*(?:$EXE_NOISE_WORDS)""")
+
+    /**
+     * Trailing noise to strip off a title. ANCHORED to the end and allowed to repeat, because these
+     * words are only junk as a suffix: "Witcher3-Win64-Shipping" -> "Witcher3", while
+     * "Game of Thrones" and "Client Simulator" must survive intact.
+     *
+     * Kept separate from [EXE_NOISE_RE] on purpose. One regex used to serve both jobs, so
+     * anchoring it to fix stripping ALSO narrowed the boilerplate test — and a game in
+     * "Game Controller Test/GameConTest.exe" stopped preferring its folder and became "GameConTest".
+     */
+    private val EXE_SUFFIX_RE = Regex("""(?i)(?:[-_. ]*(?:$EXE_NOISE_WORDS))+$""")
+    private val VERSION_TOKEN_RE = Regex("""(?i)\b(v?\d+([._]\d+)+|build[-_ ]?\d+|update[-_ ]?\d+)\b""")
+
+    /**
+     * True when an exe basename is a launcher/loader rather than the game — its parent folder is the
+     * better title. Catches "PlayGTAV"/"Play - GTA IV"/"LaunchGame"/"MyLauncher"/"GSE" but NOT a real
+     * title that merely starts with those letters ("PlayerUnknown"). A "play|launch|start|run" prefix
+     * counts only when it's a whole token — followed by a separator or a camelCase uppercase boundary,
+     * not another lowercase letter (checked case-sensitively, so it survives the case-insensitive JUNK
+     * matching used elsewhere).
+     */
+    /** True when an exe basename looks like a launcher/loader rather than the game itself. */
+    fun isLauncherExeName(base: String): Boolean {
+        val lower = base.lowercase()
+        if (lower == "gse" || lower.endsWith("launcher") || lower.endsWith("redirector")) return true
+        for (p in arrayOf("play", "launch", "start", "run")) {
+            if (!lower.startsWith(p)) continue
+            val rest = base.substring(p.length)
+            if (rest.isEmpty()) return true                         // exactly "Play"
+            val c = rest[0]
+            if (!c.isLetterOrDigit() || c.isUpperCase()) return true // "Play - GTA IV" / camelCase "PlayGTAV"
+            // lowercase continuation ("Player…") → part of a longer word, not a launcher
+        }
+        return false
+    }
+
+    /** A PE ProductName/FileDescription that describes a launcher/loader, not the game — reject it so it
+     *  doesn't become the shortcut name (e.g. "Rockstar Games Launcher Redirector", "GSE", "Steam"). */
+    private val JUNK_NAME_RE = Regex(
+        """(?i)^(gse|steam|steam client|goldberg.*|launcher|game|play|start|setup|.* launcher.*|.*launcher redirector|.* redirector|rockstar games launcher.*|epic games launcher|smartsteamemu|coldclient.*|steamemu.*)$"""
+    )
+
+    /** True when a PE name is a launcher/loader label rather than a real game title. */
+    fun isJunkPeName(name: String): Boolean {
+        val n = name.trim()
+        return n.isEmpty() || JUNK_NAME_RE.matches(n)
+    }
+
+    /**
+     * Prefer the game's install-folder name (usually the real title) over the exe basename when the
+     * exe is a UE-style shipping binary OR a launcher/loader; then strip repack/suffix noise.
+     */
+    private fun cleanedFallbackName(exeFile: File): String? {
+        val exeBase = exeFile.nameWithoutExtension
+        val preferFolder = EXE_NOISE_RE.containsMatchIn(exeBase) ||
+            isLauncherExeName(exeBase) ||
+            exeBase.equals("game", true) || exeBase.equals("start", true)
+        val folder = exeFile.absoluteFile.parentFile?.name
+        val raw = if (preferFolder && !folder.isNullOrBlank()) folder else exeBase
+        return cleanName(raw)
+    }
+
+    /** Strip bracketed tags, repack-group names, engine/arch suffixes and version tokens; tidy separators. */
+    private fun cleanName(raw: String): String? {
+        var s = raw
+        s = s.replace(Regex("""[\[(][^\])]*[\])]"""), " ") // (…) […]
+        s = VERSION_TOKEN_RE.replace(s, " ")
+        s = EXE_SUFFIX_RE.replace(s, " ")
+        s = s.replace(Regex("""[._]+"""), " ")
+        // Drop standalone repack-group words.
+        s = s.split(Regex("""[\s-]+"""))
+            .filter { it.isNotBlank() && it.lowercase() !in REPACK_TOKENS }
+            .joinToString(" ")
+        s = s.trim()
+        return s.ifBlank { null }
+    }
+
+    // ── tiny text/format helpers (regex-based → no Android/org.json dependency, unit-testable) ──
+
+    /** Read a small text file (guards against accidentally slurping a huge file). */
+    private fun readSmallTextFile(f: File, maxBytes: Long = 1L * 1024 * 1024): String? = try {
+        if (f.isFile && f.length() in 1..maxBytes) f.readText(Charsets.UTF_8) else null
+    } catch (_: Throwable) {
+        null
+    }
+
+    /** Value of a Valve KeyValues (.acf/.vdf) `"key"  "value"` pair, first match, case-insensitive key. */
+    private fun vdfValue(text: String, key: String): String? =
+        Regex(""""${Regex.escape(key)}"\s*"([^"]*)"""", RegexOption.IGNORE_CASE).find(text)?.groupValues?.getOrNull(1)?.trim()
+
+    /** Value of a JSON `"key": "value"` pair, first match. Sufficient for the flat goggame .info files. */
+    private fun jsonStringValue(text: String, key: String): String? =
+        Regex(""""${Regex.escape(key)}"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"""").find(text)
+            ?.groupValues?.getOrNull(1)?.replace("\\\"", "\"")?.replace("\\\\", "\\")?.trim()
+}
@@ -0,0 +1,32 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.content.Intent
+
+object GameLaunchIntent {
+    const val ACTION = "com.droiddeck.launcher.LAUNCH_GAME"
+    const val EXTRA_APP_ID = "app_id"
+    const val EXTRA_GAME_SOURCE = "game_source"
+    private const val GAMENATIVE_ACTION = "app.gamenative.LAUNCH_GAME"
+
+    fun accepts(action: String?): Boolean = action == Intent.ACTION_VIEW || action == ACTION || action == GAMENATIVE_ACTION
+
+    fun read(context: Context, intent: Intent): String? = when (intent.action) {
+        Intent.ACTION_VIEW -> GameFiles.readIntent(context, intent)
+        ACTION, GAMENATIVE_ACTION -> readId(intent)
+        else -> null
+    }
+
+    @Suppress("DEPRECATION")
+    internal fun readId(intent: Intent): String? = runCatching {
+        if (intent.action != ACTION && intent.action != GAMENATIVE_ACTION) return null
+        val source = intent.extras?.get(EXTRA_GAME_SOURCE)
+        if (source != null && (source !is String || !source.equals("STEAM", ignoreCase = true))) return null
+        val id = when (val value = intent.extras?.get(EXTRA_APP_ID)) {
+            is Int -> value.takeIf { it > 0 }?.toString()
+            is String -> value.takeIf(GameLaunchLink::validId)
+            else -> null
+        }
+        id
+    }.getOrNull()
+}
@@ -0,0 +1,66 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import com.droiddeck.launcher.session.SessionPrefs
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import com.droiddeck.launcher.stores.StoreInstallRoot
+import java.io.File
+import java.util.zip.CRC32
+
+/**
+ * Games folders (the roots earlier builds let the user add in Steam settings) become what the
+ * Games tab's "Add all games in this folder" makes: one entry per game ([AddedExes]). Everything
+ * a game had is keyed by its own folder and stays as it was - the chosen exe, the shortcut appid,
+ * the name, Start in, launch options, art choices, a removal. The roots stay bound into the
+ * session at the same guest paths ([SessionPrefs.gameFolderBinds]), so every exe keeps its path
+ * inside the session and every Steam shortcut its target; they are no longer Steam libraries.
+ * Runs whenever saved roots remain (so twice is the same as once) and clears them after.
+ */
+object GamesFolderMigration {
+    private const val TAG = "GamesFolderMigration"
+
+    @Synchronized
+    fun run(context: Context) {
+        val dirs = SessionPrefs.addedGamesDirs(context)
+        if (dirs.isEmpty()) return
+        val roots = legacyRoots(SessionPrefs.gameFolderBinds(context).map { it.first } + dirs)
+            .filter { root -> root.host.path in dirs }
+        // The binds first: a game's guest path (and with it the shortcut's appid) depends on them.
+        SessionPrefs.setGameFolderBinds(context, SessionPrefs.gameFolderBinds(context) + roots.map { it.host.path to it.guest })
+        val removed = SessionPrefs.removedAddedGames(context).toSet()
+        val entries = AddedExes.list(context).map { it.folder }.toMutableSet()
+        val storeRoots = StoreInstallRoot.roots(context).map { it.absolutePath }
+        for (root in roots) {
+            var n = 0
+            val steamInstalls = AddedGames.steamInstallDirs(root.host)
+            for (folder in root.host.listFiles { f -> f.isDirectory }?.sortedBy { it.name.lowercase() }.orEmpty()) {
+                if (folder.name.equals("steamapps", ignoreCase = true) || folder.name.lowercase() in steamInstalls) continue
+                if (folder.absolutePath in storeRoots || StoreGameSidecar.read(folder) != null) continue
+                if (folder.path in entries) continue
+                val picked = SessionPrefs.addedGameExe(context, folder.path).takeIf { it.isNotEmpty() }?.let { File(it) }?.takeIf { it.isFile }
+                val exe = picked ?: AddedGames.rank(folder).exes.firstOrNull() ?: continue
+                AddedExes.put(context, AddedExes.Entry(folder.path, exe.path, picked = picked != null))
+                entries.add(folder.path)
+                if (folder.path !in removed) n++
+            }
+            Log.i(TAG, "games: migrated ${root.host} → $n games")
+        }
+        SessionPrefs.setAddedGamesDirs(context, emptyList())
+        SessionPrefs.setGamesFoldersMigrated(context)
+    }
+
+    /**
+     * The guest paths earlier builds gave Games folders: /root/Games/<folder name>, with a short
+     * hash of the host path when two share a name. Kept exactly, so nothing moves in the session.
+     */
+    internal fun legacyRoots(paths: List<String>): List<AddedGames.Root> {
+        val hosts = paths.distinct().map { File(it) }
+        val names = hosts.groupingBy { it.name.lowercase() }.eachCount()
+        return hosts.map { host ->
+            val name = host.name.ifEmpty { "games" }
+            val guestName = if ((names[name.lowercase()] ?: 0) > 1) name + "-" + "%08x".format(CRC32().apply { update(host.path.toByteArray()) }.value).take(4) else name
+            AddedGames.Root(host, "${AddedGames.GUEST_DIR}/$guestName")
+        }
+    }
+}
@@ -24,15 +24,23 @@ object Library {
        val hero: File? = null, val lastPlayed: Long = 0L,
        val gameFiles: File? = null, val protonPrefix: File? = null,
        val icon: File? = null,
+        /** Where the game came from: [SOURCE_STEAM], a store's id (gog, epic, amazon) or [ADDED] for a folder the user added. */
+        val source: String = SOURCE_STEAM,
+        /** The store's own id for a store install; null otherwise. */
+        val storeId: String? = null,
    ) {
        /** Decimal form used by Steam links and Android shortcuts, including unsigned shortcut ids. */
        val gameIdString: String get() = java.lang.Long.toUnsignedString(gameId)
    }
-    /** The [SteamGame.library] of a game added to the library rather than installed by Steam. */
+    /** 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"
+    /** The [SteamGame.source] of a title Steam itself installed. */
+    const val SOURCE_STEAM = "steam"

    class Rom(val name: String, val hostPath: File, val guestPath: String, val emulatorId: String, val art: File? = null)
    class Emulator(val id: String, val name: String, val system: String, val program: String, val installed: Boolean, val games: List<Rom>) {
+        /** The shown name of [system] when it is words rather than a platform name, else 0. */
+        val systemRes: Int get() = if (id == "retroarch") R.string.content_system_many else 0
        /** The emulator's own icon, bundled (the runtime keeps them as theme SVGs the app cannot draw). */
        val iconRes: Int get() = when (id) {
            "rpcs3" -> R.drawable.emu_rpcs3; "armsx2" -> R.drawable.emu_pcsx2; "dolphin" -> R.drawable.emu_dolphin
@@ -84,17 +92,20 @@ object Library {
        return listOfNotNull(
            root to "internal",
            GameStorage.effective(context)?.let { File(it.path) to it.label },
-        )
+        ) + GameStorage.gamesFolderLibraries(context).map { it.host to it.label }
    }

    /** Proton keeps each game's prefix below compatdata/<appid>/pfx in a Steam library. */
-    fun protonPrefix(context: Context, appId: Long, preferredLibrary: File? = null): File? {
+    fun protonPrefix(
+        context: Context, appId: Long, preferredLibrary: File? = null,
+        libraries: List<File> = steamLibraries(context).map { it.first },
+    ): File? {
        val ids = listOf(appId.toString(), java.lang.Integer.toString(appId.toInt())).distinct()
-        val secondary = GameStorage.effective(context)?.let { File(it.path) }
-        fun prefixRoot(root: File): File = if (secondary != null && root.canonicalPath == secondary.canonicalPath)
+        val secondary = libraries.drop(1).mapNotNull { runCatching { it.canonicalPath }.getOrNull() }.toSet()
+        fun prefixRoot(root: File): File = if (runCatching { root.canonicalPath }.getOrNull() in secondary)
            SecondaryLibrary.privateRoot(context.filesDir, root).takeIf { File(it, "steamapps/compatdata").isDirectory } ?: root
            else root
-        val roots = (listOfNotNull(preferredLibrary) + steamLibraries(context).map { it.first }).map(::prefixRoot)
+        val roots = (listOfNotNull(preferredLibrary) + libraries).map(::prefixRoot)
            .distinctBy { runCatching { it.canonicalPath }.getOrDefault(it.absolutePath) }
        return roots.asSequence()
            .flatMap { root -> ids.asSequence().map { id -> File(root, "steamapps/compatdata/$id/pfx") } }
@@ -105,11 +116,12 @@ object Library {
        val root = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam")
        val cache = File(root, "appcache/librarycache")
        val libraries = steamLibraries(context)
+        val roots = libraries.map { it.first }
        val out = LinkedHashMap<Int, SteamGame>()
        for ((library, label) in libraries) {
            val steamapps = File(library, "steamapps")
            val manifests = steamapps.listFiles { f -> f.isFile && f.name.startsWith("appmanifest_") && f.name.endsWith(".acf") }
-            if (strictRead && steamapps.isDirectory) check(manifests != null) { "Steam manifests are unavailable" }
+            if (strictRead && steamapps.isDirectory) check(manifests != null) { context.getString(R.string.game_sync_err_manifests) }
            manifests?.sortedBy { it.name }?.forEach { manifest ->
                    val appId = manifest.name.removePrefix("appmanifest_").removeSuffix(".acf").toIntOrNull() ?: return@forEach
                    if (appId in NOT_GAMES || out.containsKey(appId)) return@forEach
@@ -130,7 +142,7 @@ object Library {
                    out[appId] = SteamGame(
                        appId, name, art, label, hero = hero, lastPlayed = lastPlayed,
                        gameFiles = gameFiles,
-                        protonPrefix = protonPrefix(context, appId.toLong(), library),
+                        protonPrefix = protonPrefix(context, appId.toLong(), library, roots),
                        icon = steamCacheImage(cache, appId, listOf("icon.jpg", "icon.png"))
                            ?: File(cache, appId.toString()).listFiles()?.firstOrNull { it.isFile && STEAM_ICON.matches(it.name) },
                    )
@@ -140,16 +152,23 @@ object Library {
    }

    /** The same installed-game inventory used for links, shortcuts and file exports. */
-    fun launchableGames(context: Context, strictRead: Boolean = false): List<SteamGame> = (steamGames(context, strictRead) + AddedGames.scan(context).map { g ->
+    /** [added]: the added games when the caller has just scanned them, so they are not scanned again. */
+    fun launchableGames(context: Context, strictRead: Boolean = false, added: List<AddedGames.Game>? = null): List<SteamGame> {
+        val roots = steamLibraries(context).map { it.first }
+        return (steamGames(context, strictRead) + (added ?: AddedGames.scan(context)).map { g -> addedGame(context, g, roots) }).distinctBy { it.gameId }
+    }
+
+    /** One added game as the Games tab lists it; [roots] the Steam libraries, for its Proton prefix. */
+    fun addedGame(context: Context, g: AddedGames.Game, roots: List<File> = steamLibraries(context).map { it.first }): SteamGame =
        AddedGameArt.resolve(context, g).let { art ->
            SteamGame(
                g.steamAppId ?: g.appId.toInt(), g.name, art.portrait ?: art.header, ADDED, g.gameId,
                hero = art.hero ?: art.header, gameFiles = g.folder,
-                protonPrefix = protonPrefix(context, g.steamAppId?.toLong() ?: g.appId),
+                protonPrefix = protonPrefix(context, g.steamAppId?.toLong() ?: g.appId, libraries = roots),
                icon = art.icon?.takeIf { it.extension.lowercase() != "ico" },
+                source = g.source, storeId = g.storeId,
            )
        }
-    }).distinctBy { it.gameId }

    /** Steam stores current library art inside hash-named folders under the app's cache dir. */
    private fun steamCacheImage(cache: File, appId: Int, names: List<String>): File? {
@@ -26,6 +26,8 @@ object LibraryCache {
                library = o.getString("library"), gameId = o.getLong("gameId"), hero = o.file("hero"),
                lastPlayed = o.optLong("lastPlayed"), gameFiles = o.file("gameFiles"), protonPrefix = o.file("protonPrefix"),
                icon = o.file("icon"),
+                source = o.optString("source").ifEmpty { if (o.getString("library") == Library.ADDED) Library.ADDED else Library.SOURCE_STEAM },
+                storeId = o.optString("storeId").ifEmpty { null },
            )
        }
    }.getOrElse { e -> Log.w(TAG, "unreadable, ignored: ${e.message}"); emptyList() }
@@ -36,7 +38,8 @@ object LibraryCache {
            for (g in games) array.put(
                JSONObject().put("appId", g.appId).put("name", g.name).put("library", g.library).put("gameId", g.gameId)
                    .put("lastPlayed", g.lastPlayed).putFile("art", g.art).putFile("hero", g.hero)
-                    .putFile("gameFiles", g.gameFiles).putFile("protonPrefix", g.protonPrefix).putFile("icon", g.icon),
+                    .putFile("gameFiles", g.gameFiles).putFile("protonPrefix", g.protonPrefix).putFile("icon", g.icon)
+                    .put("source", g.source).apply { g.storeId?.let { put("storeId", it) } },
            )
            val f = file(context)
            val tmp = File(f.path + ".tmp")
@@ -0,0 +1,250 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+import java.io.RandomAccessFile
+
+/**
+ * Reads the StringFileInfo strings (ProductName, FileDescription, …) out of the
+ * VS_VERSION_INFO resource embedded in a Windows PE executable (.exe).
+ *
+ * Walks the PE resource directory to the first RT_VERSION resource — the same
+ * navigation [com.droiddeck.launcher.files.PeIconExtractor] uses for icons — then parses the alignment-heavy
+ * VS_VERSIONINFO → StringFileInfo → StringTable → String tree by hand.
+ *
+ * Everything is best-effort: any malformed / oversized / unsupported input returns
+ * null (or an empty map). No allocation beyond the single resource blob.
+ */
+object PeVersionInfo {
+
+    private const val RT_VERSION = 16
+    private const val MAX_RES_SECTION = 64 * 1024 * 1024 // don't slurp absurd resource sections
+
+    /**
+     * Returns the StringFileInfo key→value map (e.g. `"ProductName" -> "Palworld"`),
+     * or null if the file has no readable version resource. Keys are the raw
+     * VS_VERSIONINFO names; look up [productName]/[fileDescription] for the common ones.
+     */
+    fun read(file: File): Map<String, String>? = try {
+        RandomAccessFile(file, "r").use { raf ->
+            val blob = versionResourceBytes(raf) ?: return@use null
+            parseStringFileInfo(blob).takeIf { it.isNotEmpty() }
+        }
+    } catch (_: Throwable) {
+        null
+    }
+
+    /**
+     * Best display name from a version map. ProductName is usually the cleanest title, but is
+     * sometimes an internal abbreviation (e.g. God of War ships ProductName "GoW" while
+     * FileDescription is "God of War"). When ProductName is a single spaceless token and
+     * FileDescription is a normal multi-word title, prefer FileDescription. Trimmed; null if
+     * neither is meaningful.
+     */
+    fun bestName(map: Map<String, String>?): String? {
+        if (map == null) return null
+        val product = map["ProductName"]?.trim()?.takeIf { it.isNotEmpty() }
+        val desc = map["FileDescription"]?.trim()?.takeIf { it.isNotEmpty() }
+        if (product != null && desc != null &&
+            !product.contains(' ') && desc.contains(' ') && desc.length <= 60
+        ) {
+            return desc
+        }
+        return product ?: desc
+    }
+
+    // ── locate the RT_VERSION resource blob (mirrors PeIconExtractor's navigation) ──
+
+    private fun versionResourceBytes(raf: RandomAccessFile): ByteArray? {
+        val dos = read(raf, 0, 0x40) ?: return null
+        if (u8(dos, 0) != 0x4D || u8(dos, 1) != 0x5A) return null // "MZ"
+        val peOff = u32(dos, 0x3C).toInt()
+
+        val coff = read(raf, peOff.toLong(), 24) ?: return null
+        if (u8(coff, 0) != 0x50 || u8(coff, 1) != 0x45 || u8(coff, 2) != 0 || u8(coff, 3) != 0) return null // "PE\0\0"
+        val numSections = u16(coff, 6)
+        val sizeOpt = u16(coff, 20)
+        if (numSections <= 0 || numSections > 96 || sizeOpt <= 0) return null
+
+        val optOff = peOff + 24L
+        val opt = read(raf, optOff, sizeOpt) ?: return null
+        val magic = u16(opt, 0)
+        val ddOff = if (magic == 0x20B) 112 else 96 // PE32+ vs PE32 data-directory offset
+        val resDirEntry = ddOff + 2 * 8 // data directory index 2 = resource table
+        if (resDirEntry + 8 > opt.size) return null
+        val resRVA = u32(opt, resDirEntry).toInt()
+        val resSize = u32(opt, resDirEntry + 4).toInt()
+        if (resRVA == 0 || resSize == 0) return null
+
+        val secTabOff = optOff + sizeOpt
+        val secTab = read(raf, secTabOff, numSections * 40) ?: return null
+
+        var secVA = 0
+        var secPtr = 0L
+        var secRaw = 0
+        var found = false
+        for (i in 0 until numSections) {
+            val o = i * 40
+            if (o + 40 > secTab.size) break
+            val va = u32(secTab, o + 12).toInt()
+            val vSize = u32(secTab, o + 8).toInt()
+            val raw = u32(secTab, o + 16).toInt()
+            val pRaw = u32(secTab, o + 20)
+            val span = maxOf(vSize, raw)
+            if (resRVA >= va && resRVA < va + span) {
+                secVA = va; secPtr = pRaw; secRaw = raw; found = true; break
+            }
+        }
+        if (!found || secRaw <= 0 || secRaw > MAX_RES_SECTION) return null
+
+        val res = read(raf, secPtr, secRaw) ?: return null
+        val resDirStart = resRVA - secVA
+        if (resDirStart < 0 || resDirStart + 16 > res.size) return null
+
+        val verTypeDir = findIdSubdir(res, resDirStart, RT_VERSION, resDirStart) ?: return null
+        val verData = firstDataEntry(res, verTypeDir, resDirStart) ?: return null
+        return dataEntryBytes(res, verData, secVA)
+    }
+
+    /** Resolve the sub-directory under [dirIdx] whose id matches [wantId]; null if absent or not a directory. */
+    private fun findIdSubdir(res: ByteArray, dirIdx: Int, wantId: Int, resDirStart: Int): Int? {
+        if (dirIdx + 16 > res.size) return null
+        val total = u16(res, dirIdx + 12) + u16(res, dirIdx + 14)
+        val start = dirIdx + 16
+        for (i in 0 until total) {
+            val e = start + i * 8
+            if (e + 8 > res.size) break
+            val id = u32(res, e)
+            val off = u32(res, e + 4)
+            if (id and 0x80000000L == 0L && id.toInt() == wantId) {
+                if (off and 0x80000000L != 0L) return resDirStart + (off and 0x7FFFFFFFL).toInt()
+                return null
+            }
+        }
+        return null
+    }
+
+    /** Descend the first entry of each level until an IMAGE_RESOURCE_DATA_ENTRY; returns its index. */
+    private fun firstDataEntry(res: ByteArray, dirIdx: Int, resDirStart: Int): Int? {
+        if (dirIdx + 16 > res.size) return null
+        if (u16(res, dirIdx + 12) + u16(res, dirIdx + 14) == 0) return null
+        val e = dirIdx + 16
+        if (e + 8 > res.size) return null
+        val off = u32(res, e + 4)
+        return if (off and 0x80000000L != 0L) {
+            firstDataEntry(res, resDirStart + (off and 0x7FFFFFFFL).toInt(), resDirStart)
+        } else {
+            resDirStart + off.toInt()
+        }
+    }
+
+    /** Read the bytes an IMAGE_RESOURCE_DATA_ENTRY points at (its OffsetToData is an RVA). */
+    private fun dataEntryBytes(res: ByteArray, entryIdx: Int, secVA: Int): ByteArray? {
+        if (entryIdx < 0 || entryIdx + 8 > res.size) return null
+        val rva = u32(res, entryIdx).toInt()
+        val size = u32(res, entryIdx + 4).toInt()
+        val start = rva - secVA
+        if (size <= 0 || start < 0 || start + size > res.size) return null
+        return res.copyOfRange(start, start + size)
+    }
+
+    // ── VS_VERSIONINFO tree parse ──
+    //
+    // Every node is: WORD wLength, WORD wValueLength, WORD wType, WCHAR szKey[],
+    // then (32-bit aligned) an optional Value, then (32-bit aligned) child nodes.
+    // We only care about: VS_VERSIONINFO → StringFileInfo → StringTable → String.
+
+    private fun parseStringFileInfo(b: ByteArray): Map<String, String> {
+        val out = LinkedHashMap<String, String>()
+        if (b.size < 6) return out
+        val rootLen = minOf(u16(b, 0), b.size)
+        // VS_VERSION_INFO header: skip szKey "VS_VERSION_INFO" then the FIXEDFILEINFO value.
+        val rootValLen = u16(b, 2)
+        var pos = align4(6 + (utf16zLen(b, 6) + 1) * 2)
+        pos = align4(pos + rootValLen)
+
+        while (pos + 6 <= rootLen) {
+            val childLen = u16(b, pos)
+            if (childLen < 6 || pos + childLen > b.size) break
+            val key = utf16z(b, pos + 6)
+            if (key == "StringFileInfo") parseTables(b, pos, pos + childLen, out)
+            pos = align4(pos + childLen)
+            if (childLen == 0) break
+        }
+        return out
+    }
+
+    /** Iterate the StringTable children inside a StringFileInfo block [start, end). */
+    private fun parseTables(b: ByteArray, start: Int, end: Int, out: MutableMap<String, String>) {
+        var p = align4(start + 6 + (utf16zLen(b, start + 6) + 1) * 2)
+        while (p + 6 <= end) {
+            val tableLen = u16(b, p)
+            if (tableLen < 6 || p + tableLen > end) break
+            parseStrings(b, p, minOf(p + tableLen, end), out)
+            p = align4(p + tableLen)
+            if (tableLen == 0) break
+        }
+    }
+
+    /** Iterate the String children inside a StringTable block [start, end). */
+    private fun parseStrings(b: ByteArray, start: Int, end: Int, out: MutableMap<String, String>) {
+        var q = align4(start + 6 + (utf16zLen(b, start + 6) + 1) * 2)
+        while (q + 6 <= end) {
+            val strLen = u16(b, q)
+            if (strLen < 6 || q + strLen > end) break
+            val key = utf16z(b, q + 6)
+            val valOff = align4(q + 6 + (key.length + 1) * 2)
+            if (key.isNotEmpty() && valOff < q + strLen) {
+                val value = utf16z(b, valOff, q + strLen).trim()
+                if (value.isNotEmpty()) out[key] = value
+            }
+            q = align4(q + strLen)
+            if (strLen == 0) break
+        }
+    }
+
+    // ── little-endian / UTF-16 readers ──
+
+    private fun align4(x: Int): Int = (x + 3) and 3.inv()
+
+    /** Number of UTF-16 code units before the null terminator starting at [off]. */
+    private fun utf16zLen(b: ByteArray, off: Int): Int {
+        var i = off
+        while (i + 1 < b.size) {
+            if (b[i].toInt() == 0 && b[i + 1].toInt() == 0) break
+            i += 2
+        }
+        return (i - off) / 2
+    }
+
+    /** Read a null-terminated UTF-16LE string starting at [off], not reading past [limit]. */
+    private fun utf16z(b: ByteArray, off: Int, limit: Int = b.size): String {
+        val sb = StringBuilder()
+        var i = off
+        val end = minOf(limit, b.size)
+        while (i + 1 < end) {
+            val c = u8(b, i) or (u8(b, i + 1) shl 8)
+            if (c == 0) break
+            sb.append(c.toChar())
+            i += 2
+        }
+        return sb.toString()
+    }
+
+    private fun u8(b: ByteArray, off: Int): Int = if (off < 0 || off >= b.size) 0 else b[off].toInt() and 0xFF
+    private fun u16(b: ByteArray, off: Int): Int = u8(b, off) or (u8(b, off + 1) shl 8)
+    private fun u32(b: ByteArray, off: Int): Long =
+        u8(b, off).toLong() or (u8(b, off + 1).toLong() shl 8) or
+            (u8(b, off + 2).toLong() shl 16) or (u8(b, off + 3).toLong() shl 24)
+
+    private fun read(raf: RandomAccessFile, pos: Long, len: Int): ByteArray? {
+        if (len <= 0 || pos < 0) return null
+        val fileLen = raf.length()
+        if (pos >= fileLen) return null
+        val n = minOf(len.toLong(), fileLen - pos).toInt()
+        if (n <= 0) return null
+        val buf = ByteArray(n)
+        raf.seek(pos)
+        raf.readFully(buf)
+        return buf
+    }
+}
@@ -0,0 +1,66 @@
+package com.droiddeck.launcher.frontend
+
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Which catalog components a game's prefix already has from elsewhere - a real installer, the game,
+ * the user - so the list can say so instead of recommending them again. Bannerlator's detector,
+ * on DroidDeck's compatdata/<id>: only markers absent from a fresh Proton prefix count (OpenAL32,
+ * Mono, PhysX, Games for Windows Live); msvcp140, d3dx9 and the like ship with Proton and cannot
+ * tell. Files DroidDeck put there itself (droiddeck-wincomponents' state) are not counted.
+ * Pure filesystem reads; never throws.
+ */
+object PrefixInstalledDetector {
+    private const val STATE = ".droiddeck-wincomponents.json"
+
+    /** Detector names (oalinst, mono, physx, XLiveRedist) present in [compat]/pfx. */
+    fun detect(compat: File?): Set<String> = try {
+        val pfx = compat?.let { File(it, "pfx") }
+        if (pfx == null || !pfx.isDirectory) emptySet() else {
+            val ours = ours(compat)
+            val out = HashSet<String>()
+            val openal = listOf("system32", "syswow64").map { "drive_c/windows/$it/openal32.dll" }
+            if (openal.any { it !in ours && fileIgnoringCase(pfx, it) }) out += "oalinst"
+            if (File(pfx, "drive_c/windows/mono").isDirectory) out += "mono"
+            if (hasPhysX(pfx)) out += "physx"
+            if (registryContains(pfx, "Games for Windows")) out += "XLiveRedist"
+            out
+        }
+    } catch (_: Throwable) {
+        emptySet()
+    }
+
+    private fun ours(compat: File): Set<String> = try {
+        val files = JSONObject(File(compat, STATE).readText()).optJSONObject("files")
+        files?.keys()?.asSequence()?.map { it.lowercase() }?.toSet().orEmpty()
+    } catch (_: Exception) {
+        emptySet()
+    }
+
+    /** Windows names ignore case; the prefix's folder may spell them either way. */
+    private fun fileIgnoringCase(pfx: File, rel: String): Boolean {
+        val target = File(pfx, rel)
+        return target.parentFile?.listFiles()?.any { it.isFile && it.name.equals(target.name, ignoreCase = true) } == true
+    }
+
+    private fun hasPhysX(pfx: File): Boolean {
+        for (pf in arrayOf("drive_c/Program Files", "drive_c/Program Files (x86)")) {
+            val base = File(pfx, pf)
+            if (File(base, "NVIDIA Corporation/PhysX").isDirectory) return true
+            if (base.listFiles()?.any { it.isDirectory && it.name.contains("PhysX", ignoreCase = true) } == true) return true
+        }
+        return false
+    }
+
+    private fun registryContains(pfx: File, needle: String): Boolean =
+        arrayOf("system.reg", "user.reg").any { name ->
+            val f = File(pfx, name)
+            try {
+                f.isFile && f.length() < 32L * 1024 * 1024 &&
+                    f.bufferedReader().use { r -> r.lineSequence().any { it.contains(needle, ignoreCase = true) } }
+            } catch (_: Throwable) {
+                false
+            }
+        }
+}
@@ -0,0 +1,95 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import com.droiddeck.launcher.session.GameStorage
+import com.droiddeck.launcher.session.SessionState
+import java.io.File
+
+/**
+ * A Steam game whose download finishes during a session, noticed by its appmanifest (a new one,
+ * or StateFlags turning to 4, fully installed) with a light look every five seconds while the
+ * session runs, and handed to [AutoComponents] as a single job that may run in the session, so its
+ * Windows components are in place when the user plays it right after the download.
+ */
+object SessionInstalls {
+    private const val TAG = "SessionInstalls"
+    private const val POLL_MS = 5_000L
+
+    /** One appmanifest as read: the app, its name and folder, whether it is fully installed. */
+    class Manifest(val appId: Int, val name: String, val installDir: String, val installed: Boolean, val steamapps: File)
+
+    private val APPID = Regex("\"appid\"\\s*\"(\\d+)\"", RegexOption.IGNORE_CASE)
+    private val NAME = Regex("\"name\"\\s*\"([^\"]*)\"", RegexOption.IGNORE_CASE)
+    private val DIR = Regex("\"installdir\"\\s*\"([^\"]*)\"", RegexOption.IGNORE_CASE)
+    private val STATE = Regex("\"StateFlags\"\\s*\"(\\d+)\"", RegexOption.IGNORE_CASE)
+
+    internal fun parse(file: File): Manifest? = runCatching {
+        val text = file.readText()
+        val id = APPID.find(text)?.groupValues?.get(1)?.toInt() ?: return null
+        Manifest(id, NAME.find(text)?.groupValues?.get(1).orEmpty(), DIR.find(text)?.groupValues?.get(1).orEmpty(),
+            STATE.find(text)?.groupValues?.get(1)?.toIntOrNull() == 4, file.parentFile!!)
+    }.getOrNull()
+
+    /** The libraries the session's client installs to, as host folders. */
+    internal fun steamappsDirs(context: Context): List<File> = listOfNotNull(
+        File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/steamapps"),
+        GameStorage.effective(context)?.let { File(it.path, "steamapps") },
+    ).filter { it.isDirectory }
+
+    /**
+     * Keeps what the libraries hold between looks: a manifest re-read only when its time changed.
+     * [poll] returns the apps that became fully installed since the last look (none on the first).
+     */
+    internal class Watch(private val dirs: () -> List<File>) {
+        private val seen = HashMap<String, Pair<Long, Manifest?>>()
+        private var first = true
+
+        fun poll(): List<Manifest> {
+            val fresh = ArrayList<Manifest>()
+            for (dir in dirs()) for (f in dir.listFiles { x -> x.isFile && x.name.startsWith("appmanifest_") && x.name.endsWith(".acf") }.orEmpty()) {
+                val before = seen[f.path]
+                if (before != null && before.first == f.lastModified()) continue
+                val now = parse(f)
+                seen[f.path] = f.lastModified() to now
+                if (!first && now != null && now.installed && before?.second?.installed != true) fresh.add(now)
+            }
+            first = false
+            return fresh
+        }
+    }
+
+    /** A finished install as the Games tab would list it. */
+    internal fun gameOf(m: Manifest): Library.SteamGame =
+        Library.SteamGame(m.appId, m.name.ifEmpty { m.appId.toString() }, null, m.steamapps.parentFile?.path ?: "steam",
+            gameFiles = File(m.steamapps, "common/${m.installDir}"), source = Library.SOURCE_STEAM)
+
+    /**
+     * Looks every five seconds while the session runs, on a thread of its own at background
+     * priority; each finished install becomes one job for its Windows components.
+     */
+    fun watch(context: Context) {
+        val app = context.applicationContext
+        Thread({
+            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND)
+            val watch = Watch { steamappsDirs(app) }
+            try {
+                // The session is still starting when this is called: up to two minutes for it.
+                var waited = 0L
+                while (!SessionState.running && waited < 120_000L) { Thread.sleep(POLL_MS); waited += POLL_MS }
+                watch.poll()
+                while (SessionState.running) {
+                    for (m in watch.poll()) {
+                        Log.i(TAG, "wincomp: ${m.name} (${m.appId}) finished installing in the session")
+                        AutoComponents.queueInSession(app, gameOf(m))
+                    }
+                    Thread.sleep(POLL_MS)
+                }
+            } catch (e: InterruptedException) {
+            } catch (e: Exception) {
+                Log.w(TAG, "install watch: ${e.message}")
+            }
+        }, "session-installs").apply { isDaemon = true }.start()
+    }
+}
@@ -0,0 +1,202 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.AtomicFile
+import android.util.Log
+import com.droiddeck.launcher.runtime.LinuxRuntime
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.DataInputStream
+import java.io.File
+import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * Steam's own data for an app, from the client in the runtime: its app-info cache
+ * (Steam/appcache/appinfo.vdf, the PICS data the client keeps for every app it has seen). What is
+ * read is which Steamworks Shared depots (the VC++, DirectX... redistributables of app 228980) the
+ * app's depots point at, and its name. Kept per appid in the app's files, so it works offline; an
+ * app the client has not seen is looked for again after a week.
+ */
+object SteamAppInfo {
+    private const val TAG = "SteamAppInfo"
+    private const val CACHE = "steam-appinfo.json"
+    private const val RETRY_AFTER_MS = 7L * 24 * 3600 * 1000
+    /** The Steamworks Shared app the redistributable depots belong to. */
+    const val SHARED_APP = "228980"
+
+    class Info(val name: String, val sharedDepots: List<String>)
+
+    fun appinfoFile(context: Context) = File(LinuxRuntime.rootDir(context), "root/.local/share/Steam/appcache/appinfo.vdf")
+
+    /** The shared depots for [appId]: from the cache, else the client's app-info file; null when unknown. */
+    @Synchronized
+    fun info(context: Context, appId: Int, appinfo: File = appinfoFile(context)): Info? {
+        val cacheFile = AtomicFile(File(context.filesDir, CACHE))
+        val cache = runCatching { JSONObject(cacheFile.readFully().toString(Charsets.UTF_8)) }.getOrDefault(JSONObject())
+        val now = System.currentTimeMillis()
+        val mtime = appinfo.lastModified()
+        val known = cache.optJSONObject(appId.toString())
+        known?.let { o ->
+            if (!o.optBoolean("miss")) return Info(o.optString("name"), o.optJSONArray("depots").strings())
+            // A miss is read again when the client has written its cache since (the user may have
+            // looked at the app in Steam), else a week later.
+            if (now - o.optLong("at") < RETRY_AFTER_MS && o.optLong("mtime") == mtime) return null
+        }
+        val read = runCatching { read(appinfo, appId) }.onFailure { Log.w(TAG, "appinfo: ${it.javaClass.simpleName}") }.getOrNull()
+        val entry = JSONObject().put("at", now).put("mtime", mtime)
+        // When Steam was last asked anonymously ([lookup]), kept across re-reads of the file.
+        known?.optLong("picsAt")?.takeIf { it > 0 }?.let { entry.put("picsAt", it) }
+        if (read == null) entry.put("miss", true) else entry.put("name", read.name).put("depots", JSONArray(read.sharedDepots))
+        cache.put(appId.toString(), entry)
+        val out = cacheFile.startWrite()
+        try { out.write(cache.toString().toByteArray()); cacheFile.finishWrite(out) } catch (e: Exception) { cacheFile.failWrite(out) }
+        return read
+    }
+
+    /** Steam asked anonymously ([SteamPics]); a test stands in for it. */
+    @androidx.annotation.VisibleForTesting
+    internal var pics: (List<Int>) -> Map<Int, Info?>? = { SteamPics.lookup(it) }
+
+    /**
+     * Of [appIds], those neither the client's cache (appinfo.vdf, read first: free) nor an earlier
+     * answer has, and that Steam was not asked about anonymously in the past week.
+     */
+    fun needLookup(context: Context, appIds: List<Int>): List<Int> {
+        val wanted = appIds.distinct().filter { it > 0 && info(context, it) == null }
+        if (wanted.isEmpty()) return emptyList()
+        val cache = cache(context)
+        val now = System.currentTimeMillis()
+        return wanted.filter { now - (cache.optJSONObject(it.toString())?.optLong("picsAt") ?: 0L) >= RETRY_AFTER_MS }
+    }
+
+    /**
+     * [appIds] the client never saw, asked of Steam anonymously in one connection ([SteamPics], in
+     * batches) and every answer kept like the client's: an app's depots and name, or a miss tried
+     * again in a week. False when nothing needed asking or Steam could not be reached. Blocking.
+     */
+    @Synchronized
+    fun lookup(context: Context, appIds: List<Int>): Boolean {
+        val need = needLookup(context, appIds)
+        if (need.isEmpty()) return false
+        val answers = pics(need) ?: return false
+        val cache = cache(context)
+        val now = System.currentTimeMillis()
+        val mtime = appinfoFile(context).lastModified()
+        for (id in need) {
+            val info = answers[id]
+            val entry = JSONObject().put("at", now).put("mtime", mtime).put("picsAt", now)
+            if (info == null) entry.put("miss", true) else entry.put("name", info.name).put("depots", JSONArray(info.sharedDepots)).put("source", "pics")
+            cache.put(id.toString(), entry)
+        }
+        val file = AtomicFile(File(context.filesDir, CACHE))
+        val out = file.startWrite()
+        try { out.write(cache.toString().toByteArray()); file.finishWrite(out) } catch (e: Exception) { file.failWrite(out) }
+        return true
+    }
+
+    /** What is kept for [appId]: "hit", "miss" or "none" (part of a game's list fingerprint). */
+    fun state(context: Context, appId: Int): String = cache(context).optJSONObject(appId.toString())?.let { if (it.optBoolean("miss")) "miss" else "hit" } ?: "none"
+
+    private fun cache(context: Context): JSONObject =
+        runCatching { JSONObject(AtomicFile(File(context.filesDir, CACHE)).readFully().toString(Charsets.UTF_8)) }.getOrDefault(JSONObject())
+
+    private fun JSONArray?.strings(): List<String> = if (this == null) emptyList() else (0 until length()).map { optString(it) }
+
+    /**
+     * [appId]'s entry in an appinfo.vdf (versions 27, 28 and 29, the last with its keys in a string
+     * table), or null when the file does not have it.
+     */
+    internal fun read(file: File, appId: Int): Info? {
+        if (!file.isFile) return null
+        RandomAccessFile(file, "r").use { raf ->
+            val head = ByteBuffer.allocate(16).order(ByteOrder.LITTLE_ENDIAN)
+            raf.readFully(head.array(), 0, 8)
+            val magic = head.getInt(0)
+            val version = magic and 0xFF
+            if (magic ushr 8 != 0x075644 || version !in 0x27..0x29) return null
+            var strings: List<String>? = null
+            var pos = 8L
+            if (version >= 0x29) {
+                raf.readFully(head.array(), 8, 8)
+                val tableAt = head.getLong(8)
+                strings = readStrings(raf, tableAt)
+                pos = 16L
+            }
+            val fixed = if (version >= 0x28) 4 + 4 + 8 + 20 + 4 + 20 else 4 + 4 + 8 + 20 + 4
+            val entry = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN)
+            while (pos + 8 <= raf.length()) {
+                raf.seek(pos)
+                raf.readFully(entry.array(), 0, 8)
+                val id = entry.getInt(0)
+                val size = entry.getInt(4).toLong() and 0xFFFFFFFFL
+                if (id == 0) return null
+                if (id == appId) {
+                    if (size > 64L * 1024 * 1024) return null
+                    val body = ByteArray(size.toInt())
+                    raf.readFully(body)
+                    val kv = ByteBuffer.wrap(body, fixed, body.size - fixed).order(ByteOrder.LITTLE_ENDIAN)
+                    val tree = readMap(kv, strings)
+                    @Suppress("UNCHECKED_CAST")
+                    val app = (tree["appinfo"] as? Map<String, Any>) ?: tree
+                    return infoOf(app)
+                }
+                pos += 8 + size
+            }
+            return null
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    internal fun infoOf(app: Map<String, Any>): Info {
+        val name = (app["common"] as? Map<String, Any>)?.get("name") as? String ?: ""
+        val depots = (app["depots"] as? Map<String, Any>).orEmpty()
+        val shared = depots.mapNotNull { (key, value) ->
+            val depot = value as? Map<String, Any> ?: return@mapNotNull null
+            key.takeIf { (depot["depotfromapp"] as? String) == SHARED_APP || (key in SteamRedists.DEPOTS && depot["sharedinstall"] != null) }
+        }
+        return Info(name, shared)
+    }
+
+    private fun readStrings(raf: RandomAccessFile, at: Long): List<String> {
+        raf.seek(at)
+        val count = Integer.reverseBytes(raf.readInt())
+        val rest = ByteArray((raf.length() - at - 4).toInt().coerceAtLeast(0))
+        raf.readFully(rest)
+        val out = ArrayList<String>(count)
+        var start = 0
+        for (i in rest.indices) {
+            if (out.size == count) break
+            if (rest[i] == 0.toByte()) { out.add(String(rest, start, i - start, Charsets.UTF_8)); start = i + 1 }
+        }
+        return out
+    }
+
+    private fun cstring(b: ByteBuffer): String {
+        val start = b.position()
+        while (b.get() != 0.toByte()) { }
+        val bytes = ByteArray(b.position() - start - 1)
+        b.position(start); b.get(bytes); b.get()
+        return String(bytes, Charsets.UTF_8)
+    }
+
+    /** One binary key-value map, to its end marker; keys by name, or by index into [strings]. */
+    private fun readMap(b: ByteBuffer, strings: List<String>?): Map<String, Any> {
+        val out = LinkedHashMap<String, Any>()
+        while (b.hasRemaining()) {
+            val type = b.get().toInt() and 0xFF
+            if (type == 0x08) return out
+            val key = if (strings != null) strings.getOrElse(b.int) { "" } else cstring(b)
+            when (type) {
+                0x00 -> out[key] = readMap(b, strings)
+                0x01 -> out[key] = cstring(b)
+                0x02 -> out[key] = b.int.toString()
+                0x03 -> out[key] = b.float.toString()
+                0x07, 0x0A -> out[key] = b.long.toString()
+                else -> return out
+            }
+        }
+        return out
+    }
+}
@@ -0,0 +1,160 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import com.droiddeck.launcher.stores.CredentialCipher
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+
+/**
+ * SteamGridDB, the art source after Steam's store: a game by its Steam appid, else by a search
+ * whose result must carry the same name, then its best-rated grids, heroes, logos and icons.
+ *
+ * The API key: the user's own (Steam settings › Games), sealed with [CredentialCipher] in the
+ * app's files, else the one the build carries (`BuildConfig.SGDB_API_KEY`, from a CI secret), else
+ * none, and then this step is skipped. The key travels only in the Authorization header and is
+ * never logged.
+ */
+object SteamGridDb {
+    private const val TAG = "SteamGridDb"
+    private const val API = "https://www.steamgriddb.com/api/v2"
+    private const val QUERY = "nsfw=false&humor=false"
+
+    @VisibleForTesting
+    @Volatile
+    internal var keys: CredentialCipher.KeyProvider = CredentialCipher.Keystore
+
+    private fun keyFile(context: Context) = File(context.filesDir, "sgdb/key.json")
+
+    /** The key the build carries, or "" (a build without the secret, a fork's PR build). */
+    fun builtInKey(): String = runCatching {
+        Class.forName("com.droiddeck.launcher.BuildConfig").getField("SGDB_API_KEY").get(null) as? String
+    }.getOrNull().orEmpty()
+
+    /** The user's key wins, then the build's; "" when there is neither. */
+    fun pick(user: String, builtIn: String): String = user.trim().ifEmpty { builtIn.trim() }
+
+    fun key(context: Context): String = pick(userKey(context), builtInKey())
+
+    /** The key the user entered, or "". */
+    @Synchronized
+    fun userKey(context: Context): String {
+        val f = keyFile(context)
+        if (!f.isFile) return ""
+        return try {
+            val json = JSONObject(f.readText())
+            if (CredentialCipher.isEnvelope(json)) CredentialCipher.open(json, keys) else json.optString("key")
+        } catch (e: Exception) {
+            if (CredentialCipher.isPermanent(e)) f.delete()
+            Log.w(TAG, "the saved key cannot be read (${e.javaClass.simpleName})")
+            ""
+        }
+    }
+
+    /** Saves the user's key sealed (plain only where the Keystore does not work); "" clears it. */
+    @Synchronized
+    fun setUserKey(context: Context, key: String) {
+        val f = keyFile(context)
+        val value = key.trim()
+        if (value.isEmpty()) { f.delete(); return }
+        f.parentFile?.mkdirs()
+        val text = try {
+            CredentialCipher.seal(value, keys).toString()
+        } catch (e: Exception) {
+            Log.w(TAG, "keystore unavailable, the key stays plain (${e.javaClass.simpleName})")
+            JSONObject().put("key", value).toString()
+        }
+        val tmp = File(f.path + ".tmp")
+        tmp.writeText(text)
+        tmp.setReadable(false, false); tmp.setReadable(true, true)
+        if (!tmp.renameTo(f)) { f.delete(); tmp.renameTo(f) }
+    }
+
+    /** The SteamGridDB game id for [steamAppId], else for a search on [name] that returns the same name; null when neither. */
+    fun gameId(key: String, steamAppId: Int?, name: String): Int? {
+        if (steamAppId != null) {
+            json(key, "$API/games/steam/$steamAppId")?.optJSONObject("data")?.optInt("id")?.takeIf { it > 0 }?.let { return it }
+        }
+        val term = URLEncoder.encode(name, "UTF-8").replace("+", "%20")
+        val results = json(key, "$API/search/autocomplete/$term")?.optJSONArray("data") ?: return null
+        return match(name, (0 until results.length()).map { results.getJSONObject(it) }.map { it.optInt("id") to it.optString("name") })
+    }
+
+    /** The id of the first result whose name matches [name] ([AddedGameArt.nameMatch]); no blind first pick. */
+    internal fun match(name: String, results: List<Pair<Int, String>>): Int? =
+        results.map { (id, got) -> id to AddedGameArt.nameMatch(name, got) }
+            .filter { it.second > 0 && it.first > 0 }
+            .maxByOrNull { it.second }?.first
+
+    /**
+     * Fetches what is missing into [cache] under the names Steam's art uses there (p.jpg,
+     * header.jpg, hero.jpg, logo.png) and the icon as icon-sgdb.png. True when anything arrived.
+     */
+    fun download(key: String, id: Int, cache: File): Boolean {
+        var got = false
+        for ((path, local) in listOf(
+            "grids/game/$id?dimensions=600x900&$QUERY" to "p.jpg",
+            "grids/game/$id?dimensions=460x215,920x430&$QUERY" to "header.jpg",
+            "heroes/game/$id?$QUERY" to "hero.jpg",
+            "logos/game/$id?$QUERY" to "logo.png",
+            "icons/game/$id?$QUERY" to "icon-sgdb.png",
+        )) {
+            val dst = File(cache, local)
+            if (dst.isFile) continue
+            val items = json(key, "$API/$path")?.optJSONArray("data") ?: continue
+            val url = best(items, local.endsWith(".png")) ?: continue
+            val bytes = AddedGameArt.get(url) ?: continue
+            val tmp = File(cache, "$local.tmp")
+            tmp.writeBytes(bytes)
+            if (tmp.renameTo(dst)) { got = true; File(cache, "$local.src").writeText(AddedGameArt.SGDB) }
+        }
+        return got
+    }
+
+    /** The best-scored [limit] images for [slot] of game [id], as (thumbnail, full image) URLs. */
+    fun images(key: String, id: Int, slot: AddedGameArt.Slot, limit: Int): List<Pair<String, String>> {
+        val path = when (slot) {
+            AddedGameArt.Slot.COVER -> "grids/game/$id?dimensions=600x900&$QUERY"
+            AddedGameArt.Slot.BACKGROUND -> "heroes/game/$id?$QUERY"
+            AddedGameArt.Slot.LOGO -> "logos/game/$id?$QUERY"
+            AddedGameArt.Slot.ICON -> "icons/game/$id?$QUERY"
+        }
+        val items = json(key, "$API/$path")?.optJSONArray("data") ?: return emptyList()
+        return ranked(items, pngOnly = slot == AddedGameArt.Slot.LOGO || slot == AddedGameArt.Slot.ICON).take(limit)
+    }
+
+    /** [items] best-scored first, as (thumbnail, full image) URLs; for a .png slot only PNGs. */
+    internal fun ranked(items: JSONArray, pngOnly: Boolean): List<Pair<String, String>> =
+        (0 until items.length()).map { items.getJSONObject(it) }
+            .filter { it.optString("url").startsWith("https://") && (!pngOnly || it.optString("mime") == "image/png" || it.optString("url").endsWith(".png", true)) }
+            .sortedByDescending { it.optInt("score", 0) }
+            .map { (it.optString("thumb").takeIf { t -> t.startsWith("https://") } ?: it.optString("url")) to it.optString("url") }
+
+    /** The highest-scored image's URL; for a .png slot only a PNG. */
+    internal fun best(items: JSONArray, pngOnly: Boolean): String? =
+        (0 until items.length()).map { items.getJSONObject(it) }
+            .filter { it.optString("url").startsWith("https://") && (!pngOnly || it.optString("mime") == "image/png" || it.optString("url").endsWith(".png", true)) }
+            .maxByOrNull { it.optInt("score", 0) }?.optString("url")
+
+    /** A GET with the key in its Authorization header; the body as JSON, or null. Logs the path only. */
+    private fun json(key: String, url: String): JSONObject? {
+        val c = URL(url).openConnection() as HttpURLConnection
+        c.connectTimeout = 10_000
+        c.readTimeout = 15_000
+        c.setRequestProperty("User-Agent", "DroidDeck-launcher")
+        c.setRequestProperty("Authorization", "Bearer $key")
+        return try {
+            if (c.responseCode != 200) { Log.w(TAG, "${URL(url).path}: HTTP ${c.responseCode}"); null }
+            else JSONObject(c.inputStream.use { it.readBytes() }.toString(Charsets.UTF_8)).takeIf { it.optBoolean("success", true) }
+        } catch (e: Exception) {
+            Log.w(TAG, "${URL(url).path}: ${e.javaClass.simpleName}"); null
+        } finally {
+            c.disconnect()
+        }
+    }
+}
@@ -0,0 +1,77 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.AtomicFile
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Which Steam app a game added in DroidDeck is, kept once per game (by its folder) and used by
+ * everything that asks: its art ([AddedGameArt]) and its Windows components ([WinCompSources]),
+ * so the two never disagree.
+ *
+ * [Certainty.FILES]: the game's own files name the appid (steam_appid.txt, also under
+ * steam_settings/ or a parent folder; an emulator ini; Steam's appmanifest) - certain.
+ * [Certainty.NAME]: Steam's store search returned a game of the same name - a guess.
+ * [Certainty.NONE]: neither; a miss is tried again after a week.
+ */
+object SteamMatch {
+    enum class Certainty { FILES, NAME, NONE }
+
+    /** [source]: what gave the appid (GameIdentifier's source, or "store search"). */
+    class Match(val appId: Int?, val certainty: Certainty, val source: String, val checkedAt: Long)
+
+    private const val FILE = "steam-matches.json"
+    private const val RETRY_AFTER_MS = 7L * 24 * 3600 * 1000
+
+    private fun store(context: Context) = AtomicFile(File(context.filesDir, FILE))
+
+    @Synchronized
+    private fun all(context: Context): JSONObject =
+        runCatching { JSONObject(store(context).readFully().toString(Charsets.UTF_8)) }.getOrDefault(JSONObject())
+
+    @Synchronized
+    fun get(context: Context, key: String): Match? = all(context).optJSONObject(key)?.let { o ->
+        Match(
+            o.optInt("appId", 0).takeIf { it > 0 },
+            runCatching { Certainty.valueOf(o.optString("certainty")) }.getOrDefault(Certainty.NONE),
+            o.optString("source"), o.optLong("at"),
+        )
+    }
+
+    @Synchronized
+    fun put(context: Context, key: String, match: Match) {
+        val json = all(context).put(
+            key, JSONObject().put("certainty", match.certainty.name).put("source", match.source).put("at", match.checkedAt)
+                .apply { match.appId?.let { put("appId", it) } },
+        )
+        val atomic = store(context)
+        val out = atomic.startWrite()
+        try { out.write(json.toString().toByteArray()); atomic.finishWrite(out) } catch (e: Exception) { atomic.failWrite(out) }
+    }
+
+    /**
+     * The match for the game in [key] (its folder), [exe] its exe and [name] its title: its files
+     * first, always read again; else the one kept (a name match stays, a miss for a week); else
+     * [legacy], an appid an earlier build's art lookup kept; else [search] on the name, when given.
+     * Blocking ([search] asks the network).
+     */
+    fun resolve(context: Context, key: String, exe: File, name: String, legacy: File? = null, search: ((String) -> Int?)? = null): Match {
+        val now = System.currentTimeMillis()
+        val identity = runCatching { GameIdentifier.identify(exe) }.getOrNull()
+        identity?.appId?.let { id ->
+            return Match(id, Certainty.FILES, identity.source.name.lowercase(), now).also { put(context, key, it) }
+        }
+        val known = get(context, key)
+        if (known != null && known.certainty == Certainty.NAME) return known
+        if (known != null && known.certainty == Certainty.NONE && now - known.checkedAt < RETRY_AFTER_MS) return known
+        legacy?.takeIf { it.isFile }?.let { runCatching { it.readText().trim().toInt() }.getOrNull() }?.takeIf { it > 0 }?.let { id ->
+            return Match(id, Certainty.NAME, "store search", now).also { put(context, key, it) }
+        }
+        if (search == null) return known?.takeIf { it.certainty != Certainty.FILES } ?: Match(null, Certainty.NONE, "", 0)
+        val id = runCatching { search(name) }.getOrNull()
+        val match = if (id != null && id > 0) Match(id, Certainty.NAME, "store search", now) else Match(null, Certainty.NONE, "", now)
+        put(context, key, match)
+        return match
+    }
+}
@@ -0,0 +1,334 @@
+package com.droiddeck.launcher.frontend
+
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import org.json.JSONObject
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.DataInputStream
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.security.SecureRandom
+import java.util.zip.GZIPInputStream
+import javax.net.ssl.SSLSocket
+import javax.net.ssl.SSLSocketFactory
+
+/**
+ * Steam's own app info (PICS) for apps the client in the runtime has never seen, asked of Steam
+ * anonymously: a connection to one of Steam's connection managers (the list from Steam's public
+ * ISteamDirectory/GetCMListForConnect, the WebSocket transport Steam's web clients use), an
+ * anonymous logon - no account, nothing of the user's Steam sign-in - a request for the apps'
+ * access tokens and then their product info, the app KeyValues read for their Steamworks Shared
+ * depots and name, and the connection closed. What steamcmd's anonymous `app_info_print` sees.
+ */
+object SteamPics {
+    private const val TAG = "SteamPics"
+    private const val CM_LIST = "https://api.steampowered.com/ISteamDirectory/GetCMListForConnect/v1/?cellid=0&format=json"
+    /** At most this many apps per request. */
+    const val BATCH = 25
+    private const val PROTO = 0x80000000.toInt()
+    private const val EMSG_MULTI = 1
+    private const val EMSG_LOGON = 5514
+    private const val EMSG_LOGON_RESPONSE = 751
+    private const val EMSG_LOGOFF = 706
+    private const val EMSG_TOKENS_REQUEST = 8905
+    private const val EMSG_TOKENS_RESPONSE = 8906
+    private const val EMSG_INFO_REQUEST = 8903
+    private const val EMSG_INFO_RESPONSE = 8904
+    private const val PROTOCOL_VERSION = 65580
+    /** An anonymous user's SteamID: universe Public, account type AnonUser, instance 0. */
+    private const val ANON_STEAMID = (1L shl 56) or (10L shl 52)
+
+    /**
+     * [appIds]' info, one connection for all of them in batches of [BATCH]: each known app's
+     * info, null for an app Steam does not know. Null when Steam could not be reached. Blocking.
+     */
+    fun lookup(appIds: List<Int>): Map<Int, SteamAppInfo.Info?>? {
+        if (appIds.isEmpty()) return emptyMap()
+        val host = runCatching { cmHost() }.getOrNull() ?: return null
+        return try {
+            Wss(host, 20_000).use { ws ->
+                ws.send(message(EMSG_LOGON, header(ANON_STEAMID, 0), Proto().varint(1, PROTOCOL_VERSION.toLong()).varint(7, 16).string(6, "english").bytes()))
+                var steamId = 0L
+                var session = 0
+                // The logon's answer (other messages before it are passed over).
+                loop@ while (true) for ((emsg, hdr, body) in messages(ws.receive() ?: return null)) if (emsg == EMSG_LOGON_RESPONSE) {
+                    val h = fields(hdr); val b = fields(body)
+                    if ((b[1]?.firstOrNull() as? Long ?: 0L) != 1L) { Log.w(TAG, "anonymous logon refused: ${b[1]}"); return null }
+                    steamId = h[1]?.firstOrNull() as? Long ?: 0L
+                    session = (h[2]?.firstOrNull() as? Long ?: 0L).toInt()
+                    break@loop
+                }
+                val out = HashMap<Int, SteamAppInfo.Info?>()
+                for (batch in batches(appIds)) {
+                    val tokens = HashMap<Int, Long>()
+                    ws.send(message(EMSG_TOKENS_REQUEST, header(steamId, session), Proto().apply { batch.forEach { varint(2, it.toLong()) } }.bytes()))
+                    tokens@ while (true) for ((emsg, _, body) in messages(ws.receive() ?: return null)) if (emsg == EMSG_TOKENS_RESPONSE) {
+                        for (t in fields(body)[3].orEmpty()) {
+                            val f = fields(t as ByteArray)
+                            val id = (f[1]?.firstOrNull() as? Long)?.toInt() ?: continue
+                            tokens[id] = f[2]?.firstOrNull() as? Long ?: 0L
+                        }
+                        break@tokens
+                    }
+                    ws.send(message(EMSG_INFO_REQUEST, header(steamId, session), Proto().apply {
+                        batch.forEach { id -> bytes(2, Proto().varint(1, id.toLong()).apply { tokens[id]?.takeIf { it != 0L }?.let { varint(2, it) } }.bytes()) }
+                        varint(3, 0)
+                    }.bytes()))
+                    var pending = true
+                    while (pending) for ((emsg, _, body) in messages(ws.receive() ?: return null)) if (emsg == EMSG_INFO_RESPONSE) {
+                        val r = parseInfoResponse(body)
+                        out.putAll(r.apps)
+                        r.unknown.forEach { out[it] = null }
+                        pending = r.pending
+                    }
+                    batch.forEach { if (it !in out) out[it] = null }
+                }
+                runCatching { ws.send(message(EMSG_LOGOFF, header(steamId, session), ByteArray(0))) }
+                Log.i(TAG, "steam pics: ${out.size} apps, ${out.values.count { it?.sharedDepots?.isNotEmpty() == true }} with shared redists")
+                out
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "steam pics: ${e.javaClass.simpleName}: ${e.message}")
+            null
+        }
+    }
+
+    /** [appIds] in requests of at most [BATCH], each once. */
+    fun batches(appIds: List<Int>): List<List<Int>> = appIds.distinct().chunked(BATCH)
+
+    /** A connection manager for the WebSocket transport, least loaded first as Steam lists them. */
+    private fun cmHost(): String? {
+        val c = URL(CM_LIST).openConnection() as HttpURLConnection
+        c.connectTimeout = 10_000; c.readTimeout = 10_000
+        val body = try { c.inputStream.bufferedReader().readText() } finally { c.disconnect() }
+        val list = JSONObject(body).optJSONObject("response")?.optJSONArray("serverlist") ?: return null
+        return (0 until list.length()).mapNotNull { list.optJSONObject(it) }
+            .firstOrNull { it.optString("type") == "websockets" }?.optString("endpoint")?.substringBefore(':')
+    }
+
+    // ---- the product info answer ----
+
+    class InfoResponse(val apps: Map<Int, SteamAppInfo.Info>, val unknown: List<Int>, val pending: Boolean)
+
+    /** A CMsgClientPICSProductInfoResponse: each app's KeyValues read, the unknown ones, whether more follows. */
+    @VisibleForTesting
+    internal fun parseInfoResponse(body: ByteArray): InfoResponse {
+        val f = fields(body)
+        val apps = HashMap<Int, SteamAppInfo.Info>()
+        for (a in f[1].orEmpty()) {
+            val app = fields(a as ByteArray)
+            val id = (app[1]?.firstOrNull() as? Long)?.toInt() ?: continue
+            val buffer = app[5]?.firstOrNull() as? ByteArray ?: continue
+            val text = String(buffer, Charsets.UTF_8).trimEnd('\u0000')
+            infoFromKeyValues(text)?.let { apps[id] = it }
+        }
+        val unknown = f[2].orEmpty().mapNotNull { (it as? Long)?.toInt() } + f[2].orEmpty().filterIsInstance<ByteArray>().flatMap { packed(it) }
+        return InfoResponse(apps, unknown, (f[6]?.firstOrNull() as? Long ?: 0L) != 0L)
+    }
+
+    /** An app's KeyValues text ("appinfo" { "common" {...} "depots" {...} }) to its name and shared depots. */
+    @VisibleForTesting
+    internal fun infoFromKeyValues(text: String): SteamAppInfo.Info? {
+        // The buffer ends in a NUL, kept or not by whoever handed it over.
+        val tree = runCatching { KeyValues(text.trimEnd('\u0000', ' ', '\n', '\r', '\t')).read() }.getOrNull() ?: return null
+        @Suppress("UNCHECKED_CAST")
+        val app = tree["appinfo"] as? Map<String, Any> ?: return null
+        return SteamAppInfo.infoOf(app)
+    }
+
+    /** Valve's text KeyValues: quoted keys and values, nested braces. */
+    private class KeyValues(private val s: String) {
+        private var i = 0
+        fun read(): Map<String, Any> = map(top = true)
+        private fun map(top: Boolean): Map<String, Any> {
+            val out = LinkedHashMap<String, Any>()
+            while (true) {
+                skip()
+                if (i >= s.length) { if (top) return out else throw IOException("unclosed") }
+                if (s[i] == '}') { i++; return out }
+                val key = token()
+                skip()
+                if (i < s.length && s[i] == '{') { i++; out[key] = map(top = false) } else out[key] = token()
+            }
+        }
+        private fun skip() {
+            while (i < s.length) {
+                if (s[i].isWhitespace() || s[i] == '\u0000') i++
+                else if (s.startsWith("//", i)) { while (i < s.length && s[i] != '\n') i++ }
+                else break
+            }
+        }
+        private fun token(): String {
+            if (i < s.length && s[i] == '"') {
+                i++
+                val b = StringBuilder()
+                while (i < s.length && s[i] != '"') {
+                    if (s[i] == '\\' && i + 1 < s.length) { i++; b.append(when (s[i]) { 'n' -> '\n'; 't' -> '\t'; else -> s[i] }) } else b.append(s[i])
+                    i++
+                }
+                i++
+                return b.toString()
+            }
+            val start = i
+            while (i < s.length && !s[i].isWhitespace() && s[i] != '{' && s[i] != '}') i++
+            if (start == i) throw IOException("token expected at $i")
+            return s.substring(start, i)
+        }
+    }
+
+    // ---- messages ----
+
+    private fun header(steamId: Long, session: Int) = Proto().fixed64(1, steamId).varint(2, session.toLong()).bytes()
+
+    private fun message(emsg: Int, header: ByteArray, body: ByteArray): ByteArray =
+        ByteBuffer.allocate(8 + header.size + body.size).order(ByteOrder.LITTLE_ENDIAN)
+            .putInt(emsg or PROTO).putInt(header.size).put(header).put(body).array()
+
+    /** One message off the wire as (emsg, header, body); a Multi unpacked (gunzipped when it says so) into the ones inside. */
+    @VisibleForTesting
+    internal fun messages(data: ByteArray): List<Triple<Int, ByteArray, ByteArray>> {
+        if (data.size < 8) return emptyList()
+        val b = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        val raw = b.int
+        if (raw and PROTO == 0) return emptyList()
+        val emsg = raw and PROTO.inv()
+        val hl = b.int
+        if (hl < 0 || 8 + hl > data.size) return emptyList()
+        val header = data.copyOfRange(8, 8 + hl)
+        val body = data.copyOfRange(8 + hl, data.size)
+        if (emsg != EMSG_MULTI) return listOf(Triple(emsg, header, body))
+        val f = fields(body)
+        var inner = f[2]?.firstOrNull() as? ByteArray ?: return emptyList()
+        if ((f[1]?.firstOrNull() as? Long ?: 0L) > 0) inner = GZIPInputStream(ByteArrayInputStream(inner)).use { it.readBytes() }
+        val out = ArrayList<Triple<Int, ByteArray, ByteArray>>()
+        val ib = ByteBuffer.wrap(inner).order(ByteOrder.LITTLE_ENDIAN)
+        while (ib.remaining() >= 4) {
+            val len = ib.int
+            if (len < 0 || len > ib.remaining()) break
+            val one = ByteArray(len).also { ib.get(it) }
+            out.addAll(messages(one))
+        }
+        return out
+    }
+
+    // ---- protobuf, the little needed ----
+
+    /** Writes protobuf fields. */
+    @VisibleForTesting
+    internal class Proto {
+        private val out = ByteArrayOutputStream()
+        private fun raw(v: Long) { var x = v; while (true) { val b = (x and 0x7F).toInt(); x = x ushr 7; if (x == 0L) { out.write(b); return }; out.write(b or 0x80) } }
+        fun varint(field: Int, v: Long) = apply { raw((field shl 3).toLong()); raw(v) }
+        fun fixed64(field: Int, v: Long) = apply { raw(((field shl 3) or 1).toLong()); for (k in 0 until 8) out.write(((v ushr (8 * k)) and 0xFF).toInt()) }
+        fun bytes(field: Int, b: ByteArray) = apply { raw(((field shl 3) or 2).toLong()); raw(b.size.toLong()); out.write(b) }
+        fun string(field: Int, s: String) = bytes(field, s.toByteArray())
+        fun bytes(): ByteArray = out.toByteArray()
+    }
+
+    /** Reads protobuf fields: number to values (Long for varint and fixed, ByteArray for length-delimited). */
+    @VisibleForTesting
+    internal fun fields(b: ByteArray): Map<Int, List<Any>> {
+        val out = HashMap<Int, MutableList<Any>>()
+        var i = 0
+        fun varint(): Long { var v = 0L; var s = 0; while (true) { val c = b[i++].toInt() and 0xFF; v = v or ((c and 0x7F).toLong() shl s); s += 7; if (c < 0x80) return v } }
+        while (i < b.size) {
+            val key = varint()
+            val field = (key ushr 3).toInt()
+            val value: Any = when ((key and 7).toInt()) {
+                0 -> varint()
+                1 -> { var v = 0L; for (k in 0 until 8) v = v or ((b[i + k].toLong() and 0xFF) shl (8 * k)); i += 8; v }
+                5 -> { var v = 0L; for (k in 0 until 4) v = v or ((b[i + k].toLong() and 0xFF) shl (8 * k)); i += 4; v }
+                2 -> { val n = varint().toInt(); val v = b.copyOfRange(i, i + n); i += n; v }
+                else -> throw IOException("wire type ${key and 7}")
+            }
+            out.getOrPut(field) { ArrayList() }.add(value)
+        }
+        return out
+    }
+
+    private fun packed(b: ByteArray): List<Int> {
+        val out = ArrayList<Int>(); var i = 0
+        while (i < b.size) { var v = 0L; var s = 0; while (true) { val c = b[i++].toInt() and 0xFF; v = v or ((c and 0x7F).toLong() shl s); s += 7; if (c < 0x80) break }; out.add(v.toInt()) }
+        return out
+    }
+
+    // ---- WebSocket over TLS, binary frames ----
+
+    private class Wss(host: String, timeoutMs: Int) : AutoCloseable {
+        // Made with the host name, so it goes out as SNI.
+        private val socket: SSLSocket = (SSLSocketFactory.getDefault().createSocket(host, 443) as SSLSocket).apply { soTimeout = timeoutMs }
+        private val out: OutputStream
+        private val input: DataInputStream
+
+        init {
+            // Host name checked against the certificate, as HTTPS does.
+            socket.sslParameters = socket.sslParameters.apply { endpointIdentificationAlgorithm = "HTTPS" }
+            socket.startHandshake()
+            out = socket.outputStream
+            input = DataInputStream(socket.inputStream)
+            val key = ByteArray(16).also { SecureRandom().nextBytes(it) }
+            out.write(("GET /cmsocket/ HTTP/1.1\r\nHost: $host\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" +
+                "Sec-WebSocket-Key: ${android.util.Base64.encodeToString(key, android.util.Base64.NO_WRAP)}\r\nSec-WebSocket-Version: 13\r\n\r\n").toByteArray())
+            out.flush()
+            val status = line(input) ?: throw IOException("no upgrade response")
+            if (!status.contains(" 101 ")) throw IOException("upgrade refused: $status")
+            while (true) { val l = line(input) ?: break; if (l.isEmpty()) break }
+        }
+
+        private fun line(s: InputStream): String? {
+            val buf = ByteArrayOutputStream()
+            while (true) {
+                val b = s.read()
+                if (b < 0) return if (buf.size() == 0) null else buf.toString("UTF-8")
+                if (b == '\n'.code) return buf.toString("UTF-8").trimEnd('\r')
+                buf.write(b)
+            }
+        }
+
+        fun send(payload: ByteArray) {
+            val mask = ByteArray(4).also { SecureRandom().nextBytes(it) }
+            val frame = ByteArrayOutputStream()
+            frame.write(0x82)
+            when {
+                payload.size < 126 -> frame.write(0x80 or payload.size)
+                payload.size < 65536 -> { frame.write(0x80 or 126); frame.write(payload.size ushr 8); frame.write(payload.size and 0xFF) }
+                else -> { frame.write(0x80 or 127); for (k in 7 downTo 0) frame.write(((payload.size.toLong() ushr (8 * k)) and 0xFF).toInt()) }
+            }
+            frame.write(mask)
+            for (k in payload.indices) frame.write((payload[k].toInt() xor mask[k % 4].toInt()) and 0xFF)
+            out.write(frame.toByteArray()); out.flush()
+        }
+
+        /** The next binary message (fragments joined); null on close. */
+        fun receive(): ByteArray? {
+            val message = ByteArrayOutputStream()
+            while (true) {
+                val b0 = input.read(); if (b0 < 0) return null
+                val b1 = input.read(); if (b1 < 0) return null
+                val fin = b0 and 0x80 != 0
+                val opcode = b0 and 0x0F
+                var len = (b1 and 0x7F).toLong()
+                if (len == 126L) len = input.readUnsignedShort().toLong() else if (len == 127L) len = input.readLong()
+                if (len > 32L * 1024 * 1024) throw IOException("frame too large")
+                val data = ByteArray(len.toInt()).also { input.readFully(it) }
+                when (opcode) {
+                    0x8 -> return null
+                    0x9 -> { out.write(byteArrayOf(0x8A.toByte(), 0x80.toByte(), 0, 0, 0, 0)); out.flush() }
+                    0x2, 0x0 -> { message.write(data); if (fin) return message.toByteArray() }
+                    else -> {}
+                }
+            }
+        }
+
+        override fun close() {
+            runCatching { out.write(byteArrayOf(0x88.toByte(), 0x80.toByte(), 0, 0, 0, 0)); out.flush() }
+            runCatching { socket.close() }
+        }
+    }
+}
@@ -0,0 +1,46 @@
+package com.droiddeck.launcher.frontend
+
+import java.io.File
+
+/**
+ * What Steam itself installs alongside a game: the Steamworks Shared redistributables (app 228980)
+ * listed under "SharedDepots" in the game's appmanifest. Those live in Steamworks Shared rather than
+ * the game's folder, so the folder scan ([DependencyDetector]) cannot see them; this reads Steam's
+ * list instead. Depots are matched to Bannerlator's catalog names; unknown ones are left out.
+ */
+object SteamRedists {
+    /** Steamworks Shared depot -> (catalog component, what Steam calls it). 2015-2019 runtimes are one family. */
+    val DEPOTS = linkedMapOf(
+        "228981" to ("vcredist2005_dll" to "VC++ 2005"),
+        "228982" to ("vcredist2008_dll" to "VC++ 2008"),
+        "228983" to ("vcredist2010_dll" to "VC++ 2010"),
+        "228984" to ("vcredist2012_dll" to "VC++ 2012"),
+        "228985" to ("vcredist2013_dll" to "VC++ 2013"),
+        "228986" to ("vcredist2015_dll" to "VC++ 2015"),
+        "228987" to ("vcredist2019_dll" to "VC++ 2017"),
+        "228988" to ("vcredist2019_dll" to "VC++ 2019"),
+        "228989" to ("vcredist2022_dll" to "VC++ 2022"),
+        "228990" to ("d3dx9" to "DirectX (June 2010)"),
+    )
+    private val BLOCK = Regex("\"SharedDepots\"\\s*\\{([^}]*)\\}", RegexOption.IGNORE_CASE)
+    private val ENTRY = Regex("\"(\\d+)\"\\s+\"\\d+\"")
+
+    /** The game's appmanifest beside its install folder (steamapps/common/<dir> -> steamapps/). */
+    fun manifest(gameDir: File?, appId: Int): File? {
+        val steamapps = gameDir?.parentFile?.parentFile ?: return null
+        return File(steamapps, "appmanifest_$appId.acf").takeIf { it.isFile }
+    }
+
+    fun detect(gameDir: File?, appId: Int): List<DependencyDetector.Recommendation> {
+        val text = try {
+            manifest(gameDir, appId)?.takeIf { it.length() < 1L shl 20 }?.readText() ?: return emptyList()
+        } catch (_: Exception) {
+            return emptyList()
+        }
+        val block = BLOCK.find(text)?.groupValues?.get(1) ?: return emptyList()
+        return ENTRY.findAll(block).mapNotNull { DEPOTS[it.groupValues[1]] }
+            .distinctBy { it.first }
+            .map { (component, label) -> DependencyDetector.Recommendation(component, label, label, DependencyDetector.Kind.STEAM) }
+            .toList()
+    }
+}
@@ -0,0 +1,98 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import android.util.AtomicFile
+import android.util.Log
+import androidx.annotation.VisibleForTesting
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import com.droiddeck.launcher.stores.epic.EpicApiClient
+import com.droiddeck.launcher.stores.epic.EpicCredentialStore
+import com.droiddeck.launcher.stores.epic.EpicDownloadManager
+import com.droiddeck.launcher.stores.gog.GogAuth
+import com.droiddeck.launcher.stores.gog.GogDownloadManager
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * For a GOG or Epic game installed before its sidecar kept the store's list (GOG's build
+ * `dependencies`, Epic's manifest prerequisite): the list read once from the store's build
+ * manifest with the saved sign-in - the manifest alone, never a game file - and kept in the sidecar
+ * the way an install keeps it. Runs on the components' worker ([AutoComponents]). Without a
+ * sign-in or a network it is skipped quietly and tried again a week later.
+ */
+object StoreListBackfill {
+    private const val TAG = "StoreListBackfill"
+    private const val FILE = "store-list-backfill.json"
+    private const val RETRY_AFTER_MS = 7L * 24 * 3600 * 1000
+
+    /** The store's list for the game in a sidecar: GOG's dependency ids, or Epic's prerequisite {name, path}; null when it could not be had. */
+    fun interface Fetcher {
+        fun fetch(context: Context, sidecar: StoreGameSidecar): Map<String, String>?
+    }
+
+    /** The store itself, with the saved sign-in. */
+    internal val storeFetcher = Fetcher { context, sidecar -> fromStore(context, sidecar) }
+
+    @VisibleForTesting internal var fetcher: Fetcher = storeFetcher
+
+    /** Whether [sidecar] was written before the list was kept. */
+    /**
+     * Whether [sidecar] has no list read whole: written before the list was kept, or by a build
+     * that could have written an empty one for a manifest it did not read right.
+     */
+    fun needs(sidecar: StoreGameSidecar): Boolean =
+        (sidecar.store == Store.GOG || sidecar.store == Store.EPIC) && WinCompSources.LIST_READ !in sidecar.extra
+
+    /**
+     * The list for the game in [folder], fetched and kept when its sidecar lacks one and it was not
+     * tried in the past week. True when the sidecar changed. Blocking (network).
+     */
+    @Synchronized
+    fun fill(context: Context, folder: File): Boolean {
+        val sidecar = StoreGameSidecar.read(folder)?.takeIf { it.isInstalled && needs(it) } ?: return false
+        val tries = runCatching { JSONObject(AtomicFile(File(context.filesDir, FILE)).readFully().toString(Charsets.UTF_8)) }.getOrDefault(JSONObject())
+        val now = System.currentTimeMillis()
+        if (now - tries.optLong(folder.path, 0L) < RETRY_AFTER_MS) return false
+        // Offline is no try: it waits for a network rather than a week.
+        if (!AutoComponents.online(context)) return false
+        val list = runCatching { fetcher.fetch(context, sidecar) }.getOrNull()
+        if (list == null) {
+            tries.put(folder.path, now)
+            val atomic = AtomicFile(File(context.filesDir, FILE))
+            val out = atomic.startWrite()
+            try { out.write(tries.toString().toByteArray()); atomic.finishWrite(out) } catch (e: Exception) { atomic.failWrite(out) }
+            Log.i(TAG, "${sidecar.title}: the ${sidecar.store.label} list could not be had; again in a week")
+            return false
+        }
+        // Read fresh and written whole, as an install writes it: only the list is added.
+        val current = StoreGameSidecar.read(folder) ?: return false
+        current.copy(extra = current.extra + list + (WinCompSources.LIST_READ to "1")).write(folder)
+        Log.i(TAG, "backfill: ${sidecar.title} " + when (sidecar.store) {
+            Store.GOG -> "gog deps=[${list[WinCompSources.GOG_DEPENDENCIES].orEmpty()}]"
+            else -> "epic prereq=" + (list[WinCompSources.EPIC_PREREQ_NAME].orEmpty().ifEmpty { list[WinCompSources.EPIC_PREREQ_PATH].orEmpty() }.ifEmpty { "none" })
+        })
+        return true
+    }
+
+    private fun fromStore(context: Context, sidecar: StoreGameSidecar): Map<String, String>? {
+        return when (sidecar.store) {
+            Store.GOG -> {
+                val token = GogAuth.validToken(context) ?: return null
+                GogDownloadManager.fetchDependencies(sidecar.id, sidecar.installVersion, token)
+                    ?.let { mapOf(WinCompSources.GOG_DEPENDENCIES to it.joinToString(",")) }
+            }
+            Store.EPIC -> {
+                val token = EpicCredentialStore.getValidAccessToken(context) ?: return null
+                val namespace = sidecar.extra["namespace"].orEmpty()
+                val catalogItemId = sidecar.extra["catalogItemId"].orEmpty()
+                if (namespace.isEmpty() || catalogItemId.isEmpty()) return null
+                val json = EpicApiClient.getManifestApiJson(token, namespace, catalogItemId, sidecar.extra["appName"] ?: sidecar.id) ?: return null
+                EpicDownloadManager.fetchPrereq(json)?.let { (name, path) ->
+                    mapOf(WinCompSources.EPIC_PREREQ_NAME to name, WinCompSources.EPIC_PREREQ_PATH to path)
+                }
+            }
+            else -> null
+        }
+    }
+}
@@ -0,0 +1,160 @@
+package com.droiddeck.launcher.frontend
+
+import android.content.Context
+import com.droiddeck.launcher.stores.Store
+import com.droiddeck.launcher.stores.StoreGameSidecar
+import org.json.JSONObject
+import java.io.File
+import java.util.Locale
+
+/**
+ * Which Windows components a game needs, from the list its source keeps - the source badge decides
+ * which list is trusted:
+ *
+ * - **Steam**: the Steamworks Shared redistributables Steam installs with the game (its
+ *   appmanifest's SharedDepots, else the client's app info) - turned on by themselves.
+ * - **GOG**: the build manifest's `dependencies`, kept in the sidecar at install - on by themselves.
+ * - **Epic Games**: the manifest's prerequisite (usually UE4/UE5's prerequisite setup: VC++ and the
+ *   DirectX June 2010 runtime), kept in the sidecar at install - on by themselves.
+ * - **Amazon Games**: fuel.json's PostInstall installers - on by themselves.
+ * - **Custom** whose files name a Steam appid ([SteamMatch], certain): Steam's list for that app -
+ *   on by themselves. Matched by name only: the same list as Recommended. No match: the folder scan
+ *   ([DependencyDetector]) as Recommended.
+ *
+ * Every store entry is mapped to catalog names here, in one place; one that maps to nothing is a
+ * suggestion under its own name. The folder scan is offered as Recommended for every game.
+ */
+object WinCompSources {
+    /** Whose list a finding came from; the reason line says it. */
+    enum class Origin { STEAM, GOG, EPIC, AMAZON, STEAM_NAME, FOLDER }
+
+    /**
+     * One thing a list names: [component] the catalog name it maps to (null: none, a suggestion),
+     * [original] what the list called it, [auto] whether it is turned on by itself, [args] what
+     * the reason line names (Steam: the label, the game, the appid).
+     */
+    data class Finding(val component: String?, val original: String, val origin: Origin, val auto: Boolean, val args: List<String> = emptyList())
+
+    // ---- mapping tables: a store's names -> catalog components ----
+
+    private val VC_YEAR = mapOf(
+        "2005" to "vcredist2005", "2008" to "vcredist2008", "2010" to "vcredist2010", "2012" to "vcredist2012",
+        "2013" to "vcredist2013", "2015" to "vcredist2015", "2017" to "vcredist2015", "2019" to "vcredist2019", "2022" to "vcredist2022",
+    )
+    private val DOTNET = mapOf(
+        "35" to "dotnet35", "40" to "dotnet40", "45" to "dotnet45", "451" to "dotnet452", "452" to "dotnet452",
+        "46" to "dotnet46", "461" to "dotnet46", "462" to "dotnet46", "47" to "dotnet472", "471" to "dotnet472",
+        "472" to "dotnet472", "48" to "dotnet48", "481" to "dotnet48",
+    )
+
+    /**
+     * A GOG dependency id ("MSVC2017_x64", "DirectX", "DOTNET48", "PhysX", "OpenAL", "XNA4") to its
+     * components; empty for one that is none of ours (ISI scripts, GOG's own helpers).
+     */
+    fun gog(id: String): List<String> {
+        val key = id.uppercase(Locale.US).replace(Regex("[^A-Z0-9]"), "")
+        Regex("""^(?:MSVC|VCREDIST|VC)(\d{4})""").find(key)?.let { m -> return listOfNotNull(VC_YEAR[m.groupValues[1]]) }
+        Regex("""^(?:DOTNET|NETFRAMEWORK|DOTNETFRAMEWORK)(\d{2,3})""").find(key)?.let { m -> return listOfNotNull(DOTNET[m.groupValues[1]]) }
+        return when {
+            key.startsWith("DIRECTX") || key.startsWith("DX9") || key == "DXSETUP" || key.startsWith("D3DX") -> listOf("d3dx9")
+            key.startsWith("PHYSX") -> listOf("physx")
+            key.startsWith("OPENAL") -> listOf("oalinst")
+            key == "XNA31" || key == "XNA3" -> listOf("xna31")
+            key.startsWith("XNA") -> listOf("xna40")
+            key.startsWith("XLIVE") || key.startsWith("GFWL") -> listOf("XLiveRedist")
+            key.startsWith("XACT") -> listOf("xact")
+            else -> emptyList()
+        }
+    }
+
+    /** Unreal's prerequisite setup (UE4PrereqSetup_x64.exe, UEPrereqSetup_x64.exe): VC++ 2015-2022 and DirectX June 2010. */
+    private val UE_PREREQ = Regex("""(?i)ue\d?prereqsetup""")
+
+    /** An Epic prerequisite ([path] the installer it runs, [name] what it is called) to its components. */
+    fun epic(path: String, name: String): List<String> = when {
+        UE_PREREQ.containsMatchIn(path) || name.contains("UE4 Prerequisites", true) || name.contains("UE5 Prerequisites", true) ||
+            name.contains("Unreal Engine Prerequisites", true) -> listOf("vcredist2022", "d3dx9")
+        else -> DependencyDetector.componentsFor(path).ifEmpty { if (path.isEmpty()) gog(name) else emptyList() }
+    }
+
+    /** An installer a store runs after an install (Amazon's PostInstall "Command") to its components. */
+    fun installer(path: String): List<String> = if (UE_PREREQ.containsMatchIn(path)) listOf("vcredist2022", "d3dx9") else DependencyDetector.componentsFor(path)
+
+    /** Steamworks Shared depot ids to (component, Steam's label). */
+    fun steamDepots(ids: List<String>): List<Pair<String, String>> = ids.mapNotNull { SteamRedists.DEPOTS[it] }.distinctBy { it.first }
+
+    // ---- what each store left at install ----
+
+    /** Sidecar keys the store installs fill. */
+    const val GOG_DEPENDENCIES = "dependencies"
+    const val EPIC_PREREQ_PATH = "prereqPath"
+    const val EPIC_PREREQ_NAME = "prereqName"
+    /** Set beside the list when it was read whole (an empty list then means the store lists none). */
+    const val LIST_READ = "listRead"
+
+    /** fuel.json's PostInstall commands. */
+    fun amazonPostInstall(folder: File): List<String> = runCatching {
+        val arr = JSONObject(File(folder, "fuel.json").readText()).optJSONArray("PostInstall") ?: return emptyList()
+        (0 until arr.length()).mapNotNull { arr.optJSONObject(it)?.optString("Command")?.takeIf { c -> c.isNotEmpty() } }
+    }.getOrDefault(emptyList())
+
+    // ---- per game ----
+
+    /** Steam's list for [appId]: the local appmanifest's SharedDepots, else the client's app info. */
+    fun steamList(context: Context, gameDir: File?, appId: Int, gameName: String, auto: Boolean): List<Finding> {
+        val local = SteamRedists.detect(gameDir, appId)
+        val pairs = if (local.isNotEmpty()) local.map { it.componentName to it.label }
+        else SteamAppInfo.info(context, appId)?.let { steamDepots(it.sharedDepots) }.orEmpty()
+        return pairs.map { (component, label) ->
+            Finding(component, label, if (auto) Origin.STEAM else Origin.STEAM_NAME, auto, listOf(label, gameName, appId.toString()))
+        }
+    }
+
+    /** Everything known for [game], blocking (files; the client's app info; no network). */
+    fun forGame(context: Context, game: Library.SteamGame): List<Finding> {
+        val folder = game.gameFiles
+        val out = ArrayList<Finding>()
+        val store = Store.byId(game.source)
+        val sidecar = folder?.let { StoreGameSidecar.read(it) }
+        when {
+            game.library != Library.ADDED -> if (game.appId > 0) out += steamList(context, folder, game.appId, game.name, auto = true)
+            store == Store.GOG -> sidecar?.extra?.get(GOG_DEPENDENCIES)?.split(',')?.map { it.trim() }?.filter { it.isNotEmpty() }?.forEach { id ->
+                val parts = gog(id)
+                if (parts.isEmpty()) out += Finding(null, id, Origin.GOG, false)
+                parts.forEach { out += Finding(it, id, Origin.GOG, true) }
+            }
+            store == Store.EPIC -> {
+                val path = sidecar?.extra?.get(EPIC_PREREQ_PATH).orEmpty()
+                val name = sidecar?.extra?.get(EPIC_PREREQ_NAME).orEmpty()
+                if (path.isNotEmpty() || name.isNotEmpty()) {
+                    val parts = epic(path, name)
+                    val original = name.ifEmpty { path.substringAfterLast('/') }
+                    if (parts.isEmpty()) out += Finding(null, original, Origin.EPIC, false)
+                    parts.forEach { out += Finding(it, original, Origin.EPIC, true) }
+                }
+            }
+            store == Store.AMAZON -> folder?.let { amazonPostInstall(it) }?.forEach { command ->
+                val parts = installer(command)
+                val original = command.replace('\\', '/').substringAfterLast('/')
+                if (parts.isEmpty()) out += Finding(null, original, Origin.AMAZON, false)
+                parts.forEach { out += Finding(it, original, Origin.AMAZON, true) }
+            }
+            else -> {}
+        }
+        // A game added in DroidDeck (Custom, or a store's) that is a Steam app: Steam's list for it,
+        // on by itself when its files say so, else only recommended.
+        if (game.library == Library.ADDED && folder != null) SteamMatch.get(context, folder.path)?.let { match ->
+            val id = match.appId ?: return@let
+            when (match.certainty) {
+                SteamMatch.Certainty.FILES -> out += steamList(context, folder, id, game.name, auto = true)
+                SteamMatch.Certainty.NAME -> out += steamList(context, folder, id, game.name, auto = false)
+                else -> {}
+            }
+        }
+        // The folder scan, for every game: what it bundles, as Recommended.
+        folder?.let { DependencyDetector.detect(it) }?.forEach { rec ->
+            out += Finding(rec.componentName, rec.reason, Origin.FOLDER, false, listOf(rec.reason, rec.kind.name))
+        }
+        return out
+    }
+}